drivers/net/pcmcia/3c574_cs.c

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