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