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