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