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