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