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