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