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