git.oblomov.eu Git - linux-2.6/blob - drivers/net/pcmcia/3c574_cs.c

   1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
   2
   3         Written 1993-1998 by
   4         Donald Becker, becker@scyld.com, (driver core) and
   5         David Hinds, dahinds@users.sourceforge.net (from his PC card code).
   6         Locking fixes (C) Copyright 2003 Red Hat Inc
   7
   8         This software may be used and distributed according to the terms of
   9         the GNU General Public License, incorporated herein by reference.
  10
  11         This driver derives from Donald Becker's 3c509 core, which has the
  12         following copyright:
  13         Copyright 1993 United States Government as represented by the
  14         Director, National Security Agency.
  15
  16
  17 */
  18
  19 /*
  20                                 Theory of Operation
  21
  22 I. Board Compatibility
  23
  24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
  25 Adapter.
  26
  27 II. Board-specific settings
  28
  29 None -- PC cards are autoconfigured.
  30
  31 III. Driver operation
  32
  33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
  34 See the Boomerang driver and documentation for most details.
  35
  36 IV. Notes and chip documentation.
  37
  38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
  39 RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
  40 count of word (16 bits) reads or writes the driver is about to do to the Rx
  41 or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
  42 translation latency by buffering the I/O operations with an 8 word FIFO.
  43 Note: No other chip accesses are permitted when this buffer is used.
  44
  45 A second enhancement is that both attribute and common memory space
  46 0x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
  47 with *some* PCcard bridges) may be used instead of I/O operations.
  48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
  49
  50 Some slow PC card bridges work better if they never see a WAIT signal.
  51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
  52 Only do this after testing that it is reliable and improves performance.
  53
  54 The upper five bits of RunnerRdCtrl are used to window into PCcard
  55 configuration space registers.  Window 0 is the regular Boomerang/Odie
  56 register set, 1-5 are various PC card control registers, and 16-31 are
  57 the (reversed!) CIS table.
  58
  59 A final note: writing the InternalConfig register in window 3 with an
  60 invalid ramWidth is Very Bad.
  61
  62 V. References
  63
  64 http://www.scyld.com/expert/NWay.html
  65 http://www.national.com/pf/DP/DP83840.html
  66
  67 Thanks to Terry Murphy of 3Com for providing development information for
  68 earlier 3Com products.
  69
  70 */
  71
  72 #include <linux/module.h>
  73 #include <linux/kernel.h>
  74 #include <linux/init.h>
  75 #include <linux/slab.h>
  76 #include <linux/string.h>
  77 #include <linux/timer.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/in.h>
  80 #include <linux/delay.h>
  81 #include <linux/netdevice.h>
  82 #include <linux/etherdevice.h>
  83 #include <linux/skbuff.h>
  84 #include <linux/if_arp.h>
  85 #include <linux/ioport.h>
  86 #include <linux/ethtool.h>
  87 #include <linux/bitops.h>
  88
  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         struct net_device_stats stats;
 212         u16 advertising, partner;               /* NWay media advertisement */
 213         unsigned char phys;                     /* MII device address */
 214         unsigned int autoselect:1, default_media:3;     /* Read from the EEPROM/Wn3_Config. */
 215         /* for transceiver monitoring */
 216         struct timer_list media;
 217         unsigned short media_status;
 218         unsigned short fast_poll;
 219         unsigned long last_irq;
 220         spinlock_t window_lock;                 /* Guards the Window selection */
 221 };
 222
 223 /* Set iff a MII transceiver on any interface requires mdio preamble.
 224    This only set with the original DP83840 on older 3c905 boards, so the extra
 225    code size of a per-interface flag is not worthwhile. */
 226 static char mii_preamble_required = 0;
 227
 228 /* Index of functions. */
 229
 230 static int tc574_config(struct pcmcia_device *link);
 231 static void tc574_release(struct pcmcia_device *link);
 232
 233 static void mdio_sync(unsigned int ioaddr, int bits);
 234 static int mdio_read(unsigned int ioaddr, int phy_id, int location);
 235 static void mdio_write(unsigned int ioaddr, int phy_id, int location,
 236                        int value);
 237 static unsigned short read_eeprom(unsigned int ioaddr, int index);
 238 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
 239
 240 static void tc574_reset(struct net_device *dev);
 241 static void media_check(unsigned long arg);
 242 static int el3_open(struct net_device *dev);
 243 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 244 static irqreturn_t el3_interrupt(int irq, void *dev_id);
 245 static void update_stats(struct net_device *dev);
 246 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 247 static int el3_rx(struct net_device *dev, int worklimit);
 248 static int el3_close(struct net_device *dev);
 249 static void el3_tx_timeout(struct net_device *dev);
 250 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 251 static const struct ethtool_ops netdev_ethtool_ops;
 252 static void set_rx_mode(struct net_device *dev);
 253
 254 static void tc574_detach(struct pcmcia_device *p_dev);
 255
 256 /*
 257         tc574_attach() creates an "instance" of the driver, allocating
 258         local data structures for one device.  The device is registered
 259         with Card Services.
 260 */
 261
 262 static int tc574_probe(struct pcmcia_device *link)
 263 {
 264         struct el3_private *lp;
 265         struct net_device *dev;
 266
 267         DEBUG(0, "3c574_attach()\n");
 268
 269         /* Create the PC card device object. */
 270         dev = alloc_etherdev(sizeof(struct el3_private));
 271         if (!dev)
 272                 return -ENOMEM;
 273         lp = netdev_priv(dev);
 274         link->priv = dev;
 275         lp->p_dev = link;
 276
 277         spin_lock_init(&lp->window_lock);
 278         link->io.NumPorts1 = 32;
 279         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 280         link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
 281         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 282         link->irq.Handler = &el3_interrupt;
 283         link->irq.Instance = dev;
 284         link->conf.Attributes = CONF_ENABLE_IRQ;
 285         link->conf.IntType = INT_MEMORY_AND_IO;
 286         link->conf.ConfigIndex = 1;
 287
 288         /* The EL3-specific entries in the device structure. */
 289         dev->hard_start_xmit = &el3_start_xmit;
 290         dev->get_stats = &el3_get_stats;
 291         dev->do_ioctl = &el3_ioctl;
 292         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 293         dev->set_multicast_list = &set_rx_mode;
 294         dev->open = &el3_open;
 295         dev->stop = &el3_close;
 296 #ifdef HAVE_TX_TIMEOUT
 297         dev->tx_timeout = el3_tx_timeout;
 298         dev->watchdog_timeo = TX_TIMEOUT;
 299 #endif
 300
 301         return tc574_config(link);
 302 } /* tc574_attach */
 303
 304 /*
 305
 306         This deletes a driver "instance".  The device is de-registered
 307         with Card Services.  If it has been released, all local data
 308         structures are freed.  Otherwise, the structures will be freed
 309         when the device is released.
 310
 311 */
 312
 313 static void tc574_detach(struct pcmcia_device *link)
 314 {
 315         struct net_device *dev = link->priv;
 316
 317         DEBUG(0, "3c574_detach(0x%p)\n", link);
 318
 319         if (link->dev_node)
 320                 unregister_netdev(dev);
 321
 322         tc574_release(link);
 323
 324         free_netdev(dev);
 325 } /* tc574_detach */
 326
 327 /*
 328         tc574_config() is scheduled to run after a CARD_INSERTION event
 329         is received, to configure the PCMCIA socket, and to make the
 330         ethernet device available to the system.
 331 */
 332
 333 #define CS_CHECK(fn, ret) \
 334   do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 335
 336 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 337
 338 static int tc574_config(struct pcmcia_device *link)
 339 {
 340         struct net_device *dev = link->priv;
 341         struct el3_private *lp = netdev_priv(dev);
 342         tuple_t tuple;
 343         __le16 buf[32];
 344         int last_fn, last_ret, i, j;
 345         unsigned int ioaddr;
 346         __be16 *phys_addr;
 347         char *cardname;
 348         __u32 config;
 349         DECLARE_MAC_BUF(mac);
 350
 351         phys_addr = (__be16 *)dev->dev_addr;
 352
 353         DEBUG(0, "3c574_config(0x%p)\n", link);
 354
 355         link->io.IOAddrLines = 16;
 356         for (i = j = 0; j < 0x400; j += 0x20) {
 357                 link->io.BasePort1 = j ^ 0x300;
 358                 i = pcmcia_request_io(link, &link->io);
 359                 if (i == CS_SUCCESS) break;
 360         }
 361         if (i != CS_SUCCESS) {
 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) == CS_SUCCESS) {
 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         struct el3_private *lp = netdev_priv(dev);
 745         unsigned int ioaddr = dev->base_addr;
 746
 747         printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
 748         dump_status(dev);
 749         lp->stats.tx_errors++;
 750         dev->trans_start = jiffies;
 751         /* Issue TX_RESET and TX_START commands. */
 752         tc574_wait_for_completion(dev, TxReset);
 753         outw(TxEnable, ioaddr + EL3_CMD);
 754         netif_wake_queue(dev);
 755 }
 756
 757 static void pop_tx_status(struct net_device *dev)
 758 {
 759         struct el3_private *lp = netdev_priv(dev);
 760         unsigned int ioaddr = dev->base_addr;
 761         int i;
 762
 763         /* Clear the Tx status stack. */
 764         for (i = 32; i > 0; i--) {
 765                 u_char tx_status = inb(ioaddr + TxStatus);
 766                 if (!(tx_status & 0x84))
 767                         break;
 768                 /* reset transmitter on jabber error or underrun */
 769                 if (tx_status & 0x30)
 770                         tc574_wait_for_completion(dev, TxReset);
 771                 if (tx_status & 0x38) {
 772                         DEBUG(1, "%s: transmit error: status 0x%02x\n",
 773                                   dev->name, tx_status);
 774                         outw(TxEnable, ioaddr + EL3_CMD);
 775                         lp->stats.tx_aborted_errors++;
 776                 }
 777                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
 778         }
 779 }
 780
 781 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 782 {
 783         unsigned int ioaddr = dev->base_addr;
 784         struct el3_private *lp = netdev_priv(dev);
 785         unsigned long flags;
 786
 787         DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
 788                   "status %4.4x.\n", dev->name, (long)skb->len,
 789                   inw(ioaddr + EL3_STATUS));
 790
 791         spin_lock_irqsave(&lp->window_lock, flags);
 792         outw(skb->len, ioaddr + TX_FIFO);
 793         outw(0, ioaddr + TX_FIFO);
 794         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
 795
 796         dev->trans_start = jiffies;
 797
 798         /* TxFree appears only in Window 1, not offset 0x1c. */
 799         if (inw(ioaddr + TxFree) <= 1536) {
 800                 netif_stop_queue(dev);
 801                 /* Interrupt us when the FIFO has room for max-sized packet.
 802                    The threshold is in units of dwords. */
 803                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
 804         }
 805
 806         pop_tx_status(dev);
 807         spin_unlock_irqrestore(&lp->window_lock, flags);
 808         dev_kfree_skb(skb);
 809         return 0;
 810 }
 811
 812 /* The EL3 interrupt handler. */
 813 static irqreturn_t el3_interrupt(int irq, void *dev_id)
 814 {
 815         struct net_device *dev = (struct net_device *) dev_id;
 816         struct el3_private *lp = netdev_priv(dev);
 817         unsigned int ioaddr;
 818         unsigned status;
 819         int work_budget = max_interrupt_work;
 820         int handled = 0;
 821
 822         if (!netif_device_present(dev))
 823                 return IRQ_NONE;
 824         ioaddr = dev->base_addr;
 825
 826         DEBUG(3, "%s: interrupt, status %4.4x.\n",
 827                   dev->name, inw(ioaddr + EL3_STATUS));
 828
 829         spin_lock(&lp->window_lock);
 830
 831         while ((status = inw(ioaddr + EL3_STATUS)) &
 832                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
 833                 if (!netif_device_present(dev) ||
 834                         ((status & 0xe000) != 0x2000)) {
 835                         DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
 836                         break;
 837                 }
 838
 839                 handled = 1;
 840
 841                 if (status & RxComplete)
 842                         work_budget = el3_rx(dev, work_budget);
 843
 844                 if (status & TxAvailable) {
 845                         DEBUG(3, "  TX room bit was handled.\n");
 846                         /* There's room in the FIFO for a full-sized packet. */
 847                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 848                         netif_wake_queue(dev);
 849                 }
 850
 851                 if (status & TxComplete)
 852                         pop_tx_status(dev);
 853
 854                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
 855                         /* Handle all uncommon interrupts. */
 856                         if (status & StatsFull)
 857                                 update_stats(dev);
 858                         if (status & RxEarly) {
 859                                 work_budget = el3_rx(dev, work_budget);
 860                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 861                         }
 862                         if (status & AdapterFailure) {
 863                                 u16 fifo_diag;
 864                                 EL3WINDOW(4);
 865                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
 866                                 EL3WINDOW(1);
 867                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
 868                                            " register %04x.\n", dev->name, fifo_diag);
 869                                 if (fifo_diag & 0x0400) {
 870                                         /* Tx overrun */
 871                                         tc574_wait_for_completion(dev, TxReset);
 872                                         outw(TxEnable, ioaddr + EL3_CMD);
 873                                 }
 874                                 if (fifo_diag & 0x2000) {
 875                                         /* Rx underrun */
 876                                         tc574_wait_for_completion(dev, RxReset);
 877                                         set_rx_mode(dev);
 878                                         outw(RxEnable, ioaddr + EL3_CMD);
 879                                 }
 880                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 881                         }
 882                 }
 883
 884                 if (--work_budget < 0) {
 885                         DEBUG(0, "%s: Too much work in interrupt, "
 886                                   "status %4.4x.\n", dev->name, status);
 887                         /* Clear all interrupts */
 888                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 889                         break;
 890                 }
 891                 /* Acknowledge the IRQ. */
 892                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 893         }
 894
 895         DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
 896                   dev->name, inw(ioaddr + EL3_STATUS));
 897
 898         spin_unlock(&lp->window_lock);
 899         return IRQ_RETVAL(handled);
 900 }
 901
 902 /*
 903     This timer serves two purposes: to check for missed interrupts
 904         (and as a last resort, poll the NIC for events), and to monitor
 905         the MII, reporting changes in cable status.
 906 */
 907 static void media_check(unsigned long arg)
 908 {
 909         struct net_device *dev = (struct net_device *) arg;
 910         struct el3_private *lp = netdev_priv(dev);
 911         unsigned int ioaddr = dev->base_addr;
 912         unsigned long flags;
 913         unsigned short /* cable, */ media, partner;
 914
 915         if (!netif_device_present(dev))
 916                 goto reschedule;
 917
 918         /* Check for pending interrupt with expired latency timer: with
 919            this, we can limp along even if the interrupt is blocked */
 920         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
 921                 if (!lp->fast_poll)
 922                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
 923                 el3_interrupt(dev->irq, dev);
 924                 lp->fast_poll = HZ;
 925         }
 926         if (lp->fast_poll) {
 927                 lp->fast_poll--;
 928                 lp->media.expires = jiffies + 2*HZ/100;
 929                 add_timer(&lp->media);
 930                 return;
 931         }
 932
 933         spin_lock_irqsave(&lp->window_lock, flags);
 934         EL3WINDOW(4);
 935         media = mdio_read(ioaddr, lp->phys, 1);
 936         partner = mdio_read(ioaddr, lp->phys, 5);
 937         EL3WINDOW(1);
 938
 939         if (media != lp->media_status) {
 940                 if ((media ^ lp->media_status) & 0x0004)
 941                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
 942                                    (lp->media_status & 0x0004) ? "lost" : "found");
 943                 if ((media ^ lp->media_status) & 0x0020) {
 944                         lp->partner = 0;
 945                         if (lp->media_status & 0x0020) {
 946                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
 947                                            dev->name);
 948                         } else if (partner) {
 949                                 partner &= lp->advertising;
 950                                 lp->partner = partner;
 951                                 printk(KERN_INFO "%s: autonegotiation complete: "
 952                                            "%sbaseT-%cD selected\n", dev->name,
 953                                            ((partner & 0x0180) ? "100" : "10"),
 954                                            ((partner & 0x0140) ? 'F' : 'H'));
 955                         } else {
 956                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
 957                                            dev->name);
 958                         }
 959
 960                         EL3WINDOW(3);
 961                         outb((partner & 0x0140 ? 0x20 : 0) |
 962                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 963                         EL3WINDOW(1);
 964
 965                 }
 966                 if (media & 0x0010)
 967                         printk(KERN_INFO "%s: remote fault detected\n",
 968                                    dev->name);
 969                 if (media & 0x0002)
 970                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
 971                 lp->media_status = media;
 972         }
 973         spin_unlock_irqrestore(&lp->window_lock, flags);
 974
 975 reschedule:
 976         lp->media.expires = jiffies + HZ;
 977         add_timer(&lp->media);
 978 }
 979
 980 static struct net_device_stats *el3_get_stats(struct net_device *dev)
 981 {
 982         struct el3_private *lp = netdev_priv(dev);
 983
 984         if (netif_device_present(dev)) {
 985                 unsigned long flags;
 986                 spin_lock_irqsave(&lp->window_lock, flags);
 987                 update_stats(dev);
 988                 spin_unlock_irqrestore(&lp->window_lock, flags);
 989         }
 990         return &lp->stats;
 991 }
 992
 993 /*  Update statistics.
 994         Suprisingly this need not be run single-threaded, but it effectively is.
 995         The counters clear when read, so the adds must merely be atomic.
 996  */
 997 static void update_stats(struct net_device *dev)
 998 {
 999         struct el3_private *lp = netdev_priv(dev);
1000         unsigned int ioaddr = dev->base_addr;
1001         u8 rx, tx, up;
1002
1003         DEBUG(2, "%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         lp->stats.tx_carrier_errors             += inb(ioaddr + 0);
1012         lp->stats.tx_heartbeat_errors           += inb(ioaddr + 1);
1013         /* Multiple collisions. */              inb(ioaddr + 2);
1014         lp->stats.collisions                    += inb(ioaddr + 3);
1015         lp->stats.tx_window_errors              += inb(ioaddr + 4);
1016         lp->stats.rx_fifo_errors                += inb(ioaddr + 5);
1017         lp->stats.tx_packets                    += inb(ioaddr + 6);
1018         up                                       = inb(ioaddr + 9);
1019         lp->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         lp->stats.tx_bytes                      += tx + ((up & 0xf0) << 12);
1030
1031         EL3WINDOW(1);
1032 }
1033
1034 static int el3_rx(struct net_device *dev, int worklimit)
1035 {
1036         struct el3_private *lp = netdev_priv(dev);
1037         unsigned int ioaddr = dev->base_addr;
1038         short rx_status;
1039
1040         DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1041                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1042         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1043                    (--worklimit >= 0)) {
1044                 if (rx_status & 0x4000) { /* Error, update stats. */
1045                         short error = rx_status & 0x3800;
1046                         lp->stats.rx_errors++;
1047                         switch (error) {
1048                         case 0x0000:    lp->stats.rx_over_errors++; break;
1049                         case 0x0800:    lp->stats.rx_length_errors++; break;
1050                         case 0x1000:    lp->stats.rx_frame_errors++; break;
1051                         case 0x1800:    lp->stats.rx_length_errors++; break;
1052                         case 0x2000:    lp->stats.rx_frame_errors++; break;
1053                         case 0x2800:    lp->stats.rx_crc_errors++; break;
1054                         }
1055                 } else {
1056                         short pkt_len = rx_status & 0x7ff;
1057                         struct sk_buff *skb;
1058
1059                         skb = dev_alloc_skb(pkt_len+5);
1060
1061                         DEBUG(3, "  Receiving packet size %d status %4.4x.\n",
1062                                   pkt_len, rx_status);
1063                         if (skb != NULL) {
1064                                 skb_reserve(skb, 2);
1065                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1066                                                 ((pkt_len+3)>>2));
1067                                 skb->protocol = eth_type_trans(skb, dev);
1068                                 netif_rx(skb);
1069                                 dev->last_rx = jiffies;
1070                                 lp->stats.rx_packets++;
1071                                 lp->stats.rx_bytes += pkt_len;
1072                         } else {
1073                                 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1074                                           " size %d.\n", dev->name, pkt_len);
1075                                 lp->stats.rx_dropped++;
1076                         }
1077                 }
1078                 tc574_wait_for_completion(dev, RxDiscard);
1079         }
1080
1081         return worklimit;
1082 }
1083
1084 static void netdev_get_drvinfo(struct net_device *dev,
1085                                struct ethtool_drvinfo *info)
1086 {
1087         strcpy(info->driver, "3c574_cs");
1088 }
1089
1090 static const struct ethtool_ops netdev_ethtool_ops = {
1091         .get_drvinfo            = netdev_get_drvinfo,
1092 };
1093
1094 /* Provide ioctl() calls to examine the MII xcvr state. */
1095 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1096 {
1097         struct el3_private *lp = netdev_priv(dev);
1098         unsigned int ioaddr = dev->base_addr;
1099         u16 *data = (u16 *)&rq->ifr_ifru;
1100         int phy = lp->phys & 0x1f;
1101
1102         DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1103                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1104                   data[0], data[1], data[2], data[3]);
1105
1106         switch(cmd) {
1107         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1108                 data[0] = phy;
1109         case SIOCGMIIREG:               /* Read the specified MII register. */
1110                 {
1111                         int saved_window;
1112                         unsigned long flags;
1113
1114                         spin_lock_irqsave(&lp->window_lock, flags);
1115                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1116                         EL3WINDOW(4);
1117                         data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1118                         EL3WINDOW(saved_window);
1119                         spin_unlock_irqrestore(&lp->window_lock, flags);
1120                         return 0;
1121                 }
1122         case SIOCSMIIREG:               /* Write the specified MII register */
1123                 {
1124                         int saved_window;
1125                        unsigned long flags;
1126
1127                         if (!capable(CAP_NET_ADMIN))
1128                                 return -EPERM;
1129                         spin_lock_irqsave(&lp->window_lock, flags);
1130                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1131                         EL3WINDOW(4);
1132                         mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1133                         EL3WINDOW(saved_window);
1134                         spin_unlock_irqrestore(&lp->window_lock, flags);
1135                         return 0;
1136                 }
1137         default:
1138                 return -EOPNOTSUPP;
1139         }
1140 }
1141
1142 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1143    documented.  Until it is we revert to receiving all multicast frames when
1144    any multicast reception is desired.
1145    Note: My other drivers emit a log message whenever promiscuous mode is
1146    entered to help detect password sniffers.  This is less desirable on
1147    typical PC card machines, so we omit the message.
1148    */
1149
1150 static void set_rx_mode(struct net_device *dev)
1151 {
1152         unsigned int ioaddr = dev->base_addr;
1153
1154         if (dev->flags & IFF_PROMISC)
1155                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1156                          ioaddr + EL3_CMD);
1157         else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1158                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1159         else
1160                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1161 }
1162
1163 static int el3_close(struct net_device *dev)
1164 {
1165         unsigned int ioaddr = dev->base_addr;
1166         struct el3_private *lp = netdev_priv(dev);
1167         struct pcmcia_device *link = lp->p_dev;
1168
1169         DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1170
1171         if (pcmcia_dev_present(link)) {
1172                 unsigned long flags;
1173
1174                 /* Turn off statistics ASAP.  We update lp->stats below. */
1175                 outw(StatsDisable, ioaddr + EL3_CMD);
1176
1177                 /* Disable the receiver and transmitter. */
1178                 outw(RxDisable, ioaddr + EL3_CMD);
1179                 outw(TxDisable, ioaddr + EL3_CMD);
1180
1181                 /* Note: Switching to window 0 may disable the IRQ. */
1182                 EL3WINDOW(0);
1183                 spin_lock_irqsave(&lp->window_lock, flags);
1184                 update_stats(dev);
1185                 spin_unlock_irqrestore(&lp->window_lock, flags);
1186
1187                 /* force interrupts off */
1188                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1189         }
1190
1191         link->open--;
1192         netif_stop_queue(dev);
1193         del_timer_sync(&lp->media);
1194
1195         return 0;
1196 }
1197
1198 static struct pcmcia_device_id tc574_ids[] = {
1199         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1200         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1201         PCMCIA_DEVICE_NULL,
1202 };
1203 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1204
1205 static struct pcmcia_driver tc574_driver = {
1206         .owner          = THIS_MODULE,
1207         .drv            = {
1208                 .name   = "3c574_cs",
1209         },
1210         .probe          = tc574_probe,
1211         .remove         = tc574_detach,
1212         .id_table       = tc574_ids,
1213         .suspend        = tc574_suspend,
1214         .resume         = tc574_resume,
1215 };
1216
1217 static int __init init_tc574(void)
1218 {
1219         return pcmcia_register_driver(&tc574_driver);
1220 }
1221
1222 static void __exit exit_tc574(void)
1223 {
1224         pcmcia_unregister_driver(&tc574_driver);
1225 }
1226
1227 module_init(init_tc574);
1228 module_exit(exit_tc574);