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