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