drivers/net/pcmcia/3c574_cs.c

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