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