drivers/net/pcmcia/smc91c92_cs.c

   1 /*======================================================================
   2
   3     A PCMCIA ethernet driver for SMC91c92-based cards.
   4
   5     This driver supports Megahertz PCMCIA ethernet cards; and
   6     Megahertz, Motorola, Ositech, and Psion Dacom ethernet/modem
   7     multifunction cards.
   8
   9     Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
  10
  11     smc91c92_cs.c 1.122 2002/10/25 06:26:39
  12
  13     This driver contains code written by Donald Becker
  14     (becker@scyld.com), Rowan Hughes (x-csrdh@jcu.edu.au),
  15     David Hinds (dahinds@users.sourceforge.net), and Erik Stahlman
  16     (erik@vt.edu).  Donald wrote the SMC 91c92 code using parts of
  17     Erik's SMC 91c94 driver.  Rowan wrote a similar driver, and I've
  18     incorporated some parts of his driver here.  I (Dave) wrote most
  19     of the PCMCIA glue code, and the Ositech support code.  Kelly
  20     Stephens (kstephen@holli.com) added support for the Motorola
  21     Mariner, with help from Allen Brost.
  22
  23     This software may be used and distributed according to the terms of
  24     the GNU General Public License, incorporated herein by reference.
  25
  26 ======================================================================*/
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/init.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/timer.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/delay.h>
  36 #include <linux/crc32.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/etherdevice.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/if_arp.h>
  41 #include <linux/ioport.h>
  42 #include <linux/ethtool.h>
  43 #include <linux/mii.h>
  44 #include <linux/jiffies.h>
  45 #include <linux/firmware.h>
  46
  47 #include <pcmcia/cistpl.h>
  48 #include <pcmcia/cisreg.h>
  49 #include <pcmcia/ciscode.h>
  50 #include <pcmcia/ds.h>
  51 #include <pcmcia/ss.h>
  52
  53 #include <asm/io.h>
  54 #include <asm/system.h>
  55 #include <asm/uaccess.h>
  56
  57 /*====================================================================*/
  58
  59 static const char *if_names[] = { "auto", "10baseT", "10base2"};
  60
  61 /* Firmware name */
  62 #define FIRMWARE_NAME           "ositech/Xilinx7OD.bin"
  63
  64 /* Module parameters */
  65
  66 MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
  67 MODULE_LICENSE("GPL");
  68 MODULE_FIRMWARE(FIRMWARE_NAME);
  69
  70 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  71
  72 /*
  73   Transceiver/media type.
  74    0 = auto
  75    1 = 10baseT (and autoselect if #define AUTOSELECT),
  76    2 = AUI/10base2,
  77 */
  78 INT_MODULE_PARM(if_port, 0);
  79
  80
  81 #define DRV_NAME        "smc91c92_cs"
  82 #define DRV_VERSION     "1.123"
  83
  84 /*====================================================================*/
  85
  86 /* Operational parameter that usually are not changed. */
  87
  88 /* Time in jiffies before concluding Tx hung */
  89 #define TX_TIMEOUT              ((400*HZ)/1000)
  90
  91 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  92 #define INTR_WORK               4
  93
  94 /* Times to check the check the chip before concluding that it doesn't
  95    currently have room for another Tx packet. */
  96 #define MEMORY_WAIT_TIME        8
  97
  98 struct smc_private {
  99         struct pcmcia_device    *p_dev;
 100     spinlock_t                  lock;
 101     u_short                     manfid;
 102     u_short                     cardid;
 103
 104     struct sk_buff              *saved_skb;
 105     int                         packets_waiting;
 106     void                        __iomem *base;
 107     u_short                     cfg;
 108     struct timer_list           media;
 109     int                         watchdog, tx_err;
 110     u_short                     media_status;
 111     u_short                     fast_poll;
 112     u_short                     link_status;
 113     struct mii_if_info          mii_if;
 114     int                         duplex;
 115     int                         rx_ovrn;
 116 };
 117
 118 /* Special definitions for Megahertz multifunction cards */
 119 #define MEGAHERTZ_ISR           0x0380
 120
 121 /* Special function registers for Motorola Mariner */
 122 #define MOT_LAN                 0x0000
 123 #define MOT_UART                0x0020
 124 #define MOT_EEPROM              0x20
 125
 126 #define MOT_NORMAL \
 127 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
 128
 129 /* Special function registers for Ositech cards */
 130 #define OSITECH_AUI_CTL         0x0c
 131 #define OSITECH_PWRDOWN         0x0d
 132 #define OSITECH_RESET           0x0e
 133 #define OSITECH_ISR             0x0f
 134 #define OSITECH_AUI_PWR         0x0c
 135 #define OSITECH_RESET_ISR       0x0e
 136
 137 #define OSI_AUI_PWR             0x40
 138 #define OSI_LAN_PWRDOWN         0x02
 139 #define OSI_MODEM_PWRDOWN       0x01
 140 #define OSI_LAN_RESET           0x02
 141 #define OSI_MODEM_RESET         0x01
 142
 143 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
 144 #define BANK_SELECT             14              /* Window select register. */
 145 #define SMC_SELECT_BANK(x)  { outw(x, ioaddr + BANK_SELECT); }
 146
 147 /* Bank 0 registers. */
 148 #define TCR             0       /* transmit control register */
 149 #define  TCR_CLEAR      0       /* do NOTHING */
 150 #define  TCR_ENABLE     0x0001  /* if this is 1, we can transmit */
 151 #define  TCR_PAD_EN     0x0080  /* pads short packets to 64 bytes */
 152 #define  TCR_MONCSN     0x0400  /* Monitor Carrier. */
 153 #define  TCR_FDUPLX     0x0800  /* Full duplex mode. */
 154 #define  TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
 155
 156 #define EPH             2       /* Ethernet Protocol Handler report. */
 157 #define  EPH_TX_SUC     0x0001
 158 #define  EPH_SNGLCOL    0x0002
 159 #define  EPH_MULCOL     0x0004
 160 #define  EPH_LTX_MULT   0x0008
 161 #define  EPH_16COL      0x0010
 162 #define  EPH_SQET       0x0020
 163 #define  EPH_LTX_BRD    0x0040
 164 #define  EPH_TX_DEFR    0x0080
 165 #define  EPH_LAT_COL    0x0200
 166 #define  EPH_LOST_CAR   0x0400
 167 #define  EPH_EXC_DEF    0x0800
 168 #define  EPH_CTR_ROL    0x1000
 169 #define  EPH_RX_OVRN    0x2000
 170 #define  EPH_LINK_OK    0x4000
 171 #define  EPH_TX_UNRN    0x8000
 172 #define MEMINFO         8       /* Memory Information Register */
 173 #define MEMCFG          10      /* Memory Configuration Register */
 174
 175 /* Bank 1 registers. */
 176 #define CONFIG                  0
 177 #define  CFG_MII_SELECT         0x8000  /* 91C100 only */
 178 #define  CFG_NO_WAIT            0x1000
 179 #define  CFG_FULL_STEP          0x0400
 180 #define  CFG_SET_SQLCH          0x0200
 181 #define  CFG_AUI_SELECT         0x0100
 182 #define  CFG_16BIT              0x0080
 183 #define  CFG_DIS_LINK           0x0040
 184 #define  CFG_STATIC             0x0030
 185 #define  CFG_IRQ_SEL_1          0x0004
 186 #define  CFG_IRQ_SEL_0          0x0002
 187 #define BASE_ADDR               2
 188 #define ADDR0                   4
 189 #define GENERAL                 10
 190 #define CONTROL                 12
 191 #define  CTL_STORE              0x0001
 192 #define  CTL_RELOAD             0x0002
 193 #define  CTL_EE_SELECT          0x0004
 194 #define  CTL_TE_ENABLE          0x0020
 195 #define  CTL_CR_ENABLE          0x0040
 196 #define  CTL_LE_ENABLE          0x0080
 197 #define  CTL_AUTO_RELEASE       0x0800
 198 #define  CTL_POWERDOWN          0x2000
 199
 200 /* Bank 2 registers. */
 201 #define MMU_CMD         0
 202 #define  MC_ALLOC       0x20    /* or with number of 256 byte packets */
 203 #define  MC_RESET       0x40
 204 #define  MC_RELEASE     0x80    /* remove and release the current rx packet */
 205 #define  MC_FREEPKT     0xA0    /* Release packet in PNR register */
 206 #define  MC_ENQUEUE     0xC0    /* Enqueue the packet for transmit */
 207 #define PNR_ARR         2
 208 #define FIFO_PORTS      4
 209 #define  FP_RXEMPTY     0x8000
 210 #define POINTER         6
 211 #define  PTR_AUTO_INC   0x0040
 212 #define  PTR_READ       0x2000
 213 #define  PTR_AUTOINC    0x4000
 214 #define  PTR_RCV        0x8000
 215 #define DATA_1          8
 216 #define INTERRUPT       12
 217 #define  IM_RCV_INT             0x1
 218 #define  IM_TX_INT              0x2
 219 #define  IM_TX_EMPTY_INT        0x4
 220 #define  IM_ALLOC_INT           0x8
 221 #define  IM_RX_OVRN_INT         0x10
 222 #define  IM_EPH_INT             0x20
 223
 224 #define RCR             4
 225 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
 226              RxEnable = 0x0100, RxStripCRC = 0x0200};
 227 #define  RCR_SOFTRESET  0x8000  /* resets the chip */
 228 #define  RCR_STRIP_CRC  0x200   /* strips CRC */
 229 #define  RCR_ENABLE     0x100   /* IFF this is set, we can receive packets */
 230 #define  RCR_ALMUL      0x4     /* receive all multicast packets */
 231 #define  RCR_PROMISC    0x2     /* enable promiscuous mode */
 232
 233 /* the normal settings for the RCR register : */
 234 #define  RCR_NORMAL     (RCR_STRIP_CRC | RCR_ENABLE)
 235 #define  RCR_CLEAR      0x0             /* set it to a base state */
 236 #define COUNTER         6
 237
 238 /* BANK 3 -- not the same values as in smc9194! */
 239 #define MULTICAST0      0
 240 #define MULTICAST2      2
 241 #define MULTICAST4      4
 242 #define MULTICAST6      6
 243 #define MGMT            8
 244 #define REVISION        0x0a
 245
 246 /* Transmit status bits. */
 247 #define TS_SUCCESS 0x0001
 248 #define TS_16COL   0x0010
 249 #define TS_LATCOL  0x0200
 250 #define TS_LOSTCAR 0x0400
 251
 252 /* Receive status bits. */
 253 #define RS_ALGNERR      0x8000
 254 #define RS_BADCRC       0x2000
 255 #define RS_ODDFRAME     0x1000
 256 #define RS_TOOLONG      0x0800
 257 #define RS_TOOSHORT     0x0400
 258 #define RS_MULTICAST    0x0001
 259 #define RS_ERRORS       (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
 260
 261 #define set_bits(v, p) outw(inw(p)|(v), (p))
 262 #define mask_bits(v, p) outw(inw(p)&(v), (p))
 263
 264 /*====================================================================*/
 265
 266 static void smc91c92_detach(struct pcmcia_device *p_dev);
 267 static int smc91c92_config(struct pcmcia_device *link);
 268 static void smc91c92_release(struct pcmcia_device *link);
 269
 270 static int smc_open(struct net_device *dev);
 271 static int smc_close(struct net_device *dev);
 272 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 273 static void smc_tx_timeout(struct net_device *dev);
 274 static netdev_tx_t smc_start_xmit(struct sk_buff *skb,
 275                                         struct net_device *dev);
 276 static irqreturn_t smc_interrupt(int irq, void *dev_id);
 277 static void smc_rx(struct net_device *dev);
 278 static void set_rx_mode(struct net_device *dev);
 279 static int s9k_config(struct net_device *dev, struct ifmap *map);
 280 static void smc_set_xcvr(struct net_device *dev, int if_port);
 281 static void smc_reset(struct net_device *dev);
 282 static void media_check(u_long arg);
 283 static void mdio_sync(unsigned int addr);
 284 static int mdio_read(struct net_device *dev, int phy_id, int loc);
 285 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
 286 static int smc_link_ok(struct net_device *dev);
 287 static const struct ethtool_ops ethtool_ops;
 288
 289 static const struct net_device_ops smc_netdev_ops = {
 290         .ndo_open               = smc_open,
 291         .ndo_stop               = smc_close,
 292         .ndo_start_xmit         = smc_start_xmit,
 293         .ndo_tx_timeout         = smc_tx_timeout,
 294         .ndo_set_config         = s9k_config,
 295         .ndo_set_multicast_list = set_rx_mode,
 296         .ndo_do_ioctl           = &smc_ioctl,
 297         .ndo_change_mtu         = eth_change_mtu,
 298         .ndo_set_mac_address    = eth_mac_addr,
 299         .ndo_validate_addr      = eth_validate_addr,
 300 };
 301
 302 /*======================================================================
 303
 304   smc91c92_attach() creates an "instance" of the driver, allocating
 305   local data structures for one device.  The device is registered
 306   with Card Services.
 307
 308 ======================================================================*/
 309
 310 static int smc91c92_probe(struct pcmcia_device *link)
 311 {
 312     struct smc_private *smc;
 313     struct net_device *dev;
 314
 315     dev_dbg(&link->dev, "smc91c92_attach()\n");
 316
 317     /* Create new ethernet device */
 318     dev = alloc_etherdev(sizeof(struct smc_private));
 319     if (!dev)
 320         return -ENOMEM;
 321     smc = netdev_priv(dev);
 322     smc->p_dev = link;
 323     link->priv = dev;
 324
 325     spin_lock_init(&smc->lock);
 326
 327     /* The SMC91c92-specific entries in the device structure. */
 328     dev->netdev_ops = &smc_netdev_ops;
 329     SET_ETHTOOL_OPS(dev, &ethtool_ops);
 330     dev->watchdog_timeo = TX_TIMEOUT;
 331
 332     smc->mii_if.dev = dev;
 333     smc->mii_if.mdio_read = mdio_read;
 334     smc->mii_if.mdio_write = mdio_write;
 335     smc->mii_if.phy_id_mask = 0x1f;
 336     smc->mii_if.reg_num_mask = 0x1f;
 337
 338     return smc91c92_config(link);
 339 } /* smc91c92_attach */
 340
 341 /*======================================================================
 342
 343     This deletes a driver "instance".  The device is de-registered
 344     with Card Services.  If it has been released, all local data
 345     structures are freed.  Otherwise, the structures will be freed
 346     when the device is released.
 347
 348 ======================================================================*/
 349
 350 static void smc91c92_detach(struct pcmcia_device *link)
 351 {
 352     struct net_device *dev = link->priv;
 353
 354     dev_dbg(&link->dev, "smc91c92_detach\n");
 355
 356     unregister_netdev(dev);
 357
 358     smc91c92_release(link);
 359
 360     free_netdev(dev);
 361 } /* smc91c92_detach */
 362
 363 /*====================================================================*/
 364
 365 static int cvt_ascii_address(struct net_device *dev, char *s)
 366 {
 367     int i, j, da, c;
 368
 369     if (strlen(s) != 12)
 370         return -1;
 371     for (i = 0; i < 6; i++) {
 372         da = 0;
 373         for (j = 0; j < 2; j++) {
 374             c = *s++;
 375             da <<= 4;
 376             da += ((c >= '0') && (c <= '9')) ?
 377                 (c - '0') : ((c & 0x0f) + 9);
 378         }
 379         dev->dev_addr[i] = da;
 380     }
 381     return 0;
 382 }
 383
 384 /*====================================================================
 385
 386     Configuration stuff for Megahertz cards
 387
 388     mhz_3288_power() is used to power up a 3288's ethernet chip.
 389     mhz_mfc_config() handles socket setup for multifunction (1144
 390     and 3288) cards.  mhz_setup() gets a card's hardware ethernet
 391     address.
 392
 393 ======================================================================*/
 394
 395 static int mhz_3288_power(struct pcmcia_device *link)
 396 {
 397     struct net_device *dev = link->priv;
 398     struct smc_private *smc = netdev_priv(dev);
 399     u_char tmp;
 400
 401     /* Read the ISR twice... */
 402     readb(smc->base+MEGAHERTZ_ISR);
 403     udelay(5);
 404     readb(smc->base+MEGAHERTZ_ISR);
 405
 406     /* Pause 200ms... */
 407     mdelay(200);
 408
 409     /* Now read and write the COR... */
 410     tmp = readb(smc->base + link->config_base + CISREG_COR);
 411     udelay(5);
 412     writeb(tmp, smc->base + link->config_base + CISREG_COR);
 413
 414     return 0;
 415 }
 416
 417 static int mhz_mfc_config_check(struct pcmcia_device *p_dev, void *priv_data)
 418 {
 419         int k;
 420         p_dev->io_lines = 16;
 421         p_dev->resource[1]->start = p_dev->resource[0]->start;
 422         p_dev->resource[1]->end = 8;
 423         p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
 424         p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 425         p_dev->resource[0]->end = 16;
 426         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 427         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 428         for (k = 0; k < 0x400; k += 0x10) {
 429                 if (k & 0x80)
 430                         continue;
 431                 p_dev->resource[0]->start = k ^ 0x300;
 432                 if (!pcmcia_request_io(p_dev))
 433                         return 0;
 434         }
 435         return -ENODEV;
 436 }
 437
 438 static int mhz_mfc_config(struct pcmcia_device *link)
 439 {
 440     struct net_device *dev = link->priv;
 441     struct smc_private *smc = netdev_priv(dev);
 442     unsigned int offset;
 443     int i;
 444
 445     link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ |
 446             CONF_AUTO_SET_IO;
 447
 448     /* The Megahertz combo cards have modem-like CIS entries, so
 449        we have to explicitly try a bunch of port combinations. */
 450     if (pcmcia_loop_config(link, mhz_mfc_config_check, NULL))
 451             return -ENODEV;
 452
 453     dev->base_addr = link->resource[0]->start;
 454
 455     /* Allocate a memory window, for accessing the ISR */
 456     link->resource[2]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 457     link->resource[2]->start = link->resource[2]->end = 0;
 458     i = pcmcia_request_window(link, link->resource[2], 0);
 459     if (i != 0)
 460             return -ENODEV;
 461
 462     smc->base = ioremap(link->resource[2]->start,
 463                     resource_size(link->resource[2]));
 464     offset = (smc->manfid == MANFID_MOTOROLA) ? link->config_base : 0;
 465     i = pcmcia_map_mem_page(link, link->resource[2], offset);
 466     if ((i == 0) &&
 467         (smc->manfid == MANFID_MEGAHERTZ) &&
 468         (smc->cardid == PRODID_MEGAHERTZ_EM3288))
 469             mhz_3288_power(link);
 470
 471     return 0;
 472 }
 473
 474 static int pcmcia_get_versmac(struct pcmcia_device *p_dev,
 475                               tuple_t *tuple,
 476                               void *priv)
 477 {
 478         struct net_device *dev = priv;
 479         cisparse_t parse;
 480         u8 *buf;
 481
 482         if (pcmcia_parse_tuple(tuple, &parse))
 483                 return -EINVAL;
 484
 485         buf = parse.version_1.str + parse.version_1.ofs[3];
 486
 487         if ((parse.version_1.ns > 3) && (cvt_ascii_address(dev, buf) == 0))
 488                 return 0;
 489
 490         return -EINVAL;
 491 };
 492
 493 static int mhz_setup(struct pcmcia_device *link)
 494 {
 495     struct net_device *dev = link->priv;
 496     size_t len;
 497     u8 *buf;
 498     int rc;
 499
 500     /* Read the station address from the CIS.  It is stored as the last
 501        (fourth) string in the Version 1 Version/ID tuple. */
 502     if ((link->prod_id[3]) &&
 503         (cvt_ascii_address(dev, link->prod_id[3]) == 0))
 504             return 0;
 505
 506     /* Workarounds for broken cards start here. */
 507     /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
 508     if (!pcmcia_loop_tuple(link, CISTPL_VERS_1, pcmcia_get_versmac, dev))
 509             return 0;
 510
 511     /* Another possibility: for the EM3288, in a special tuple */
 512     rc = -1;
 513     len = pcmcia_get_tuple(link, 0x81, &buf);
 514     if (buf && len >= 13) {
 515             buf[12] = '\0';
 516             if (cvt_ascii_address(dev, buf) == 0)
 517                     rc = 0;
 518     }
 519     kfree(buf);
 520
 521     return rc;
 522 };
 523
 524 /*======================================================================
 525
 526     Configuration stuff for the Motorola Mariner
 527
 528     mot_config() writes directly to the Mariner configuration
 529     registers because the CIS is just bogus.
 530
 531 ======================================================================*/
 532
 533 static void mot_config(struct pcmcia_device *link)
 534 {
 535     struct net_device *dev = link->priv;
 536     struct smc_private *smc = netdev_priv(dev);
 537     unsigned int ioaddr = dev->base_addr;
 538     unsigned int iouart = link->resource[1]->start;
 539
 540     /* Set UART base address and force map with COR bit 1 */
 541     writeb(iouart & 0xff,        smc->base + MOT_UART + CISREG_IOBASE_0);
 542     writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
 543     writeb(MOT_NORMAL,           smc->base + MOT_UART + CISREG_COR);
 544
 545     /* Set SMC base address and force map with COR bit 1 */
 546     writeb(ioaddr & 0xff,        smc->base + MOT_LAN + CISREG_IOBASE_0);
 547     writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
 548     writeb(MOT_NORMAL,           smc->base + MOT_LAN + CISREG_COR);
 549
 550     /* Wait for things to settle down */
 551     mdelay(100);
 552 }
 553
 554 static int mot_setup(struct pcmcia_device *link)
 555 {
 556     struct net_device *dev = link->priv;
 557     unsigned int ioaddr = dev->base_addr;
 558     int i, wait, loop;
 559     u_int addr;
 560
 561     /* Read Ethernet address from Serial EEPROM */
 562
 563     for (i = 0; i < 3; i++) {
 564         SMC_SELECT_BANK(2);
 565         outw(MOT_EEPROM + i, ioaddr + POINTER);
 566         SMC_SELECT_BANK(1);
 567         outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
 568
 569         for (loop = wait = 0; loop < 200; loop++) {
 570             udelay(10);
 571             wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
 572             if (wait == 0) break;
 573         }
 574
 575         if (wait)
 576             return -1;
 577
 578         addr = inw(ioaddr + GENERAL);
 579         dev->dev_addr[2*i]   = addr & 0xff;
 580         dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
 581     }
 582
 583     return 0;
 584 }
 585
 586 /*====================================================================*/
 587
 588 static int smc_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 589 {
 590         p_dev->resource[0]->end = 16;
 591         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 592         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 593
 594         return pcmcia_request_io(p_dev);
 595 }
 596
 597 static int smc_config(struct pcmcia_device *link)
 598 {
 599     struct net_device *dev = link->priv;
 600     int i;
 601
 602     link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 603
 604     i = pcmcia_loop_config(link, smc_configcheck, NULL);
 605     if (!i)
 606             dev->base_addr = link->resource[0]->start;
 607
 608     return i;
 609 }
 610
 611
 612 static int smc_setup(struct pcmcia_device *link)
 613 {
 614     struct net_device *dev = link->priv;
 615
 616     /* Check for a LAN function extension tuple */
 617     if (!pcmcia_get_mac_from_cis(link, dev))
 618             return 0;
 619
 620     /* Try the third string in the Version 1 Version/ID tuple. */
 621     if (link->prod_id[2]) {
 622             if (cvt_ascii_address(dev, link->prod_id[2]) == 0)
 623                     return 0;
 624     }
 625     return -1;
 626 }
 627
 628 /*====================================================================*/
 629
 630 static int osi_config(struct pcmcia_device *link)
 631 {
 632     struct net_device *dev = link->priv;
 633     static const unsigned int com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
 634     int i, j;
 635
 636     link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ;
 637     link->resource[0]->end = 64;
 638     link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 639     link->resource[1]->end = 8;
 640
 641     /* Enable Hard Decode, LAN, Modem */
 642     link->io_lines = 16;
 643     link->config_index = 0x23;
 644
 645     for (i = j = 0; j < 4; j++) {
 646         link->resource[1]->start = com[j];
 647         i = pcmcia_request_io(link);
 648         if (i == 0)
 649                 break;
 650     }
 651     if (i != 0) {
 652         /* Fallback: turn off hard decode */
 653         link->config_index = 0x03;
 654         link->resource[1]->end = 0;
 655         i = pcmcia_request_io(link);
 656     }
 657     dev->base_addr = link->resource[0]->start + 0x10;
 658     return i;
 659 }
 660
 661 static int osi_load_firmware(struct pcmcia_device *link)
 662 {
 663         const struct firmware *fw;
 664         int i, err;
 665
 666         err = request_firmware(&fw, FIRMWARE_NAME, &link->dev);
 667         if (err) {
 668                 pr_err("Failed to load firmware \"%s\"\n", FIRMWARE_NAME);
 669                 return err;
 670         }
 671
 672         /* Download the Seven of Diamonds firmware */
 673         for (i = 0; i < fw->size; i++) {
 674             outb(fw->data[i], link->resource[0]->start + 2);
 675             udelay(50);
 676         }
 677         release_firmware(fw);
 678         return err;
 679 }
 680
 681 static int pcmcia_osi_mac(struct pcmcia_device *p_dev,
 682                           tuple_t *tuple,
 683                           void *priv)
 684 {
 685         struct net_device *dev = priv;
 686         int i;
 687
 688         if (tuple->TupleDataLen < 8)
 689                 return -EINVAL;
 690         if (tuple->TupleData[0] != 0x04)
 691                 return -EINVAL;
 692         for (i = 0; i < 6; i++)
 693                 dev->dev_addr[i] = tuple->TupleData[i+2];
 694         return 0;
 695 };
 696
 697
 698 static int osi_setup(struct pcmcia_device *link, u_short manfid, u_short cardid)
 699 {
 700     struct net_device *dev = link->priv;
 701     int rc;
 702
 703     /* Read the station address from tuple 0x90, subtuple 0x04 */
 704     if (pcmcia_loop_tuple(link, 0x90, pcmcia_osi_mac, dev))
 705             return -1;
 706
 707     if (((manfid == MANFID_OSITECH) &&
 708          (cardid == PRODID_OSITECH_SEVEN)) ||
 709         ((manfid == MANFID_PSION) &&
 710          (cardid == PRODID_PSION_NET100))) {
 711         rc = osi_load_firmware(link);
 712         if (rc)
 713                 return rc;
 714     } else if (manfid == MANFID_OSITECH) {
 715         /* Make sure both functions are powered up */
 716         set_bits(0x300, link->resource[0]->start + OSITECH_AUI_PWR);
 717         /* Now, turn on the interrupt for both card functions */
 718         set_bits(0x300, link->resource[0]->start + OSITECH_RESET_ISR);
 719         dev_dbg(&link->dev, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
 720               inw(link->resource[0]->start + OSITECH_AUI_PWR),
 721               inw(link->resource[0]->start + OSITECH_RESET_ISR));
 722     }
 723     return 0;
 724 }
 725
 726 static int smc91c92_suspend(struct pcmcia_device *link)
 727 {
 728         struct net_device *dev = link->priv;
 729
 730         if (link->open)
 731                 netif_device_detach(dev);
 732
 733         return 0;
 734 }
 735
 736 static int smc91c92_resume(struct pcmcia_device *link)
 737 {
 738         struct net_device *dev = link->priv;
 739         struct smc_private *smc = netdev_priv(dev);
 740         int i;
 741
 742         if ((smc->manfid == MANFID_MEGAHERTZ) &&
 743             (smc->cardid == PRODID_MEGAHERTZ_EM3288))
 744                 mhz_3288_power(link);
 745         if (smc->manfid == MANFID_MOTOROLA)
 746                 mot_config(link);
 747         if ((smc->manfid == MANFID_OSITECH) &&
 748             (smc->cardid != PRODID_OSITECH_SEVEN)) {
 749                 /* Power up the card and enable interrupts */
 750                 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
 751                 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
 752         }
 753         if (((smc->manfid == MANFID_OSITECH) &&
 754              (smc->cardid == PRODID_OSITECH_SEVEN)) ||
 755             ((smc->manfid == MANFID_PSION) &&
 756              (smc->cardid == PRODID_PSION_NET100))) {
 757                 i = osi_load_firmware(link);
 758                 if (i) {
 759                         pr_err("smc91c92_cs: Failed to load firmware\n");
 760                         return i;
 761                 }
 762         }
 763         if (link->open) {
 764                 smc_reset(dev);
 765                 netif_device_attach(dev);
 766         }
 767
 768         return 0;
 769 }
 770
 771
 772 /*======================================================================
 773
 774     This verifies that the chip is some SMC91cXX variant, and returns
 775     the revision code if successful.  Otherwise, it returns -ENODEV.
 776
 777 ======================================================================*/
 778
 779 static int check_sig(struct pcmcia_device *link)
 780 {
 781     struct net_device *dev = link->priv;
 782     unsigned int ioaddr = dev->base_addr;
 783     int width;
 784     u_short s;
 785
 786     SMC_SELECT_BANK(1);
 787     if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
 788         /* Try powering up the chip */
 789         outw(0, ioaddr + CONTROL);
 790         mdelay(55);
 791     }
 792
 793     /* Try setting bus width */
 794     width = (link->resource[0]->flags == IO_DATA_PATH_WIDTH_AUTO);
 795     s = inb(ioaddr + CONFIG);
 796     if (width)
 797         s |= CFG_16BIT;
 798     else
 799         s &= ~CFG_16BIT;
 800     outb(s, ioaddr + CONFIG);
 801
 802     /* Check Base Address Register to make sure bus width is OK */
 803     s = inw(ioaddr + BASE_ADDR);
 804     if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
 805         ((s >> 8) != (s & 0xff))) {
 806         SMC_SELECT_BANK(3);
 807         s = inw(ioaddr + REVISION);
 808         return (s & 0xff);
 809     }
 810
 811     if (width) {
 812             printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
 813
 814             smc91c92_suspend(link);
 815             pcmcia_fixup_iowidth(link);
 816             smc91c92_resume(link);
 817             return check_sig(link);
 818     }
 819     return -ENODEV;
 820 }
 821
 822 /*======================================================================
 823
 824     smc91c92_config() is scheduled to run after a CARD_INSERTION event
 825     is received, to configure the PCMCIA socket, and to make the
 826     ethernet device available to the system.
 827
 828 ======================================================================*/
 829
 830 static int smc91c92_config(struct pcmcia_device *link)
 831 {
 832     struct net_device *dev = link->priv;
 833     struct smc_private *smc = netdev_priv(dev);
 834     char *name;
 835     int i, j, rev;
 836     unsigned int ioaddr;
 837     u_long mir;
 838
 839     dev_dbg(&link->dev, "smc91c92_config\n");
 840
 841     smc->manfid = link->manf_id;
 842     smc->cardid = link->card_id;
 843
 844     if ((smc->manfid == MANFID_OSITECH) &&
 845         (smc->cardid != PRODID_OSITECH_SEVEN)) {
 846         i = osi_config(link);
 847     } else if ((smc->manfid == MANFID_MOTOROLA) ||
 848                ((smc->manfid == MANFID_MEGAHERTZ) &&
 849                 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
 850                  (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
 851         i = mhz_mfc_config(link);
 852     } else {
 853         i = smc_config(link);
 854     }
 855     if (i)
 856             goto config_failed;
 857
 858     i = pcmcia_request_irq(link, smc_interrupt);
 859     if (i)
 860             goto config_failed;
 861     i = pcmcia_enable_device(link);
 862     if (i)
 863             goto config_failed;
 864
 865     if (smc->manfid == MANFID_MOTOROLA)
 866         mot_config(link);
 867
 868     dev->irq = link->irq;
 869
 870     if ((if_port >= 0) && (if_port <= 2))
 871         dev->if_port = if_port;
 872     else
 873         printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
 874
 875     switch (smc->manfid) {
 876     case MANFID_OSITECH:
 877     case MANFID_PSION:
 878         i = osi_setup(link, smc->manfid, smc->cardid); break;
 879     case MANFID_SMC:
 880     case MANFID_NEW_MEDIA:
 881         i = smc_setup(link); break;
 882     case 0x128: /* For broken Megahertz cards */
 883     case MANFID_MEGAHERTZ:
 884         i = mhz_setup(link); break;
 885     case MANFID_MOTOROLA:
 886     default: /* get the hw address from EEPROM */
 887         i = mot_setup(link); break;
 888     }
 889
 890     if (i != 0) {
 891         printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
 892         goto config_failed;
 893     }
 894
 895     smc->duplex = 0;
 896     smc->rx_ovrn = 0;
 897
 898     rev = check_sig(link);
 899     name = "???";
 900     if (rev > 0)
 901         switch (rev >> 4) {
 902         case 3: name = "92"; break;
 903         case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
 904         case 5: name = "95"; break;
 905         case 7: name = "100"; break;
 906         case 8: name = "100-FD"; break;
 907         case 9: name = "110"; break;
 908         }
 909
 910     ioaddr = dev->base_addr;
 911     if (rev > 0) {
 912         u_long mcr;
 913         SMC_SELECT_BANK(0);
 914         mir = inw(ioaddr + MEMINFO) & 0xff;
 915         if (mir == 0xff) mir++;
 916         /* Get scale factor for memory size */
 917         mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
 918         mir *= 128 * (1<<((mcr >> 9) & 7));
 919         SMC_SELECT_BANK(1);
 920         smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
 921         smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
 922         if (smc->manfid == MANFID_OSITECH)
 923             smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
 924         if ((rev >> 4) >= 7)
 925             smc->cfg |= CFG_MII_SELECT;
 926     } else
 927         mir = 0;
 928
 929     if (smc->cfg & CFG_MII_SELECT) {
 930         SMC_SELECT_BANK(3);
 931
 932         for (i = 0; i < 32; i++) {
 933             j = mdio_read(dev, i, 1);
 934             if ((j != 0) && (j != 0xffff)) break;
 935         }
 936         smc->mii_if.phy_id = (i < 32) ? i : -1;
 937
 938         SMC_SELECT_BANK(0);
 939     }
 940
 941     SET_NETDEV_DEV(dev, &link->dev);
 942
 943     if (register_netdev(dev) != 0) {
 944         printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
 945         goto config_undo;
 946     }
 947
 948     printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
 949            "hw_addr %pM\n",
 950            dev->name, name, (rev & 0x0f), dev->base_addr, dev->irq,
 951            dev->dev_addr);
 952
 953     if (rev > 0) {
 954         if (mir & 0x3ff)
 955             printk(KERN_INFO "  %lu byte", mir);
 956         else
 957             printk(KERN_INFO "  %lu kb", mir>>10);
 958         printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
 959                "MII" : if_names[dev->if_port]);
 960     }
 961
 962     if (smc->cfg & CFG_MII_SELECT) {
 963         if (smc->mii_if.phy_id != -1) {
 964             dev_dbg(&link->dev, "  MII transceiver at index %d, status %x.\n",
 965                   smc->mii_if.phy_id, j);
 966         } else {
 967             printk(KERN_NOTICE "  No MII transceivers found!\n");
 968         }
 969     }
 970     return 0;
 971
 972 config_undo:
 973     unregister_netdev(dev);
 974 config_failed:
 975     smc91c92_release(link);
 976     free_netdev(dev);
 977     return -ENODEV;
 978 } /* smc91c92_config */
 979
 980 /*======================================================================
 981
 982     After a card is removed, smc91c92_release() will unregister the net
 983     device, and release the PCMCIA configuration.  If the device is
 984     still open, this will be postponed until it is closed.
 985
 986 ======================================================================*/
 987
 988 static void smc91c92_release(struct pcmcia_device *link)
 989 {
 990         dev_dbg(&link->dev, "smc91c92_release\n");
 991         if (link->resource[2]->end) {
 992                 struct net_device *dev = link->priv;
 993                 struct smc_private *smc = netdev_priv(dev);
 994                 iounmap(smc->base);
 995         }
 996         pcmcia_disable_device(link);
 997 }
 998
 999 /*======================================================================
1000
1001     MII interface support for SMC91cXX based cards
1002 ======================================================================*/
1003
1004 #define MDIO_SHIFT_CLK          0x04
1005 #define MDIO_DATA_OUT           0x01
1006 #define MDIO_DIR_WRITE          0x08
1007 #define MDIO_DATA_WRITE0        (MDIO_DIR_WRITE)
1008 #define MDIO_DATA_WRITE1        (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1009 #define MDIO_DATA_READ          0x02
1010
1011 static void mdio_sync(unsigned int addr)
1012 {
1013     int bits;
1014     for (bits = 0; bits < 32; bits++) {
1015         outb(MDIO_DATA_WRITE1, addr);
1016         outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1017     }
1018 }
1019
1020 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1021 {
1022     unsigned int addr = dev->base_addr + MGMT;
1023     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1024     int i, retval = 0;
1025
1026     mdio_sync(addr);
1027     for (i = 13; i >= 0; i--) {
1028         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1029         outb(dat, addr);
1030         outb(dat | MDIO_SHIFT_CLK, addr);
1031     }
1032     for (i = 19; i > 0; i--) {
1033         outb(0, addr);
1034         retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1035         outb(MDIO_SHIFT_CLK, addr);
1036     }
1037     return (retval>>1) & 0xffff;
1038 }
1039
1040 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1041 {
1042     unsigned int addr = dev->base_addr + MGMT;
1043     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1044     int i;
1045
1046     mdio_sync(addr);
1047     for (i = 31; i >= 0; i--) {
1048         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1049         outb(dat, addr);
1050         outb(dat | MDIO_SHIFT_CLK, addr);
1051     }
1052     for (i = 1; i >= 0; i--) {
1053         outb(0, addr);
1054         outb(MDIO_SHIFT_CLK, addr);
1055     }
1056 }
1057
1058 /*======================================================================
1059
1060     The driver core code, most of which should be common with a
1061     non-PCMCIA implementation.
1062
1063 ======================================================================*/
1064
1065 #ifdef PCMCIA_DEBUG
1066 static void smc_dump(struct net_device *dev)
1067 {
1068     unsigned int ioaddr = dev->base_addr;
1069     u_short i, w, save;
1070     save = inw(ioaddr + BANK_SELECT);
1071     for (w = 0; w < 4; w++) {
1072         SMC_SELECT_BANK(w);
1073         printk(KERN_DEBUG "bank %d: ", w);
1074         for (i = 0; i < 14; i += 2)
1075             printk(" %04x", inw(ioaddr + i));
1076         printk("\n");
1077     }
1078     outw(save, ioaddr + BANK_SELECT);
1079 }
1080 #endif
1081
1082 static int smc_open(struct net_device *dev)
1083 {
1084     struct smc_private *smc = netdev_priv(dev);
1085     struct pcmcia_device *link = smc->p_dev;
1086
1087     dev_dbg(&link->dev, "%s: smc_open(%p), ID/Window %4.4x.\n",
1088           dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1089 #ifdef PCMCIA_DEBUG
1090     smc_dump(dev);
1091 #endif
1092
1093     /* Check that the PCMCIA card is still here. */
1094     if (!pcmcia_dev_present(link))
1095         return -ENODEV;
1096     /* Physical device present signature. */
1097     if (check_sig(link) < 0) {
1098         printk("smc91c92_cs: Yikes!  Bad chip signature!\n");
1099         return -ENODEV;
1100     }
1101     link->open++;
1102
1103     netif_start_queue(dev);
1104     smc->saved_skb = NULL;
1105     smc->packets_waiting = 0;
1106
1107     smc_reset(dev);
1108     init_timer(&smc->media);
1109     smc->media.function = &media_check;
1110     smc->media.data = (u_long) dev;
1111     smc->media.expires = jiffies + HZ;
1112     add_timer(&smc->media);
1113
1114     return 0;
1115 } /* smc_open */
1116
1117 /*====================================================================*/
1118
1119 static int smc_close(struct net_device *dev)
1120 {
1121     struct smc_private *smc = netdev_priv(dev);
1122     struct pcmcia_device *link = smc->p_dev;
1123     unsigned int ioaddr = dev->base_addr;
1124
1125     dev_dbg(&link->dev, "%s: smc_close(), status %4.4x.\n",
1126           dev->name, inw(ioaddr + BANK_SELECT));
1127
1128     netif_stop_queue(dev);
1129
1130     /* Shut off all interrupts, and turn off the Tx and Rx sections.
1131        Don't bother to check for chip present. */
1132     SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1133     outw(0, ioaddr + INTERRUPT);
1134     SMC_SELECT_BANK(0);
1135     mask_bits(0xff00, ioaddr + RCR);
1136     mask_bits(0xff00, ioaddr + TCR);
1137
1138     /* Put the chip into power-down mode. */
1139     SMC_SELECT_BANK(1);
1140     outw(CTL_POWERDOWN, ioaddr + CONTROL );
1141
1142     link->open--;
1143     del_timer_sync(&smc->media);
1144
1145     return 0;
1146 } /* smc_close */
1147
1148 /*======================================================================
1149
1150    Transfer a packet to the hardware and trigger the packet send.
1151    This may be called at either from either the Tx queue code
1152    or the interrupt handler.
1153
1154 ======================================================================*/
1155
1156 static void smc_hardware_send_packet(struct net_device * dev)
1157 {
1158     struct smc_private *smc = netdev_priv(dev);
1159     struct sk_buff *skb = smc->saved_skb;
1160     unsigned int ioaddr = dev->base_addr;
1161     u_char packet_no;
1162
1163     if (!skb) {
1164         printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1165         return;
1166     }
1167
1168     /* There should be a packet slot waiting. */
1169     packet_no = inw(ioaddr + PNR_ARR) >> 8;
1170     if (packet_no & 0x80) {
1171         /* If not, there is a hardware problem!  Likely an ejected card. */
1172         printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1173                " failed, status %#2.2x.\n", dev->name, packet_no);
1174         dev_kfree_skb_irq(skb);
1175         smc->saved_skb = NULL;
1176         netif_start_queue(dev);
1177         return;
1178     }
1179
1180     dev->stats.tx_bytes += skb->len;
1181     /* The card should use the just-allocated buffer. */
1182     outw(packet_no, ioaddr + PNR_ARR);
1183     /* point to the beginning of the packet */
1184     outw(PTR_AUTOINC , ioaddr + POINTER);
1185
1186     /* Send the packet length (+6 for status, length and ctl byte)
1187        and the status word (set to zeros). */
1188     {
1189         u_char *buf = skb->data;
1190         u_int length = skb->len; /* The chip will pad to ethernet min. */
1191
1192         pr_debug("%s: Trying to xmit packet of length %d.\n",
1193               dev->name, length);
1194
1195         /* send the packet length: +6 for status word, length, and ctl */
1196         outw(0, ioaddr + DATA_1);
1197         outw(length + 6, ioaddr + DATA_1);
1198         outsw(ioaddr + DATA_1, buf, length >> 1);
1199
1200         /* The odd last byte, if there is one, goes in the control word. */
1201         outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1202     }
1203
1204     /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1205     outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1206          (inw(ioaddr + INTERRUPT) & 0xff00),
1207          ioaddr + INTERRUPT);
1208
1209     /* The chip does the rest of the work. */
1210     outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1211
1212     smc->saved_skb = NULL;
1213     dev_kfree_skb_irq(skb);
1214     dev->trans_start = jiffies;
1215     netif_start_queue(dev);
1216 }
1217
1218 /*====================================================================*/
1219
1220 static void smc_tx_timeout(struct net_device *dev)
1221 {
1222     struct smc_private *smc = netdev_priv(dev);
1223     unsigned int ioaddr = dev->base_addr;
1224
1225     printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1226            "Tx_status %2.2x status %4.4x.\n",
1227            dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1228     dev->stats.tx_errors++;
1229     smc_reset(dev);
1230     dev->trans_start = jiffies; /* prevent tx timeout */
1231     smc->saved_skb = NULL;
1232     netif_wake_queue(dev);
1233 }
1234
1235 static netdev_tx_t smc_start_xmit(struct sk_buff *skb,
1236                                         struct net_device *dev)
1237 {
1238     struct smc_private *smc = netdev_priv(dev);
1239     unsigned int ioaddr = dev->base_addr;
1240     u_short num_pages;
1241     short time_out, ir;
1242     unsigned long flags;
1243
1244     netif_stop_queue(dev);
1245
1246     pr_debug("%s: smc_start_xmit(length = %d) called,"
1247           " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1248
1249     if (smc->saved_skb) {
1250         /* THIS SHOULD NEVER HAPPEN. */
1251         dev->stats.tx_aborted_errors++;
1252         printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1253                dev->name);
1254         return NETDEV_TX_BUSY;
1255     }
1256     smc->saved_skb = skb;
1257
1258     num_pages = skb->len >> 8;
1259
1260     if (num_pages > 7) {
1261         printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1262         dev_kfree_skb (skb);
1263         smc->saved_skb = NULL;
1264         dev->stats.tx_dropped++;
1265         return NETDEV_TX_OK;            /* Do not re-queue this packet. */
1266     }
1267     /* A packet is now waiting. */
1268     smc->packets_waiting++;
1269
1270     spin_lock_irqsave(&smc->lock, flags);
1271     SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1272
1273     /* need MC_RESET to keep the memory consistent. errata? */
1274     if (smc->rx_ovrn) {
1275         outw(MC_RESET, ioaddr + MMU_CMD);
1276         smc->rx_ovrn = 0;
1277     }
1278
1279     /* Allocate the memory; send the packet now if we win. */
1280     outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1281     for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1282         ir = inw(ioaddr+INTERRUPT);
1283         if (ir & IM_ALLOC_INT) {
1284             /* Acknowledge the interrupt, send the packet. */
1285             outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1286             smc_hardware_send_packet(dev);      /* Send the packet now.. */
1287             spin_unlock_irqrestore(&smc->lock, flags);
1288             return NETDEV_TX_OK;
1289         }
1290     }
1291
1292     /* Otherwise defer until the Tx-space-allocated interrupt. */
1293     pr_debug("%s: memory allocation deferred.\n", dev->name);
1294     outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1295     spin_unlock_irqrestore(&smc->lock, flags);
1296
1297     return NETDEV_TX_OK;
1298 }
1299
1300 /*======================================================================
1301
1302     Handle a Tx anomolous event.  Entered while in Window 2.
1303
1304 ======================================================================*/
1305
1306 static void smc_tx_err(struct net_device * dev)
1307 {
1308     struct smc_private *smc = netdev_priv(dev);
1309     unsigned int ioaddr = dev->base_addr;
1310     int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1311     int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1312     int tx_status;
1313
1314     /* select this as the packet to read from */
1315     outw(packet_no, ioaddr + PNR_ARR);
1316
1317     /* read the first word from this packet */
1318     outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1319
1320     tx_status = inw(ioaddr + DATA_1);
1321
1322     dev->stats.tx_errors++;
1323     if (tx_status & TS_LOSTCAR) dev->stats.tx_carrier_errors++;
1324     if (tx_status & TS_LATCOL)  dev->stats.tx_window_errors++;
1325     if (tx_status & TS_16COL) {
1326         dev->stats.tx_aborted_errors++;
1327         smc->tx_err++;
1328     }
1329
1330     if (tx_status & TS_SUCCESS) {
1331         printk(KERN_NOTICE "%s: Successful packet caused error "
1332                "interrupt?\n", dev->name);
1333     }
1334     /* re-enable transmit */
1335     SMC_SELECT_BANK(0);
1336     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1337     SMC_SELECT_BANK(2);
1338
1339     outw(MC_FREEPKT, ioaddr + MMU_CMD);         /* Free the packet memory. */
1340
1341     /* one less packet waiting for me */
1342     smc->packets_waiting--;
1343
1344     outw(saved_packet, ioaddr + PNR_ARR);
1345 }
1346
1347 /*====================================================================*/
1348
1349 static void smc_eph_irq(struct net_device *dev)
1350 {
1351     struct smc_private *smc = netdev_priv(dev);
1352     unsigned int ioaddr = dev->base_addr;
1353     u_short card_stats, ephs;
1354
1355     SMC_SELECT_BANK(0);
1356     ephs = inw(ioaddr + EPH);
1357     pr_debug("%s: Ethernet protocol handler interrupt, status"
1358           " %4.4x.\n", dev->name, ephs);
1359     /* Could be a counter roll-over warning: update stats. */
1360     card_stats = inw(ioaddr + COUNTER);
1361     /* single collisions */
1362     dev->stats.collisions += card_stats & 0xF;
1363     card_stats >>= 4;
1364     /* multiple collisions */
1365     dev->stats.collisions += card_stats & 0xF;
1366 #if 0           /* These are for when linux supports these statistics */
1367     card_stats >>= 4;                   /* deferred */
1368     card_stats >>= 4;                   /* excess deferred */
1369 #endif
1370     /* If we had a transmit error we must re-enable the transmitter. */
1371     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1372
1373     /* Clear a link error interrupt. */
1374     SMC_SELECT_BANK(1);
1375     outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1376     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1377          ioaddr + CONTROL);
1378     SMC_SELECT_BANK(2);
1379 }
1380
1381 /*====================================================================*/
1382
1383 static irqreturn_t smc_interrupt(int irq, void *dev_id)
1384 {
1385     struct net_device *dev = dev_id;
1386     struct smc_private *smc = netdev_priv(dev);
1387     unsigned int ioaddr;
1388     u_short saved_bank, saved_pointer, mask, status;
1389     unsigned int handled = 1;
1390     char bogus_cnt = INTR_WORK;         /* Work we are willing to do. */
1391
1392     if (!netif_device_present(dev))
1393         return IRQ_NONE;
1394
1395     ioaddr = dev->base_addr;
1396
1397     pr_debug("%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1398           irq, ioaddr);
1399
1400     spin_lock(&smc->lock);
1401     smc->watchdog = 0;
1402     saved_bank = inw(ioaddr + BANK_SELECT);
1403     if ((saved_bank & 0xff00) != 0x3300) {
1404         /* The device does not exist -- the card could be off-line, or
1405            maybe it has been ejected. */
1406         pr_debug("%s: SMC91c92 interrupt %d for non-existent"
1407               "/ejected device.\n", dev->name, irq);
1408         handled = 0;
1409         goto irq_done;
1410     }
1411
1412     SMC_SELECT_BANK(2);
1413     saved_pointer = inw(ioaddr + POINTER);
1414     mask = inw(ioaddr + INTERRUPT) >> 8;
1415     /* clear all interrupts */
1416     outw(0, ioaddr + INTERRUPT);
1417
1418     do { /* read the status flag, and mask it */
1419         status = inw(ioaddr + INTERRUPT) & 0xff;
1420         pr_debug("%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1421               status, mask);
1422         if ((status & mask) == 0) {
1423             if (bogus_cnt == INTR_WORK)
1424                 handled = 0;
1425             break;
1426         }
1427         if (status & IM_RCV_INT) {
1428             /* Got a packet(s). */
1429             smc_rx(dev);
1430         }
1431         if (status & IM_TX_INT) {
1432             smc_tx_err(dev);
1433             outw(IM_TX_INT, ioaddr + INTERRUPT);
1434         }
1435         status &= mask;
1436         if (status & IM_TX_EMPTY_INT) {
1437             outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1438             mask &= ~IM_TX_EMPTY_INT;
1439             dev->stats.tx_packets += smc->packets_waiting;
1440             smc->packets_waiting = 0;
1441         }
1442         if (status & IM_ALLOC_INT) {
1443             /* Clear this interrupt so it doesn't happen again */
1444             mask &= ~IM_ALLOC_INT;
1445
1446             smc_hardware_send_packet(dev);
1447
1448             /* enable xmit interrupts based on this */
1449             mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1450
1451             /* and let the card send more packets to me */
1452             netif_wake_queue(dev);
1453         }
1454         if (status & IM_RX_OVRN_INT) {
1455             dev->stats.rx_errors++;
1456             dev->stats.rx_fifo_errors++;
1457             if (smc->duplex)
1458                 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1459             outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1460         }
1461         if (status & IM_EPH_INT)
1462             smc_eph_irq(dev);
1463     } while (--bogus_cnt);
1464
1465     pr_debug("  Restoring saved registers mask %2.2x bank %4.4x"
1466           " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1467
1468     /* restore state register */
1469     outw((mask<<8), ioaddr + INTERRUPT);
1470     outw(saved_pointer, ioaddr + POINTER);
1471     SMC_SELECT_BANK(saved_bank);
1472
1473     pr_debug("%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1474
1475 irq_done:
1476
1477     if ((smc->manfid == MANFID_OSITECH) &&
1478         (smc->cardid != PRODID_OSITECH_SEVEN)) {
1479         /* Retrigger interrupt if needed */
1480         mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1481         set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1482     }
1483     if (smc->manfid == MANFID_MOTOROLA) {
1484         u_char cor;
1485         cor = readb(smc->base + MOT_UART + CISREG_COR);
1486         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1487         writeb(cor, smc->base + MOT_UART + CISREG_COR);
1488         cor = readb(smc->base + MOT_LAN + CISREG_COR);
1489         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1490         writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1491     }
1492
1493     if ((smc->base != NULL) &&  /* Megahertz MFC's */
1494         (smc->manfid == MANFID_MEGAHERTZ) &&
1495         (smc->cardid == PRODID_MEGAHERTZ_EM3288)) {
1496
1497         u_char tmp;
1498         tmp = readb(smc->base+MEGAHERTZ_ISR);
1499         tmp = readb(smc->base+MEGAHERTZ_ISR);
1500
1501         /* Retrigger interrupt if needed */
1502         writeb(tmp, smc->base + MEGAHERTZ_ISR);
1503         writeb(tmp, smc->base + MEGAHERTZ_ISR);
1504     }
1505
1506     spin_unlock(&smc->lock);
1507     return IRQ_RETVAL(handled);
1508 }
1509
1510 /*====================================================================*/
1511
1512 static void smc_rx(struct net_device *dev)
1513 {
1514     unsigned int ioaddr = dev->base_addr;
1515     int rx_status;
1516     int packet_length;  /* Caution: not frame length, rather words
1517                            to transfer from the chip. */
1518
1519     /* Assertion: we are in Window 2. */
1520
1521     if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1522         printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1523                dev->name);
1524         return;
1525     }
1526
1527     /*  Reset the read pointer, and read the status and packet length. */
1528     outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1529     rx_status = inw(ioaddr + DATA_1);
1530     packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1531
1532     pr_debug("%s: Receive status %4.4x length %d.\n",
1533           dev->name, rx_status, packet_length);
1534
1535     if (!(rx_status & RS_ERRORS)) {
1536         /* do stuff to make a new packet */
1537         struct sk_buff *skb;
1538
1539         /* Note: packet_length adds 5 or 6 extra bytes here! */
1540         skb = dev_alloc_skb(packet_length+2);
1541
1542         if (skb == NULL) {
1543             pr_debug("%s: Low memory, packet dropped.\n", dev->name);
1544             dev->stats.rx_dropped++;
1545             outw(MC_RELEASE, ioaddr + MMU_CMD);
1546             return;
1547         }
1548
1549         packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1550         skb_reserve(skb, 2);
1551         insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1552              (packet_length+1)>>1);
1553         skb->protocol = eth_type_trans(skb, dev);
1554
1555         netif_rx(skb);
1556         dev->last_rx = jiffies;
1557         dev->stats.rx_packets++;
1558         dev->stats.rx_bytes += packet_length;
1559         if (rx_status & RS_MULTICAST)
1560             dev->stats.multicast++;
1561     } else {
1562         /* error ... */
1563         dev->stats.rx_errors++;
1564
1565         if (rx_status & RS_ALGNERR)  dev->stats.rx_frame_errors++;
1566         if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1567             dev->stats.rx_length_errors++;
1568         if (rx_status & RS_BADCRC)      dev->stats.rx_crc_errors++;
1569     }
1570     /* Let the MMU free the memory of this packet. */
1571     outw(MC_RELEASE, ioaddr + MMU_CMD);
1572 }
1573
1574 /*======================================================================
1575
1576     Set the receive mode.
1577
1578     This routine is used by both the protocol level to notify us of
1579     promiscuous/multicast mode changes, and by the open/reset code to
1580     initialize the Rx registers.  We always set the multicast list and
1581     leave the receiver running.
1582
1583 ======================================================================*/
1584
1585 static void set_rx_mode(struct net_device *dev)
1586 {
1587     unsigned int ioaddr = dev->base_addr;
1588     struct smc_private *smc = netdev_priv(dev);
1589     unsigned char multicast_table[8];
1590     unsigned long flags;
1591     u_short rx_cfg_setting;
1592     int i;
1593
1594     memset(multicast_table, 0, sizeof(multicast_table));
1595
1596     if (dev->flags & IFF_PROMISC) {
1597         rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1598     } else if (dev->flags & IFF_ALLMULTI)
1599         rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1600     else {
1601         if (!netdev_mc_empty(dev)) {
1602             struct netdev_hw_addr *ha;
1603
1604             netdev_for_each_mc_addr(ha, dev) {
1605                 u_int position = ether_crc(6, ha->addr);
1606                 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1607             }
1608         }
1609         rx_cfg_setting = RxStripCRC | RxEnable;
1610     }
1611
1612     /* Load MC table and Rx setting into the chip without interrupts. */
1613     spin_lock_irqsave(&smc->lock, flags);
1614     SMC_SELECT_BANK(3);
1615     for (i = 0; i < 8; i++)
1616         outb(multicast_table[i], ioaddr + MULTICAST0 + i);
1617     SMC_SELECT_BANK(0);
1618     outw(rx_cfg_setting, ioaddr + RCR);
1619     SMC_SELECT_BANK(2);
1620     spin_unlock_irqrestore(&smc->lock, flags);
1621 }
1622
1623 /*======================================================================
1624
1625     Senses when a card's config changes. Here, it's coax or TP.
1626
1627 ======================================================================*/
1628
1629 static int s9k_config(struct net_device *dev, struct ifmap *map)
1630 {
1631     struct smc_private *smc = netdev_priv(dev);
1632     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1633         if (smc->cfg & CFG_MII_SELECT)
1634             return -EOPNOTSUPP;
1635         else if (map->port > 2)
1636             return -EINVAL;
1637         dev->if_port = map->port;
1638         printk(KERN_INFO "%s: switched to %s port\n",
1639                dev->name, if_names[dev->if_port]);
1640         smc_reset(dev);
1641     }
1642     return 0;
1643 }
1644
1645 /*======================================================================
1646
1647     Reset the chip, reloading every register that might be corrupted.
1648
1649 ======================================================================*/
1650
1651 /*
1652   Set transceiver type, perhaps to something other than what the user
1653   specified in dev->if_port.
1654 */
1655 static void smc_set_xcvr(struct net_device *dev, int if_port)
1656 {
1657     struct smc_private *smc = netdev_priv(dev);
1658     unsigned int ioaddr = dev->base_addr;
1659     u_short saved_bank;
1660
1661     saved_bank = inw(ioaddr + BANK_SELECT);
1662     SMC_SELECT_BANK(1);
1663     if (if_port == 2) {
1664         outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1665         if ((smc->manfid == MANFID_OSITECH) &&
1666             (smc->cardid != PRODID_OSITECH_SEVEN))
1667             set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1668         smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1669     } else {
1670         outw(smc->cfg, ioaddr + CONFIG);
1671         if ((smc->manfid == MANFID_OSITECH) &&
1672             (smc->cardid != PRODID_OSITECH_SEVEN))
1673             mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1674         smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1675     }
1676     SMC_SELECT_BANK(saved_bank);
1677 }
1678
1679 static void smc_reset(struct net_device *dev)
1680 {
1681     unsigned int ioaddr = dev->base_addr;
1682     struct smc_private *smc = netdev_priv(dev);
1683     int i;
1684
1685     pr_debug("%s: smc91c92 reset called.\n", dev->name);
1686
1687     /* The first interaction must be a write to bring the chip out
1688        of sleep mode. */
1689     SMC_SELECT_BANK(0);
1690     /* Reset the chip. */
1691     outw(RCR_SOFTRESET, ioaddr + RCR);
1692     udelay(10);
1693
1694     /* Clear the transmit and receive configuration registers. */
1695     outw(RCR_CLEAR, ioaddr + RCR);
1696     outw(TCR_CLEAR, ioaddr + TCR);
1697
1698     /* Set the Window 1 control, configuration and station addr registers.
1699        No point in writing the I/O base register ;-> */
1700     SMC_SELECT_BANK(1);
1701     /* Automatically release successfully transmitted packets,
1702        Accept link errors, counter and Tx error interrupts. */
1703     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1704          ioaddr + CONTROL);
1705     smc_set_xcvr(dev, dev->if_port);
1706     if ((smc->manfid == MANFID_OSITECH) &&
1707         (smc->cardid != PRODID_OSITECH_SEVEN))
1708         outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1709              (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1710              ioaddr - 0x10 + OSITECH_AUI_PWR);
1711
1712     /* Fill in the physical address.  The databook is wrong about the order! */
1713     for (i = 0; i < 6; i += 2)
1714         outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1715              ioaddr + ADDR0 + i);
1716
1717     /* Reset the MMU */
1718     SMC_SELECT_BANK(2);
1719     outw(MC_RESET, ioaddr + MMU_CMD);
1720     outw(0, ioaddr + INTERRUPT);
1721
1722     /* Re-enable the chip. */
1723     SMC_SELECT_BANK(0);
1724     outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1725          TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1726     set_rx_mode(dev);
1727
1728     if (smc->cfg & CFG_MII_SELECT) {
1729         SMC_SELECT_BANK(3);
1730
1731         /* Reset MII */
1732         mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1733
1734         /* Advertise 100F, 100H, 10F, 10H */
1735         mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1736
1737         /* Restart MII autonegotiation */
1738         mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1739         mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1740     }
1741
1742     /* Enable interrupts. */
1743     SMC_SELECT_BANK(2);
1744     outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
1745          ioaddr + INTERRUPT);
1746 }
1747
1748 /*======================================================================
1749
1750     Media selection timer routine
1751
1752 ======================================================================*/
1753
1754 static void media_check(u_long arg)
1755 {
1756     struct net_device *dev = (struct net_device *) arg;
1757     struct smc_private *smc = netdev_priv(dev);
1758     unsigned int ioaddr = dev->base_addr;
1759     u_short i, media, saved_bank;
1760     u_short link;
1761     unsigned long flags;
1762
1763     spin_lock_irqsave(&smc->lock, flags);
1764
1765     saved_bank = inw(ioaddr + BANK_SELECT);
1766
1767     if (!netif_device_present(dev))
1768         goto reschedule;
1769
1770     SMC_SELECT_BANK(2);
1771
1772     /* need MC_RESET to keep the memory consistent. errata? */
1773     if (smc->rx_ovrn) {
1774         outw(MC_RESET, ioaddr + MMU_CMD);
1775         smc->rx_ovrn = 0;
1776     }
1777     i = inw(ioaddr + INTERRUPT);
1778     SMC_SELECT_BANK(0);
1779     media = inw(ioaddr + EPH) & EPH_LINK_OK;
1780     SMC_SELECT_BANK(1);
1781     media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
1782
1783     SMC_SELECT_BANK(saved_bank);
1784     spin_unlock_irqrestore(&smc->lock, flags);
1785
1786     /* Check for pending interrupt with watchdog flag set: with
1787        this, we can limp along even if the interrupt is blocked */
1788     if (smc->watchdog++ && ((i>>8) & i)) {
1789         if (!smc->fast_poll)
1790             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1791         local_irq_save(flags);
1792         smc_interrupt(dev->irq, dev);
1793         local_irq_restore(flags);
1794         smc->fast_poll = HZ;
1795     }
1796     if (smc->fast_poll) {
1797         smc->fast_poll--;
1798         smc->media.expires = jiffies + HZ/100;
1799         add_timer(&smc->media);
1800         return;
1801     }
1802
1803     spin_lock_irqsave(&smc->lock, flags);
1804
1805     saved_bank = inw(ioaddr + BANK_SELECT);
1806
1807     if (smc->cfg & CFG_MII_SELECT) {
1808         if (smc->mii_if.phy_id < 0)
1809             goto reschedule;
1810
1811         SMC_SELECT_BANK(3);
1812         link = mdio_read(dev, smc->mii_if.phy_id, 1);
1813         if (!link || (link == 0xffff)) {
1814             printk(KERN_INFO "%s: MII is missing!\n", dev->name);
1815             smc->mii_if.phy_id = -1;
1816             goto reschedule;
1817         }
1818
1819         link &= 0x0004;
1820         if (link != smc->link_status) {
1821             u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
1822             printk(KERN_INFO "%s: %s link beat\n", dev->name,
1823                 (link) ? "found" : "lost");
1824             smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
1825                            ? TCR_FDUPLX : 0);
1826             if (link) {
1827                 printk(KERN_INFO "%s: autonegotiation complete: "
1828                        "%sbaseT-%cD selected\n", dev->name,
1829                        ((p & 0x0180) ? "100" : "10"),
1830                        (smc->duplex ? 'F' : 'H'));
1831             }
1832             SMC_SELECT_BANK(0);
1833             outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
1834             smc->link_status = link;
1835         }
1836         goto reschedule;
1837     }
1838
1839     /* Ignore collisions unless we've had no rx's recently */
1840     if (time_after(jiffies, dev->last_rx + HZ)) {
1841         if (smc->tx_err || (smc->media_status & EPH_16COL))
1842             media |= EPH_16COL;
1843     }
1844     smc->tx_err = 0;
1845
1846     if (media != smc->media_status) {
1847         if ((media & smc->media_status & 1) &&
1848             ((smc->media_status ^ media) & EPH_LINK_OK))
1849             printk(KERN_INFO "%s: %s link beat\n", dev->name,
1850                    (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
1851         else if ((media & smc->media_status & 2) &&
1852                  ((smc->media_status ^ media) & EPH_16COL))
1853             printk(KERN_INFO "%s: coax cable %s\n", dev->name,
1854                    (media & EPH_16COL ? "problem" : "ok"));
1855         if (dev->if_port == 0) {
1856             if (media & 1) {
1857                 if (media & EPH_LINK_OK)
1858                     printk(KERN_INFO "%s: flipped to 10baseT\n",
1859                            dev->name);
1860                 else
1861                     smc_set_xcvr(dev, 2);
1862             } else {
1863                 if (media & EPH_16COL)
1864                     smc_set_xcvr(dev, 1);
1865                 else
1866                     printk(KERN_INFO "%s: flipped to 10base2\n",
1867                            dev->name);
1868             }
1869         }
1870         smc->media_status = media;
1871     }
1872
1873 reschedule:
1874     smc->media.expires = jiffies + HZ;
1875     add_timer(&smc->media);
1876     SMC_SELECT_BANK(saved_bank);
1877     spin_unlock_irqrestore(&smc->lock, flags);
1878 }
1879
1880 static int smc_link_ok(struct net_device *dev)
1881 {
1882     unsigned int ioaddr = dev->base_addr;
1883     struct smc_private *smc = netdev_priv(dev);
1884
1885     if (smc->cfg & CFG_MII_SELECT) {
1886         return mii_link_ok(&smc->mii_if);
1887     } else {
1888         SMC_SELECT_BANK(0);
1889         return inw(ioaddr + EPH) & EPH_LINK_OK;
1890     }
1891 }
1892
1893 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1894 {
1895     u16 tmp;
1896     unsigned int ioaddr = dev->base_addr;
1897
1898     ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
1899         SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
1900
1901     SMC_SELECT_BANK(1);
1902     tmp = inw(ioaddr + CONFIG);
1903     ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
1904     ecmd->transceiver = XCVR_INTERNAL;
1905     ecmd->speed = SPEED_10;
1906     ecmd->phy_address = ioaddr + MGMT;
1907
1908     SMC_SELECT_BANK(0);
1909     tmp = inw(ioaddr + TCR);
1910     ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
1911
1912     return 0;
1913 }
1914
1915 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1916 {
1917     u16 tmp;
1918     unsigned int ioaddr = dev->base_addr;
1919
1920     if (ecmd->speed != SPEED_10)
1921         return -EINVAL;
1922     if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1923         return -EINVAL;
1924     if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
1925         return -EINVAL;
1926     if (ecmd->transceiver != XCVR_INTERNAL)
1927         return -EINVAL;
1928
1929     if (ecmd->port == PORT_AUI)
1930         smc_set_xcvr(dev, 1);
1931     else
1932         smc_set_xcvr(dev, 0);
1933
1934     SMC_SELECT_BANK(0);
1935     tmp = inw(ioaddr + TCR);
1936     if (ecmd->duplex == DUPLEX_FULL)
1937         tmp |= TCR_FDUPLX;
1938     else
1939         tmp &= ~TCR_FDUPLX;
1940     outw(tmp, ioaddr + TCR);
1941
1942     return 0;
1943 }
1944
1945 static int check_if_running(struct net_device *dev)
1946 {
1947         if (!netif_running(dev))
1948                 return -EINVAL;
1949         return 0;
1950 }
1951
1952 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1953 {
1954         strcpy(info->driver, DRV_NAME);
1955         strcpy(info->version, DRV_VERSION);
1956 }
1957
1958 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1959 {
1960         struct smc_private *smc = netdev_priv(dev);
1961         unsigned int ioaddr = dev->base_addr;
1962         u16 saved_bank = inw(ioaddr + BANK_SELECT);
1963         int ret;
1964         unsigned long flags;
1965
1966         spin_lock_irqsave(&smc->lock, flags);
1967         SMC_SELECT_BANK(3);
1968         if (smc->cfg & CFG_MII_SELECT)
1969                 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
1970         else
1971                 ret = smc_netdev_get_ecmd(dev, ecmd);
1972         SMC_SELECT_BANK(saved_bank);
1973         spin_unlock_irqrestore(&smc->lock, flags);
1974         return ret;
1975 }
1976
1977 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1978 {
1979         struct smc_private *smc = netdev_priv(dev);
1980         unsigned int ioaddr = dev->base_addr;
1981         u16 saved_bank = inw(ioaddr + BANK_SELECT);
1982         int ret;
1983         unsigned long flags;
1984
1985         spin_lock_irqsave(&smc->lock, flags);
1986         SMC_SELECT_BANK(3);
1987         if (smc->cfg & CFG_MII_SELECT)
1988                 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
1989         else
1990                 ret = smc_netdev_set_ecmd(dev, ecmd);
1991         SMC_SELECT_BANK(saved_bank);
1992         spin_unlock_irqrestore(&smc->lock, flags);
1993         return ret;
1994 }
1995
1996 static u32 smc_get_link(struct net_device *dev)
1997 {
1998         struct smc_private *smc = netdev_priv(dev);
1999         unsigned int ioaddr = dev->base_addr;
2000         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2001         u32 ret;
2002         unsigned long flags;
2003
2004         spin_lock_irqsave(&smc->lock, flags);
2005         SMC_SELECT_BANK(3);
2006         ret = smc_link_ok(dev);
2007         SMC_SELECT_BANK(saved_bank);
2008         spin_unlock_irqrestore(&smc->lock, flags);
2009         return ret;
2010 }
2011
2012 static int smc_nway_reset(struct net_device *dev)
2013 {
2014         struct smc_private *smc = netdev_priv(dev);
2015         if (smc->cfg & CFG_MII_SELECT) {
2016                 unsigned int ioaddr = dev->base_addr;
2017                 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2018                 int res;
2019
2020                 SMC_SELECT_BANK(3);
2021                 res = mii_nway_restart(&smc->mii_if);
2022                 SMC_SELECT_BANK(saved_bank);
2023
2024                 return res;
2025         } else
2026                 return -EOPNOTSUPP;
2027 }
2028
2029 static const struct ethtool_ops ethtool_ops = {
2030         .begin = check_if_running,
2031         .get_drvinfo = smc_get_drvinfo,
2032         .get_settings = smc_get_settings,
2033         .set_settings = smc_set_settings,
2034         .get_link = smc_get_link,
2035         .nway_reset = smc_nway_reset,
2036 };
2037
2038 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2039 {
2040         struct smc_private *smc = netdev_priv(dev);
2041         struct mii_ioctl_data *mii = if_mii(rq);
2042         int rc = 0;
2043         u16 saved_bank;
2044         unsigned int ioaddr = dev->base_addr;
2045         unsigned long flags;
2046
2047         if (!netif_running(dev))
2048                 return -EINVAL;
2049
2050         spin_lock_irqsave(&smc->lock, flags);
2051         saved_bank = inw(ioaddr + BANK_SELECT);
2052         SMC_SELECT_BANK(3);
2053         rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2054         SMC_SELECT_BANK(saved_bank);
2055         spin_unlock_irqrestore(&smc->lock, flags);
2056         return rc;
2057 }
2058
2059 static struct pcmcia_device_id smc91c92_ids[] = {
2060         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2061         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2062         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2063         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2064         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2065         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2066         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2067         PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2068         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2069         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2070         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2071         PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2072         PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2073         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2074         PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2075         PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2076         PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2077         PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2078         PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2079         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2080         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2081         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2082         PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2083         PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2084         /* These conflict with other cards! */
2085         /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2086         /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2087         PCMCIA_DEVICE_NULL,
2088 };
2089 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2090
2091 static struct pcmcia_driver smc91c92_cs_driver = {
2092         .owner          = THIS_MODULE,
2093         .name           = "smc91c92_cs",
2094         .probe          = smc91c92_probe,
2095         .remove         = smc91c92_detach,
2096         .id_table       = smc91c92_ids,
2097         .suspend        = smc91c92_suspend,
2098         .resume         = smc91c92_resume,
2099 };
2100
2101 static int __init init_smc91c92_cs(void)
2102 {
2103         return pcmcia_register_driver(&smc91c92_cs_driver);
2104 }
2105
2106 static void __exit exit_smc91c92_cs(void)
2107 {
2108         pcmcia_unregister_driver(&smc91c92_cs_driver);
2109 }
2110
2111 module_init(init_smc91c92_cs);
2112 module_exit(exit_smc91c92_cs);