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