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