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