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