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