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