drivers/net/pcmcia/3c574_cs.c

   1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
   2
   3         Written 1993-1998 by
   4         Donald Becker, becker@scyld.com, (driver core) and
   5         David Hinds, dahinds@users.sourceforge.net (from his PC card code).
   6         Locking fixes (C) Copyright 2003 Red Hat Inc
   7
   8         This software may be used and distributed according to the terms of
   9         the GNU General Public License, incorporated herein by reference.
  10
  11         This driver derives from Donald Becker's 3c509 core, which has the
  12         following copyright:
  13         Copyright 1993 United States Government as represented by the
  14         Director, National Security Agency.
  15
  16
  17 */
  18
  19 /*
  20                                 Theory of Operation
  21
  22 I. Board Compatibility
  23
  24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
  25 Adapter.
  26
  27 II. Board-specific settings
  28
  29 None -- PC cards are autoconfigured.
  30
  31 III. Driver operation
  32
  33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
  34 See the Boomerang driver and documentation for most details.
  35
  36 IV. Notes and chip documentation.
  37
  38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
  39 RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
  40 count of word (16 bits) reads or writes the driver is about to do to the Rx
  41 or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
  42 translation latency by buffering the I/O operations with an 8 word FIFO.
  43 Note: No other chip accesses are permitted when this buffer is used.
  44
  45 A second enhancement is that both attribute and common memory space
  46 0x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
  47 with *some* PCcard bridges) may be used instead of I/O operations.
  48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
  49
  50 Some slow PC card bridges work better if they never see a WAIT signal.
  51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
  52 Only do this after testing that it is reliable and improves performance.
  53
  54 The upper five bits of RunnerRdCtrl are used to window into PCcard
  55 configuration space registers.  Window 0 is the regular Boomerang/Odie
  56 register set, 1-5 are various PC card control registers, and 16-31 are
  57 the (reversed!) CIS table.
  58
  59 A final note: writing the InternalConfig register in window 3 with an
  60 invalid ramWidth is Very Bad.
  61
  62 V. References
  63
  64 http://www.scyld.com/expert/NWay.html
  65 http://www.national.com/pf/DP/DP83840.html
  66
  67 Thanks to Terry Murphy of 3Com for providing development information for
  68 earlier 3Com products.
  69
  70 */
  71
  72 #include <linux/module.h>
  73 #include <linux/kernel.h>
  74 #include <linux/init.h>
  75 #include <linux/slab.h>
  76 #include <linux/string.h>
  77 #include <linux/timer.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/in.h>
  80 #include <linux/delay.h>
  81 #include <linux/netdevice.h>
  82 #include <linux/etherdevice.h>
  83 #include <linux/skbuff.h>
  84 #include <linux/if_arp.h>
  85 #include <linux/ioport.h>
  86 #include <linux/ethtool.h>
  87 #include <linux/bitops.h>
  88 #include <linux/mii.h>
  89
  90 #include <pcmcia/cs_types.h>
  91 #include <pcmcia/cs.h>
  92 #include <pcmcia/cistpl.h>
  93 #include <pcmcia/cisreg.h>
  94 #include <pcmcia/ciscode.h>
  95 #include <pcmcia/ds.h>
  96
  97 #include <asm/uaccess.h>
  98 #include <asm/io.h>
  99 #include <asm/system.h>
 100
 101 /*====================================================================*/
 102
 103 /* Module parameters */
 104
 105 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 106 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
 107 MODULE_LICENSE("GPL");
 108
 109 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
 110
 111 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 112 INT_MODULE_PARM(max_interrupt_work, 32);
 113
 114 /* Force full duplex modes? */
 115 INT_MODULE_PARM(full_duplex, 0);
 116
 117 /* Autodetect link polarity reversal? */
 118 INT_MODULE_PARM(auto_polarity, 1);
 119
 120
 121 /*====================================================================*/
 122
 123 /* Time in jiffies before concluding the transmitter is hung. */
 124 #define TX_TIMEOUT  ((800*HZ)/1000)
 125
 126 /* To minimize the size of the driver source and make the driver more
 127    readable not all constants are symbolically defined.
 128    You'll need the manual if you want to understand driver details anyway. */
 129 /* Offsets from base I/O address. */
 130 #define EL3_DATA        0x00
 131 #define EL3_CMD         0x0e
 132 #define EL3_STATUS      0x0e
 133
 134 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 135
 136 /* The top five bits written to EL3_CMD are a command, the lower
 137    11 bits are the parameter, if applicable. */
 138 enum el3_cmds {
 139         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 140         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 141         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 142         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 143         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 144         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 145         StatsDisable = 22<<11, StopCoax = 23<<11,
 146 };
 147
 148 enum elxl_status {
 149         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 150         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 151         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
 152
 153 /* The SetRxFilter command accepts the following classes: */
 154 enum RxFilter {
 155         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
 156 };
 157
 158 enum Window0 {
 159         Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
 160         IntrStatus=0x0E,                /* Valid in all windows. */
 161 };
 162 /* These assumes the larger EEPROM. */
 163 enum Win0_EEPROM_cmds {
 164         EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
 165         EEPROM_EWENB = 0x30,            /* Enable erasing/writing for 10 msec. */
 166         EEPROM_EWDIS = 0x00,            /* Disable EWENB before 10 msec timeout. */
 167 };
 168
 169 /* Register window 1 offsets, the window used in normal operation.
 170    On the "Odie" this window is always mapped at offsets 0x10-0x1f.
 171    Except for TxFree, which is overlapped by RunnerWrCtrl. */
 172 enum Window1 {
 173         TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
 174         RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
 175         TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
 176         RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
 177 };
 178
 179 enum Window3 {                  /* Window 3: MAC/config bits. */
 180         Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
 181 };
 182 enum wn3_config {
 183         Ram_size = 7,
 184         Ram_width = 8,
 185         Ram_speed = 0x30,
 186         Rom_size = 0xc0,
 187         Ram_split_shift = 16,
 188         Ram_split = 3 << Ram_split_shift,
 189         Xcvr_shift = 20,
 190         Xcvr = 7 << Xcvr_shift,
 191         Autoselect = 0x1000000,
 192 };
 193
 194 enum Window4 {          /* Window 4: Xcvr/media bits. */
 195         Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
 196 };
 197
 198 #define MEDIA_TP        0x00C0  /* Enable link beat and jabber for 10baseT. */
 199
 200 struct el3_private {
 201         struct pcmcia_device    *p_dev;
 202         u16 advertising, partner;               /* NWay media advertisement */
 203         unsigned char phys;                     /* MII device address */
 204         unsigned int autoselect:1, default_media:3;     /* Read from the EEPROM/Wn3_Config. */
 205         /* for transceiver monitoring */
 206         struct timer_list media;
 207         unsigned short media_status;
 208         unsigned short fast_poll;
 209         unsigned long last_irq;
 210         spinlock_t window_lock;                 /* Guards the Window selection */
 211 };
 212
 213 /* Set iff a MII transceiver on any interface requires mdio preamble.
 214    This only set with the original DP83840 on older 3c905 boards, so the extra
 215    code size of a per-interface flag is not worthwhile. */
 216 static char mii_preamble_required = 0;
 217
 218 /* Index of functions. */
 219
 220 static int tc574_config(struct pcmcia_device *link);
 221 static void tc574_release(struct pcmcia_device *link);
 222
 223 static void mdio_sync(unsigned int ioaddr, int bits);
 224 static int mdio_read(unsigned int ioaddr, int phy_id, int location);
 225 static void mdio_write(unsigned int ioaddr, int phy_id, int location,
 226                        int value);
 227 static unsigned short read_eeprom(unsigned int ioaddr, int index);
 228 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
 229
 230 static void tc574_reset(struct net_device *dev);
 231 static void media_check(unsigned long arg);
 232 static int el3_open(struct net_device *dev);
 233 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 234                                         struct net_device *dev);
 235 static irqreturn_t el3_interrupt(int irq, void *dev_id);
 236 static void update_stats(struct net_device *dev);
 237 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 238 static int el3_rx(struct net_device *dev, int worklimit);
 239 static int el3_close(struct net_device *dev);
 240 static void el3_tx_timeout(struct net_device *dev);
 241 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 242 static const struct ethtool_ops netdev_ethtool_ops;
 243 static void set_rx_mode(struct net_device *dev);
 244 static void set_multicast_list(struct net_device *dev);
 245
 246 static void tc574_detach(struct pcmcia_device *p_dev);
 247
 248 /*
 249         tc574_attach() creates an "instance" of the driver, allocating
 250         local data structures for one device.  The device is registered
 251         with Card Services.
 252 */
 253 static const struct net_device_ops el3_netdev_ops = {
 254         .ndo_open               = el3_open,
 255         .ndo_stop               = el3_close,
 256         .ndo_start_xmit         = el3_start_xmit,
 257         .ndo_tx_timeout         = el3_tx_timeout,
 258         .ndo_get_stats          = el3_get_stats,
 259         .ndo_do_ioctl           = el3_ioctl,
 260         .ndo_set_multicast_list = set_multicast_list,
 261         .ndo_change_mtu         = eth_change_mtu,
 262         .ndo_set_mac_address    = eth_mac_addr,
 263         .ndo_validate_addr      = eth_validate_addr,
 264 };
 265
 266 static int tc574_probe(struct pcmcia_device *link)
 267 {
 268         struct el3_private *lp;
 269         struct net_device *dev;
 270
 271         dev_dbg(&link->dev, "3c574_attach()\n");
 272
 273         /* Create the PC card device object. */
 274         dev = alloc_etherdev(sizeof(struct el3_private));
 275         if (!dev)
 276                 return -ENOMEM;
 277         lp = netdev_priv(dev);
 278         link->priv = dev;
 279         lp->p_dev = link;
 280
 281         spin_lock_init(&lp->window_lock);
 282         link->io.NumPorts1 = 32;
 283         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 284         link->conf.Attributes = CONF_ENABLE_IRQ;
 285         link->conf.IntType = INT_MEMORY_AND_IO;
 286         link->conf.ConfigIndex = 1;
 287
 288         dev->netdev_ops = &el3_netdev_ops;
 289         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 290         dev->watchdog_timeo = TX_TIMEOUT;
 291
 292         return tc574_config(link);
 293 } /* tc574_attach */
 294
 295 /*
 296
 297         This deletes a driver "instance".  The device is de-registered
 298         with Card Services.  If it has been released, all local data
 299         structures are freed.  Otherwise, the structures will be freed
 300         when the device is released.
 301
 302 */
 303
 304 static void tc574_detach(struct pcmcia_device *link)
 305 {
 306         struct net_device *dev = link->priv;
 307
 308         dev_dbg(&link->dev, "3c574_detach()\n");
 309
 310         unregister_netdev(dev);
 311
 312         tc574_release(link);
 313
 314         free_netdev(dev);
 315 } /* tc574_detach */
 316
 317 /*
 318         tc574_config() is scheduled to run after a CARD_INSERTION event
 319         is received, to configure the PCMCIA socket, and to make the
 320         ethernet device available to the system.
 321 */
 322
 323 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 324
 325 static int tc574_config(struct pcmcia_device *link)
 326 {
 327         struct net_device *dev = link->priv;
 328         struct el3_private *lp = netdev_priv(dev);
 329         int ret, i, j;
 330         unsigned int ioaddr;
 331         __be16 *phys_addr;
 332         char *cardname;
 333         __u32 config;
 334         u8 *buf;
 335         size_t len;
 336
 337         phys_addr = (__be16 *)dev->dev_addr;
 338
 339         dev_dbg(&link->dev, "3c574_config()\n");
 340
 341         link->io.IOAddrLines = 16;
 342         for (i = j = 0; j < 0x400; j += 0x20) {
 343                 link->io.BasePort1 = j ^ 0x300;
 344                 i = pcmcia_request_io(link, &link->io);
 345                 if (i == 0)
 346                         break;
 347         }
 348         if (i != 0)
 349                 goto failed;
 350
 351         ret = pcmcia_request_irq(link, el3_interrupt);
 352         if (ret)
 353                 goto failed;
 354
 355         ret = pcmcia_request_configuration(link, &link->conf);
 356         if (ret)
 357                 goto failed;
 358
 359         dev->irq = link->irq;
 360         dev->base_addr = link->io.BasePort1;
 361
 362         ioaddr = dev->base_addr;
 363
 364         /* The 3c574 normally uses an EEPROM for configuration info, including
 365            the hardware address.  The future products may include a modem chip
 366            and put the address in the CIS. */
 367
 368         len = pcmcia_get_tuple(link, 0x88, &buf);
 369         if (buf && len >= 6) {
 370                 for (i = 0; i < 3; i++)
 371                         phys_addr[i] = htons(le16_to_cpu(buf[i * 2]));
 372                 kfree(buf);
 373         } else {
 374                 kfree(buf); /* 0 < len < 6 */
 375                 EL3WINDOW(0);
 376                 for (i = 0; i < 3; i++)
 377                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
 378                 if (phys_addr[0] == htons(0x6060)) {
 379                         printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
 380                                    "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
 381                         goto failed;
 382                 }
 383         }
 384         if (link->prod_id[1])
 385                 cardname = link->prod_id[1];
 386         else
 387                 cardname = "3Com 3c574";
 388
 389         {
 390                 u_char mcr;
 391                 outw(2<<11, ioaddr + RunnerRdCtrl);
 392                 mcr = inb(ioaddr + 2);
 393                 outw(0<<11, ioaddr + RunnerRdCtrl);
 394                 printk(KERN_INFO "  ASIC rev %d,", mcr>>3);
 395                 EL3WINDOW(3);
 396                 config = inl(ioaddr + Wn3_Config);
 397                 lp->default_media = (config & Xcvr) >> Xcvr_shift;
 398                 lp->autoselect = config & Autoselect ? 1 : 0;
 399         }
 400
 401         init_timer(&lp->media);
 402
 403         {
 404                 int phy;
 405
 406                 /* Roadrunner only: Turn on the MII transceiver */
 407                 outw(0x8040, ioaddr + Wn3_Options);
 408                 mdelay(1);
 409                 outw(0xc040, ioaddr + Wn3_Options);
 410                 tc574_wait_for_completion(dev, TxReset);
 411                 tc574_wait_for_completion(dev, RxReset);
 412                 mdelay(1);
 413                 outw(0x8040, ioaddr + Wn3_Options);
 414
 415                 EL3WINDOW(4);
 416                 for (phy = 1; phy <= 32; phy++) {
 417                         int mii_status;
 418                         mdio_sync(ioaddr, 32);
 419                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
 420                         if (mii_status != 0xffff) {
 421                                 lp->phys = phy & 0x1f;
 422                                 dev_dbg(&link->dev, "  MII transceiver at "
 423                                         "index %d, status %x.\n",
 424                                           phy, mii_status);
 425                                 if ((mii_status & 0x0040) == 0)
 426                                         mii_preamble_required = 1;
 427                                 break;
 428                         }
 429                 }
 430                 if (phy > 32) {
 431                         printk(KERN_NOTICE "  No MII transceivers found!\n");
 432                         goto failed;
 433                 }
 434                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
 435                 mdio_write(ioaddr, lp->phys, 16, i);
 436                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
 437                 if (full_duplex) {
 438                         /* Only advertise the FD media types. */
 439                         lp->advertising &= ~0x02a0;
 440                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 441                 }
 442         }
 443
 444         SET_NETDEV_DEV(dev, &link->dev);
 445
 446         if (register_netdev(dev) != 0) {
 447                 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
 448                 goto failed;
 449         }
 450
 451         printk(KERN_INFO "%s: %s at io %#3lx, irq %d, "
 452                "hw_addr %pM.\n",
 453                dev->name, cardname, dev->base_addr, dev->irq,
 454                dev->dev_addr);
 455         printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
 456                    8 << config & Ram_size,
 457                    ram_split[(config & Ram_split) >> Ram_split_shift],
 458                    config & Autoselect ? "autoselect " : "");
 459
 460         return 0;
 461
 462 failed:
 463         tc574_release(link);
 464         return -ENODEV;
 465
 466 } /* tc574_config */
 467
 468 /*
 469         After a card is removed, tc574_release() will unregister the net
 470         device, and release the PCMCIA configuration.  If the device is
 471         still open, this will be postponed until it is closed.
 472 */
 473
 474 static void tc574_release(struct pcmcia_device *link)
 475 {
 476         pcmcia_disable_device(link);
 477 }
 478
 479 static int tc574_suspend(struct pcmcia_device *link)
 480 {
 481         struct net_device *dev = link->priv;
 482
 483         if (link->open)
 484                 netif_device_detach(dev);
 485
 486         return 0;
 487 }
 488
 489 static int tc574_resume(struct pcmcia_device *link)
 490 {
 491         struct net_device *dev = link->priv;
 492
 493         if (link->open) {
 494                 tc574_reset(dev);
 495                 netif_device_attach(dev);
 496         }
 497
 498         return 0;
 499 }
 500
 501 static void dump_status(struct net_device *dev)
 502 {
 503         unsigned int ioaddr = dev->base_addr;
 504         EL3WINDOW(1);
 505         printk(KERN_INFO "  irq status %04x, rx status %04x, tx status "
 506                    "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
 507                    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
 508                    inw(ioaddr+TxFree));
 509         EL3WINDOW(4);
 510         printk(KERN_INFO "  diagnostics: fifo %04x net %04x ethernet %04x"
 511                    " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
 512                    inw(ioaddr+0x08), inw(ioaddr+0x0a));
 513         EL3WINDOW(1);
 514 }
 515
 516 /*
 517   Use this for commands that may take time to finish
 518 */
 519 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
 520 {
 521         int i = 1500;
 522         outw(cmd, dev->base_addr + EL3_CMD);
 523         while (--i > 0)
 524                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
 525         if (i == 0)
 526                 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
 527 }
 528
 529 /* Read a word from the EEPROM using the regular EEPROM access register.
 530    Assume that we are in register window zero.
 531  */
 532 static unsigned short read_eeprom(unsigned int ioaddr, int index)
 533 {
 534         int timer;
 535         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
 536         /* Pause for at least 162 usec for the read to take place. */
 537         for (timer = 1620; timer >= 0; timer--) {
 538                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
 539                         break;
 540         }
 541         return inw(ioaddr + Wn0EepromData);
 542 }
 543
 544 /* MII transceiver control section.
 545    Read and write the MII registers using software-generated serial
 546    MDIO protocol.  See the MII specifications or DP83840A data sheet
 547    for details.
 548    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
 549    slow PC card interface. */
 550
 551 #define MDIO_SHIFT_CLK  0x01
 552 #define MDIO_DIR_WRITE  0x04
 553 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
 554 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
 555 #define MDIO_DATA_READ  0x02
 556 #define MDIO_ENB_IN             0x00
 557
 558 /* Generate the preamble required for initial synchronization and
 559    a few older transceivers. */
 560 static void mdio_sync(unsigned int ioaddr, int bits)
 561 {
 562         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 563
 564         /* Establish sync by sending at least 32 logic ones. */
 565         while (-- bits >= 0) {
 566                 outw(MDIO_DATA_WRITE1, mdio_addr);
 567                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
 568         }
 569 }
 570
 571 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
 572 {
 573         int i;
 574         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 575         unsigned int retval = 0;
 576         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 577
 578         if (mii_preamble_required)
 579                 mdio_sync(ioaddr, 32);
 580
 581         /* Shift the read command bits out. */
 582         for (i = 14; i >= 0; i--) {
 583                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 584                 outw(dataval, mdio_addr);
 585                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 586         }
 587         /* Read the two transition, 16 data, and wire-idle bits. */
 588         for (i = 19; i > 0; i--) {
 589                 outw(MDIO_ENB_IN, mdio_addr);
 590                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
 591                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 592         }
 593         return (retval>>1) & 0xffff;
 594 }
 595
 596 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
 597 {
 598         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
 599         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 600         int i;
 601
 602         if (mii_preamble_required)
 603                 mdio_sync(ioaddr, 32);
 604
 605         /* Shift the command bits out. */
 606         for (i = 31; i >= 0; i--) {
 607                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 608                 outw(dataval, mdio_addr);
 609                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 610         }
 611         /* Leave the interface idle. */
 612         for (i = 1; i >= 0; i--) {
 613                 outw(MDIO_ENB_IN, mdio_addr);
 614                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 615         }
 616
 617         return;
 618 }
 619
 620 /* Reset and restore all of the 3c574 registers. */
 621 static void tc574_reset(struct net_device *dev)
 622 {
 623         struct el3_private *lp = netdev_priv(dev);
 624         int i;
 625         unsigned int ioaddr = dev->base_addr;
 626         unsigned long flags;
 627
 628         tc574_wait_for_completion(dev, TotalReset|0x10);
 629
 630         spin_lock_irqsave(&lp->window_lock, flags);
 631         /* Clear any transactions in progress. */
 632         outw(0, ioaddr + RunnerWrCtrl);
 633         outw(0, ioaddr + RunnerRdCtrl);
 634
 635         /* Set the station address and mask. */
 636         EL3WINDOW(2);
 637         for (i = 0; i < 6; i++)
 638                 outb(dev->dev_addr[i], ioaddr + i);
 639         for (; i < 12; i+=2)
 640                 outw(0, ioaddr + i);
 641
 642         /* Reset config options */
 643         EL3WINDOW(3);
 644         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 645         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
 646                  ioaddr + Wn3_Config);
 647         /* Roadrunner only: Turn on the MII transceiver. */
 648         outw(0x8040, ioaddr + Wn3_Options);
 649         mdelay(1);
 650         outw(0xc040, ioaddr + Wn3_Options);
 651         EL3WINDOW(1);
 652         spin_unlock_irqrestore(&lp->window_lock, flags);
 653
 654         tc574_wait_for_completion(dev, TxReset);
 655         tc574_wait_for_completion(dev, RxReset);
 656         mdelay(1);
 657         spin_lock_irqsave(&lp->window_lock, flags);
 658         EL3WINDOW(3);
 659         outw(0x8040, ioaddr + Wn3_Options);
 660
 661         /* Switch to the stats window, and clear all stats by reading. */
 662         outw(StatsDisable, ioaddr + EL3_CMD);
 663         EL3WINDOW(6);
 664         for (i = 0; i < 10; i++)
 665                 inb(ioaddr + i);
 666         inw(ioaddr + 10);
 667         inw(ioaddr + 12);
 668         EL3WINDOW(4);
 669         inb(ioaddr + 12);
 670         inb(ioaddr + 13);
 671
 672         /* .. enable any extra statistics bits.. */
 673         outw(0x0040, ioaddr + Wn4_NetDiag);
 674
 675         EL3WINDOW(1);
 676         spin_unlock_irqrestore(&lp->window_lock, flags);
 677
 678         /* .. re-sync MII and re-fill what NWay is advertising. */
 679         mdio_sync(ioaddr, 32);
 680         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 681         if (!auto_polarity) {
 682                 /* works for TDK 78Q2120 series MII's */
 683                 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
 684                 mdio_write(ioaddr, lp->phys, 16, i);
 685         }
 686
 687         spin_lock_irqsave(&lp->window_lock, flags);
 688         /* Switch to register set 1 for normal use, just for TxFree. */
 689         set_rx_mode(dev);
 690         spin_unlock_irqrestore(&lp->window_lock, flags);
 691         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 692         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 693         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 694         /* Allow status bits to be seen. */
 695         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 696         /* Ack all pending events, and set active indicator mask. */
 697         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 698                  ioaddr + EL3_CMD);
 699         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 700                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
 701 }
 702
 703 static int el3_open(struct net_device *dev)
 704 {
 705         struct el3_private *lp = netdev_priv(dev);
 706         struct pcmcia_device *link = lp->p_dev;
 707
 708         if (!pcmcia_dev_present(link))
 709                 return -ENODEV;
 710
 711         link->open++;
 712         netif_start_queue(dev);
 713
 714         tc574_reset(dev);
 715         lp->media.function = &media_check;
 716         lp->media.data = (unsigned long) dev;
 717         lp->media.expires = jiffies + HZ;
 718         add_timer(&lp->media);
 719
 720         dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
 721                   dev->name, inw(dev->base_addr + EL3_STATUS));
 722
 723         return 0;
 724 }
 725
 726 static void el3_tx_timeout(struct net_device *dev)
 727 {
 728         unsigned int ioaddr = dev->base_addr;
 729
 730         printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
 731         dump_status(dev);
 732         dev->stats.tx_errors++;
 733         dev->trans_start = jiffies;
 734         /* Issue TX_RESET and TX_START commands. */
 735         tc574_wait_for_completion(dev, TxReset);
 736         outw(TxEnable, ioaddr + EL3_CMD);
 737         netif_wake_queue(dev);
 738 }
 739
 740 static void pop_tx_status(struct net_device *dev)
 741 {
 742         unsigned int ioaddr = dev->base_addr;
 743         int i;
 744
 745         /* Clear the Tx status stack. */
 746         for (i = 32; i > 0; i--) {
 747                 u_char tx_status = inb(ioaddr + TxStatus);
 748                 if (!(tx_status & 0x84))
 749                         break;
 750                 /* reset transmitter on jabber error or underrun */
 751                 if (tx_status & 0x30)
 752                         tc574_wait_for_completion(dev, TxReset);
 753                 if (tx_status & 0x38) {
 754                         pr_debug("%s: transmit error: status 0x%02x\n",
 755                                   dev->name, tx_status);
 756                         outw(TxEnable, ioaddr + EL3_CMD);
 757                         dev->stats.tx_aborted_errors++;
 758                 }
 759                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
 760         }
 761 }
 762
 763 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 764                                         struct net_device *dev)
 765 {
 766         unsigned int ioaddr = dev->base_addr;
 767         struct el3_private *lp = netdev_priv(dev);
 768         unsigned long flags;
 769
 770         pr_debug("%s: el3_start_xmit(length = %ld) called, "
 771                   "status %4.4x.\n", dev->name, (long)skb->len,
 772                   inw(ioaddr + EL3_STATUS));
 773
 774         spin_lock_irqsave(&lp->window_lock, flags);
 775
 776         dev->stats.tx_bytes += skb->len;
 777
 778         /* Put out the doubleword header... */
 779         outw(skb->len, ioaddr + TX_FIFO);
 780         outw(0, ioaddr + TX_FIFO);
 781         /* ... and the packet rounded to a doubleword. */
 782         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
 783
 784         dev->trans_start = jiffies;
 785
 786         /* TxFree appears only in Window 1, not offset 0x1c. */
 787         if (inw(ioaddr + TxFree) <= 1536) {
 788                 netif_stop_queue(dev);
 789                 /* Interrupt us when the FIFO has room for max-sized packet.
 790                    The threshold is in units of dwords. */
 791                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
 792         }
 793
 794         pop_tx_status(dev);
 795         spin_unlock_irqrestore(&lp->window_lock, flags);
 796         dev_kfree_skb(skb);
 797         return NETDEV_TX_OK;
 798 }
 799
 800 /* The EL3 interrupt handler. */
 801 static irqreturn_t el3_interrupt(int irq, void *dev_id)
 802 {
 803         struct net_device *dev = (struct net_device *) dev_id;
 804         struct el3_private *lp = netdev_priv(dev);
 805         unsigned int ioaddr;
 806         unsigned status;
 807         int work_budget = max_interrupt_work;
 808         int handled = 0;
 809
 810         if (!netif_device_present(dev))
 811                 return IRQ_NONE;
 812         ioaddr = dev->base_addr;
 813
 814         pr_debug("%s: interrupt, status %4.4x.\n",
 815                   dev->name, inw(ioaddr + EL3_STATUS));
 816
 817         spin_lock(&lp->window_lock);
 818
 819         while ((status = inw(ioaddr + EL3_STATUS)) &
 820                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
 821                 if (!netif_device_present(dev) ||
 822                         ((status & 0xe000) != 0x2000)) {
 823                         pr_debug("%s: Interrupt from dead card\n", dev->name);
 824                         break;
 825                 }
 826
 827                 handled = 1;
 828
 829                 if (status & RxComplete)
 830                         work_budget = el3_rx(dev, work_budget);
 831
 832                 if (status & TxAvailable) {
 833                         pr_debug("  TX room bit was handled.\n");
 834                         /* There's room in the FIFO for a full-sized packet. */
 835                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 836                         netif_wake_queue(dev);
 837                 }
 838
 839                 if (status & TxComplete)
 840                         pop_tx_status(dev);
 841
 842                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
 843                         /* Handle all uncommon interrupts. */
 844                         if (status & StatsFull)
 845                                 update_stats(dev);
 846                         if (status & RxEarly) {
 847                                 work_budget = el3_rx(dev, work_budget);
 848                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 849                         }
 850                         if (status & AdapterFailure) {
 851                                 u16 fifo_diag;
 852                                 EL3WINDOW(4);
 853                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
 854                                 EL3WINDOW(1);
 855                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
 856                                            " register %04x.\n", dev->name, fifo_diag);
 857                                 if (fifo_diag & 0x0400) {
 858                                         /* Tx overrun */
 859                                         tc574_wait_for_completion(dev, TxReset);
 860                                         outw(TxEnable, ioaddr + EL3_CMD);
 861                                 }
 862                                 if (fifo_diag & 0x2000) {
 863                                         /* Rx underrun */
 864                                         tc574_wait_for_completion(dev, RxReset);
 865                                         set_rx_mode(dev);
 866                                         outw(RxEnable, ioaddr + EL3_CMD);
 867                                 }
 868                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 869                         }
 870                 }
 871
 872                 if (--work_budget < 0) {
 873                         pr_debug("%s: Too much work in interrupt, "
 874                                   "status %4.4x.\n", dev->name, status);
 875                         /* Clear all interrupts */
 876                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 877                         break;
 878                 }
 879                 /* Acknowledge the IRQ. */
 880                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 881         }
 882
 883         pr_debug("%s: exiting interrupt, status %4.4x.\n",
 884                   dev->name, inw(ioaddr + EL3_STATUS));
 885
 886         spin_unlock(&lp->window_lock);
 887         return IRQ_RETVAL(handled);
 888 }
 889
 890 /*
 891     This timer serves two purposes: to check for missed interrupts
 892         (and as a last resort, poll the NIC for events), and to monitor
 893         the MII, reporting changes in cable status.
 894 */
 895 static void media_check(unsigned long arg)
 896 {
 897         struct net_device *dev = (struct net_device *) arg;
 898         struct el3_private *lp = netdev_priv(dev);
 899         unsigned int ioaddr = dev->base_addr;
 900         unsigned long flags;
 901         unsigned short /* cable, */ media, partner;
 902
 903         if (!netif_device_present(dev))
 904                 goto reschedule;
 905
 906         /* Check for pending interrupt with expired latency timer: with
 907            this, we can limp along even if the interrupt is blocked */
 908         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
 909                 if (!lp->fast_poll)
 910                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
 911
 912                 local_irq_save(flags);
 913                 el3_interrupt(dev->irq, dev);
 914                 local_irq_restore(flags);
 915
 916                 lp->fast_poll = HZ;
 917         }
 918         if (lp->fast_poll) {
 919                 lp->fast_poll--;
 920                 lp->media.expires = jiffies + 2*HZ/100;
 921                 add_timer(&lp->media);
 922                 return;
 923         }
 924
 925         spin_lock_irqsave(&lp->window_lock, flags);
 926         EL3WINDOW(4);
 927         media = mdio_read(ioaddr, lp->phys, 1);
 928         partner = mdio_read(ioaddr, lp->phys, 5);
 929         EL3WINDOW(1);
 930
 931         if (media != lp->media_status) {
 932                 if ((media ^ lp->media_status) & 0x0004)
 933                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
 934                                    (lp->media_status & 0x0004) ? "lost" : "found");
 935                 if ((media ^ lp->media_status) & 0x0020) {
 936                         lp->partner = 0;
 937                         if (lp->media_status & 0x0020) {
 938                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
 939                                            dev->name);
 940                         } else if (partner) {
 941                                 partner &= lp->advertising;
 942                                 lp->partner = partner;
 943                                 printk(KERN_INFO "%s: autonegotiation complete: "
 944                                            "%sbaseT-%cD selected\n", dev->name,
 945                                            ((partner & 0x0180) ? "100" : "10"),
 946                                            ((partner & 0x0140) ? 'F' : 'H'));
 947                         } else {
 948                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
 949                                            dev->name);
 950                         }
 951
 952                         EL3WINDOW(3);
 953                         outb((partner & 0x0140 ? 0x20 : 0) |
 954                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 955                         EL3WINDOW(1);
 956
 957                 }
 958                 if (media & 0x0010)
 959                         printk(KERN_INFO "%s: remote fault detected\n",
 960                                    dev->name);
 961                 if (media & 0x0002)
 962                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
 963                 lp->media_status = media;
 964         }
 965         spin_unlock_irqrestore(&lp->window_lock, flags);
 966
 967 reschedule:
 968         lp->media.expires = jiffies + HZ;
 969         add_timer(&lp->media);
 970 }
 971
 972 static struct net_device_stats *el3_get_stats(struct net_device *dev)
 973 {
 974         struct el3_private *lp = netdev_priv(dev);
 975
 976         if (netif_device_present(dev)) {
 977                 unsigned long flags;
 978                 spin_lock_irqsave(&lp->window_lock, flags);
 979                 update_stats(dev);
 980                 spin_unlock_irqrestore(&lp->window_lock, flags);
 981         }
 982         return &dev->stats;
 983 }
 984
 985 /*  Update statistics.
 986         Suprisingly this need not be run single-threaded, but it effectively is.
 987         The counters clear when read, so the adds must merely be atomic.
 988  */
 989 static void update_stats(struct net_device *dev)
 990 {
 991         unsigned int ioaddr = dev->base_addr;
 992         u8 rx, tx, up;
 993
 994         pr_debug("%s: updating the statistics.\n", dev->name);
 995
 996         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
 997                 return;
 998
 999         /* Unlike the 3c509 we need not turn off stats updates while reading. */
1000         /* Switch to the stats window, and read everything. */
1001         EL3WINDOW(6);
1002         dev->stats.tx_carrier_errors            += inb(ioaddr + 0);
1003         dev->stats.tx_heartbeat_errors          += inb(ioaddr + 1);
1004         /* Multiple collisions. */              inb(ioaddr + 2);
1005         dev->stats.collisions                   += inb(ioaddr + 3);
1006         dev->stats.tx_window_errors             += inb(ioaddr + 4);
1007         dev->stats.rx_fifo_errors               += inb(ioaddr + 5);
1008         dev->stats.tx_packets                   += inb(ioaddr + 6);
1009         up                                       = inb(ioaddr + 9);
1010         dev->stats.tx_packets                   += (up&0x30) << 4;
1011         /* Rx packets   */                         inb(ioaddr + 7);
1012         /* Tx deferrals */                         inb(ioaddr + 8);
1013         rx                                       = inw(ioaddr + 10);
1014         tx                                       = inw(ioaddr + 12);
1015
1016         EL3WINDOW(4);
1017         /* BadSSD */                               inb(ioaddr + 12);
1018         up                                       = inb(ioaddr + 13);
1019
1020         EL3WINDOW(1);
1021 }
1022
1023 static int el3_rx(struct net_device *dev, int worklimit)
1024 {
1025         unsigned int ioaddr = dev->base_addr;
1026         short rx_status;
1027
1028         pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1029                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1030         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1031                         worklimit > 0) {
1032                 worklimit--;
1033                 if (rx_status & 0x4000) { /* Error, update stats. */
1034                         short error = rx_status & 0x3800;
1035                         dev->stats.rx_errors++;
1036                         switch (error) {
1037                         case 0x0000:    dev->stats.rx_over_errors++; break;
1038                         case 0x0800:    dev->stats.rx_length_errors++; break;
1039                         case 0x1000:    dev->stats.rx_frame_errors++; break;
1040                         case 0x1800:    dev->stats.rx_length_errors++; break;
1041                         case 0x2000:    dev->stats.rx_frame_errors++; break;
1042                         case 0x2800:    dev->stats.rx_crc_errors++; break;
1043                         }
1044                 } else {
1045                         short pkt_len = rx_status & 0x7ff;
1046                         struct sk_buff *skb;
1047
1048                         skb = dev_alloc_skb(pkt_len+5);
1049
1050                         pr_debug("  Receiving packet size %d status %4.4x.\n",
1051                                   pkt_len, rx_status);
1052                         if (skb != NULL) {
1053                                 skb_reserve(skb, 2);
1054                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1055                                                 ((pkt_len+3)>>2));
1056                                 skb->protocol = eth_type_trans(skb, dev);
1057                                 netif_rx(skb);
1058                                 dev->stats.rx_packets++;
1059                                 dev->stats.rx_bytes += pkt_len;
1060                         } else {
1061                                 pr_debug("%s: couldn't allocate a sk_buff of"
1062                                           " size %d.\n", dev->name, pkt_len);
1063                                 dev->stats.rx_dropped++;
1064                         }
1065                 }
1066                 tc574_wait_for_completion(dev, RxDiscard);
1067         }
1068
1069         return worklimit;
1070 }
1071
1072 static void netdev_get_drvinfo(struct net_device *dev,
1073                                struct ethtool_drvinfo *info)
1074 {
1075         strcpy(info->driver, "3c574_cs");
1076 }
1077
1078 static const struct ethtool_ops netdev_ethtool_ops = {
1079         .get_drvinfo            = netdev_get_drvinfo,
1080 };
1081
1082 /* Provide ioctl() calls to examine the MII xcvr state. */
1083 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1084 {
1085         struct el3_private *lp = netdev_priv(dev);
1086         unsigned int ioaddr = dev->base_addr;
1087         struct mii_ioctl_data *data = if_mii(rq);
1088         int phy = lp->phys & 0x1f;
1089
1090         pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1091                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1092                   data->phy_id, data->reg_num, data->val_in, data->val_out);
1093
1094         switch(cmd) {
1095         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1096                 data->phy_id = phy;
1097         case SIOCGMIIREG:               /* Read the specified MII register. */
1098                 {
1099                         int saved_window;
1100                         unsigned long flags;
1101
1102                         spin_lock_irqsave(&lp->window_lock, flags);
1103                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1104                         EL3WINDOW(4);
1105                         data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1106                                                   data->reg_num & 0x1f);
1107                         EL3WINDOW(saved_window);
1108                         spin_unlock_irqrestore(&lp->window_lock, flags);
1109                         return 0;
1110                 }
1111         case SIOCSMIIREG:               /* Write the specified MII register */
1112                 {
1113                         int saved_window;
1114                        unsigned long flags;
1115
1116                         spin_lock_irqsave(&lp->window_lock, flags);
1117                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1118                         EL3WINDOW(4);
1119                         mdio_write(ioaddr, data->phy_id & 0x1f,
1120                                    data->reg_num & 0x1f, data->val_in);
1121                         EL3WINDOW(saved_window);
1122                         spin_unlock_irqrestore(&lp->window_lock, flags);
1123                         return 0;
1124                 }
1125         default:
1126                 return -EOPNOTSUPP;
1127         }
1128 }
1129
1130 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1131    documented.  Until it is we revert to receiving all multicast frames when
1132    any multicast reception is desired.
1133    Note: My other drivers emit a log message whenever promiscuous mode is
1134    entered to help detect password sniffers.  This is less desirable on
1135    typical PC card machines, so we omit the message.
1136    */
1137
1138 static void set_rx_mode(struct net_device *dev)
1139 {
1140         unsigned int ioaddr = dev->base_addr;
1141
1142         if (dev->flags & IFF_PROMISC)
1143                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1144                          ioaddr + EL3_CMD);
1145         else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1146                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1147         else
1148                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1149 }
1150
1151 static void set_multicast_list(struct net_device *dev)
1152 {
1153         struct el3_private *lp = netdev_priv(dev);
1154         unsigned long flags;
1155
1156         spin_lock_irqsave(&lp->window_lock, flags);
1157         set_rx_mode(dev);
1158         spin_unlock_irqrestore(&lp->window_lock, flags);
1159 }
1160
1161 static int el3_close(struct net_device *dev)
1162 {
1163         unsigned int ioaddr = dev->base_addr;
1164         struct el3_private *lp = netdev_priv(dev);
1165         struct pcmcia_device *link = lp->p_dev;
1166
1167         dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1168
1169         if (pcmcia_dev_present(link)) {
1170                 unsigned long flags;
1171
1172                 /* Turn off statistics ASAP.  We update lp->stats below. */
1173                 outw(StatsDisable, ioaddr + EL3_CMD);
1174
1175                 /* Disable the receiver and transmitter. */
1176                 outw(RxDisable, ioaddr + EL3_CMD);
1177                 outw(TxDisable, ioaddr + EL3_CMD);
1178
1179                 /* Note: Switching to window 0 may disable the IRQ. */
1180                 EL3WINDOW(0);
1181                 spin_lock_irqsave(&lp->window_lock, flags);
1182                 update_stats(dev);
1183                 spin_unlock_irqrestore(&lp->window_lock, flags);
1184
1185                 /* force interrupts off */
1186                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1187         }
1188
1189         link->open--;
1190         netif_stop_queue(dev);
1191         del_timer_sync(&lp->media);
1192
1193         return 0;
1194 }
1195
1196 static struct pcmcia_device_id tc574_ids[] = {
1197         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1198         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1199         PCMCIA_DEVICE_NULL,
1200 };
1201 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1202
1203 static struct pcmcia_driver tc574_driver = {
1204         .owner          = THIS_MODULE,
1205         .drv            = {
1206                 .name   = "3c574_cs",
1207         },
1208         .probe          = tc574_probe,
1209         .remove         = tc574_detach,
1210         .id_table       = tc574_ids,
1211         .suspend        = tc574_suspend,
1212         .resume         = tc574_resume,
1213 };
1214
1215 static int __init init_tc574(void)
1216 {
1217         return pcmcia_register_driver(&tc574_driver);
1218 }
1219
1220 static void __exit exit_tc574(void)
1221 {
1222         pcmcia_unregister_driver(&tc574_driver);
1223 }
1224
1225 module_init(init_tc574);
1226 module_exit(exit_tc574);