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