drivers/net/pcmcia/3c574_cs.c

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