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;
 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         dev->trans_start = jiffies;
 794
 795         /* TxFree appears only in Window 1, not offset 0x1c. */
 796         if (inw(ioaddr + TxFree) <= 1536) {
 797                 netif_stop_queue(dev);
 798                 /* Interrupt us when the FIFO has room for max-sized packet.
 799                    The threshold is in units of dwords. */
 800                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
 801         }
 802
 803         pop_tx_status(dev);
 804         spin_unlock_irqrestore(&lp->window_lock, flags);
 805         dev_kfree_skb(skb);
 806         return NETDEV_TX_OK;
 807 }
 808
 809 /* The EL3 interrupt handler. */
 810 static irqreturn_t el3_interrupt(int irq, void *dev_id)
 811 {
 812         struct net_device *dev = (struct net_device *) dev_id;
 813         struct el3_private *lp = netdev_priv(dev);
 814         unsigned int ioaddr;
 815         unsigned status;
 816         int work_budget = max_interrupt_work;
 817         int handled = 0;
 818
 819         if (!netif_device_present(dev))
 820                 return IRQ_NONE;
 821         ioaddr = dev->base_addr;
 822
 823         pr_debug("%s: interrupt, status %4.4x.\n",
 824                   dev->name, inw(ioaddr + EL3_STATUS));
 825
 826         spin_lock(&lp->window_lock);
 827
 828         while ((status = inw(ioaddr + EL3_STATUS)) &
 829                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
 830                 if (!netif_device_present(dev) ||
 831                         ((status & 0xe000) != 0x2000)) {
 832                         pr_debug("%s: Interrupt from dead card\n", dev->name);
 833                         break;
 834                 }
 835
 836                 handled = 1;
 837
 838                 if (status & RxComplete)
 839                         work_budget = el3_rx(dev, work_budget);
 840
 841                 if (status & TxAvailable) {
 842                         pr_debug("  TX room bit was handled.\n");
 843                         /* There's room in the FIFO for a full-sized packet. */
 844                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 845                         netif_wake_queue(dev);
 846                 }
 847
 848                 if (status & TxComplete)
 849                         pop_tx_status(dev);
 850
 851                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
 852                         /* Handle all uncommon interrupts. */
 853                         if (status & StatsFull)
 854                                 update_stats(dev);
 855                         if (status & RxEarly) {
 856                                 work_budget = el3_rx(dev, work_budget);
 857                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 858                         }
 859                         if (status & AdapterFailure) {
 860                                 u16 fifo_diag;
 861                                 EL3WINDOW(4);
 862                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
 863                                 EL3WINDOW(1);
 864                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
 865                                            " register %04x.\n", dev->name, fifo_diag);
 866                                 if (fifo_diag & 0x0400) {
 867                                         /* Tx overrun */
 868                                         tc574_wait_for_completion(dev, TxReset);
 869                                         outw(TxEnable, ioaddr + EL3_CMD);
 870                                 }
 871                                 if (fifo_diag & 0x2000) {
 872                                         /* Rx underrun */
 873                                         tc574_wait_for_completion(dev, RxReset);
 874                                         set_rx_mode(dev);
 875                                         outw(RxEnable, ioaddr + EL3_CMD);
 876                                 }
 877                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 878                         }
 879                 }
 880
 881                 if (--work_budget < 0) {
 882                         pr_debug("%s: Too much work in interrupt, "
 883                                   "status %4.4x.\n", dev->name, status);
 884                         /* Clear all interrupts */
 885                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 886                         break;
 887                 }
 888                 /* Acknowledge the IRQ. */
 889                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 890         }
 891
 892         pr_debug("%s: exiting interrupt, status %4.4x.\n",
 893                   dev->name, inw(ioaddr + EL3_STATUS));
 894
 895         spin_unlock(&lp->window_lock);
 896         return IRQ_RETVAL(handled);
 897 }
 898
 899 /*
 900     This timer serves two purposes: to check for missed interrupts
 901         (and as a last resort, poll the NIC for events), and to monitor
 902         the MII, reporting changes in cable status.
 903 */
 904 static void media_check(unsigned long arg)
 905 {
 906         struct net_device *dev = (struct net_device *) arg;
 907         struct el3_private *lp = netdev_priv(dev);
 908         unsigned int ioaddr = dev->base_addr;
 909         unsigned long flags;
 910         unsigned short /* cable, */ media, partner;
 911
 912         if (!netif_device_present(dev))
 913                 goto reschedule;
 914
 915         /* Check for pending interrupt with expired latency timer: with
 916            this, we can limp along even if the interrupt is blocked */
 917         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
 918                 if (!lp->fast_poll)
 919                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
 920
 921                 local_irq_save(flags);
 922                 el3_interrupt(dev->irq, dev);
 923                 local_irq_restore(flags);
 924
 925                 lp->fast_poll = HZ;
 926         }
 927         if (lp->fast_poll) {
 928                 lp->fast_poll--;
 929                 lp->media.expires = jiffies + 2*HZ/100;
 930                 add_timer(&lp->media);
 931                 return;
 932         }
 933
 934         spin_lock_irqsave(&lp->window_lock, flags);
 935         EL3WINDOW(4);
 936         media = mdio_read(ioaddr, lp->phys, 1);
 937         partner = mdio_read(ioaddr, lp->phys, 5);
 938         EL3WINDOW(1);
 939
 940         if (media != lp->media_status) {
 941                 if ((media ^ lp->media_status) & 0x0004)
 942                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
 943                                    (lp->media_status & 0x0004) ? "lost" : "found");
 944                 if ((media ^ lp->media_status) & 0x0020) {
 945                         lp->partner = 0;
 946                         if (lp->media_status & 0x0020) {
 947                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
 948                                            dev->name);
 949                         } else if (partner) {
 950                                 partner &= lp->advertising;
 951                                 lp->partner = partner;
 952                                 printk(KERN_INFO "%s: autonegotiation complete: "
 953                                            "%sbaseT-%cD selected\n", dev->name,
 954                                            ((partner & 0x0180) ? "100" : "10"),
 955                                            ((partner & 0x0140) ? 'F' : 'H'));
 956                         } else {
 957                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
 958                                            dev->name);
 959                         }
 960
 961                         EL3WINDOW(3);
 962                         outb((partner & 0x0140 ? 0x20 : 0) |
 963                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 964                         EL3WINDOW(1);
 965
 966                 }
 967                 if (media & 0x0010)
 968                         printk(KERN_INFO "%s: remote fault detected\n",
 969                                    dev->name);
 970                 if (media & 0x0002)
 971                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
 972                 lp->media_status = media;
 973         }
 974         spin_unlock_irqrestore(&lp->window_lock, flags);
 975
 976 reschedule:
 977         lp->media.expires = jiffies + HZ;
 978         add_timer(&lp->media);
 979 }
 980
 981 static struct net_device_stats *el3_get_stats(struct net_device *dev)
 982 {
 983         struct el3_private *lp = netdev_priv(dev);
 984
 985         if (netif_device_present(dev)) {
 986                 unsigned long flags;
 987                 spin_lock_irqsave(&lp->window_lock, flags);
 988                 update_stats(dev);
 989                 spin_unlock_irqrestore(&lp->window_lock, flags);
 990         }
 991         return &dev->stats;
 992 }
 993
 994 /*  Update statistics.
 995         Suprisingly this need not be run single-threaded, but it effectively is.
 996         The counters clear when read, so the adds must merely be atomic.
 997  */
 998 static void update_stats(struct net_device *dev)
 999 {
1000         unsigned int ioaddr = dev->base_addr;
1001         u8 rx, tx, up;
1002
1003         pr_debug("%s: updating the statistics.\n", dev->name);
1004
1005         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1006                 return;
1007
1008         /* Unlike the 3c509 we need not turn off stats updates while reading. */
1009         /* Switch to the stats window, and read everything. */
1010         EL3WINDOW(6);
1011         dev->stats.tx_carrier_errors            += inb(ioaddr + 0);
1012         dev->stats.tx_heartbeat_errors          += inb(ioaddr + 1);
1013         /* Multiple collisions. */              inb(ioaddr + 2);
1014         dev->stats.collisions                   += inb(ioaddr + 3);
1015         dev->stats.tx_window_errors             += inb(ioaddr + 4);
1016         dev->stats.rx_fifo_errors               += inb(ioaddr + 5);
1017         dev->stats.tx_packets                   += inb(ioaddr + 6);
1018         up                                       = inb(ioaddr + 9);
1019         dev->stats.tx_packets                   += (up&0x30) << 4;
1020         /* Rx packets   */                         inb(ioaddr + 7);
1021         /* Tx deferrals */                         inb(ioaddr + 8);
1022         rx                                       = inw(ioaddr + 10);
1023         tx                                       = inw(ioaddr + 12);
1024
1025         EL3WINDOW(4);
1026         /* BadSSD */                               inb(ioaddr + 12);
1027         up                                       = inb(ioaddr + 13);
1028
1029         EL3WINDOW(1);
1030 }
1031
1032 static int el3_rx(struct net_device *dev, int worklimit)
1033 {
1034         unsigned int ioaddr = dev->base_addr;
1035         short rx_status;
1036
1037         pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1038                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1039         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1040                         worklimit > 0) {
1041                 worklimit--;
1042                 if (rx_status & 0x4000) { /* Error, update stats. */
1043                         short error = rx_status & 0x3800;
1044                         dev->stats.rx_errors++;
1045                         switch (error) {
1046                         case 0x0000:    dev->stats.rx_over_errors++; break;
1047                         case 0x0800:    dev->stats.rx_length_errors++; break;
1048                         case 0x1000:    dev->stats.rx_frame_errors++; break;
1049                         case 0x1800:    dev->stats.rx_length_errors++; break;
1050                         case 0x2000:    dev->stats.rx_frame_errors++; break;
1051                         case 0x2800:    dev->stats.rx_crc_errors++; break;
1052                         }
1053                 } else {
1054                         short pkt_len = rx_status & 0x7ff;
1055                         struct sk_buff *skb;
1056
1057                         skb = dev_alloc_skb(pkt_len+5);
1058
1059                         pr_debug("  Receiving packet size %d status %4.4x.\n",
1060                                   pkt_len, rx_status);
1061                         if (skb != NULL) {
1062                                 skb_reserve(skb, 2);
1063                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1064                                                 ((pkt_len+3)>>2));
1065                                 skb->protocol = eth_type_trans(skb, dev);
1066                                 netif_rx(skb);
1067                                 dev->stats.rx_packets++;
1068                                 dev->stats.rx_bytes += pkt_len;
1069                         } else {
1070                                 pr_debug("%s: couldn't allocate a sk_buff of"
1071                                           " size %d.\n", dev->name, pkt_len);
1072                                 dev->stats.rx_dropped++;
1073                         }
1074                 }
1075                 tc574_wait_for_completion(dev, RxDiscard);
1076         }
1077
1078         return worklimit;
1079 }
1080
1081 static void netdev_get_drvinfo(struct net_device *dev,
1082                                struct ethtool_drvinfo *info)
1083 {
1084         strcpy(info->driver, "3c574_cs");
1085 }
1086
1087 static const struct ethtool_ops netdev_ethtool_ops = {
1088         .get_drvinfo            = netdev_get_drvinfo,
1089 };
1090
1091 /* Provide ioctl() calls to examine the MII xcvr state. */
1092 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1093 {
1094         struct el3_private *lp = netdev_priv(dev);
1095         unsigned int ioaddr = dev->base_addr;
1096         struct mii_ioctl_data *data = if_mii(rq);
1097         int phy = lp->phys & 0x1f;
1098
1099         pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1100                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1101                   data->phy_id, data->reg_num, data->val_in, data->val_out);
1102
1103         switch(cmd) {
1104         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1105                 data->phy_id = phy;
1106         case SIOCGMIIREG:               /* Read the specified MII register. */
1107                 {
1108                         int saved_window;
1109                         unsigned long flags;
1110
1111                         spin_lock_irqsave(&lp->window_lock, flags);
1112                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1113                         EL3WINDOW(4);
1114                         data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1115                                                   data->reg_num & 0x1f);
1116                         EL3WINDOW(saved_window);
1117                         spin_unlock_irqrestore(&lp->window_lock, flags);
1118                         return 0;
1119                 }
1120         case SIOCSMIIREG:               /* Write the specified MII register */
1121                 {
1122                         int saved_window;
1123                        unsigned long flags;
1124
1125                         spin_lock_irqsave(&lp->window_lock, flags);
1126                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1127                         EL3WINDOW(4);
1128                         mdio_write(ioaddr, data->phy_id & 0x1f,
1129                                    data->reg_num & 0x1f, data->val_in);
1130                         EL3WINDOW(saved_window);
1131                         spin_unlock_irqrestore(&lp->window_lock, flags);
1132                         return 0;
1133                 }
1134         default:
1135                 return -EOPNOTSUPP;
1136         }
1137 }
1138
1139 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1140    documented.  Until it is we revert to receiving all multicast frames when
1141    any multicast reception is desired.
1142    Note: My other drivers emit a log message whenever promiscuous mode is
1143    entered to help detect password sniffers.  This is less desirable on
1144    typical PC card machines, so we omit the message.
1145    */
1146
1147 static void set_rx_mode(struct net_device *dev)
1148 {
1149         unsigned int ioaddr = dev->base_addr;
1150
1151         if (dev->flags & IFF_PROMISC)
1152                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1153                          ioaddr + EL3_CMD);
1154         else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1155                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1156         else
1157                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1158 }
1159
1160 static void set_multicast_list(struct net_device *dev)
1161 {
1162         struct el3_private *lp = netdev_priv(dev);
1163         unsigned long flags;
1164
1165         spin_lock_irqsave(&lp->window_lock, flags);
1166         set_rx_mode(dev);
1167         spin_unlock_irqrestore(&lp->window_lock, flags);
1168 }
1169
1170 static int el3_close(struct net_device *dev)
1171 {
1172         unsigned int ioaddr = dev->base_addr;
1173         struct el3_private *lp = netdev_priv(dev);
1174         struct pcmcia_device *link = lp->p_dev;
1175
1176         dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1177
1178         if (pcmcia_dev_present(link)) {
1179                 unsigned long flags;
1180
1181                 /* Turn off statistics ASAP.  We update lp->stats below. */
1182                 outw(StatsDisable, ioaddr + EL3_CMD);
1183
1184                 /* Disable the receiver and transmitter. */
1185                 outw(RxDisable, ioaddr + EL3_CMD);
1186                 outw(TxDisable, ioaddr + EL3_CMD);
1187
1188                 /* Note: Switching to window 0 may disable the IRQ. */
1189                 EL3WINDOW(0);
1190                 spin_lock_irqsave(&lp->window_lock, flags);
1191                 update_stats(dev);
1192                 spin_unlock_irqrestore(&lp->window_lock, flags);
1193
1194                 /* force interrupts off */
1195                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1196         }
1197
1198         link->open--;
1199         netif_stop_queue(dev);
1200         del_timer_sync(&lp->media);
1201
1202         return 0;
1203 }
1204
1205 static struct pcmcia_device_id tc574_ids[] = {
1206         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1207         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1208         PCMCIA_DEVICE_NULL,
1209 };
1210 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1211
1212 static struct pcmcia_driver tc574_driver = {
1213         .owner          = THIS_MODULE,
1214         .drv            = {
1215                 .name   = "3c574_cs",
1216         },
1217         .probe          = tc574_probe,
1218         .remove         = tc574_detach,
1219         .id_table       = tc574_ids,
1220         .suspend        = tc574_suspend,
1221         .resume         = tc574_resume,
1222 };
1223
1224 static int __init init_tc574(void)
1225 {
1226         return pcmcia_register_driver(&tc574_driver);
1227 }
1228
1229 static void __exit exit_tc574(void)
1230 {
1231         pcmcia_unregister_driver(&tc574_driver);
1232 }
1233
1234 module_init(init_tc574);
1235 module_exit(exit_tc574);