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