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