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