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