SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/pcmcia/pcnet_cs.c

   1 /*======================================================================
   2
   3     A PCMCIA ethernet driver for NS8390-based cards
   4
   5     This driver supports the D-Link DE-650 and Linksys EthernetCard
   6     cards, the newer D-Link and Linksys combo cards, Accton EN2212
   7     cards, the RPTI EP400, and the PreMax PE-200 in non-shared-memory
   8     mode, and the IBM Credit Card Adapter, the NE4100, the Thomas
   9     Conrad ethernet card, and the Kingston KNE-PCM/x in shared-memory
  10     mode.  It will also handle the Socket EA card in either mode.
  11
  12     Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
  13
  14     pcnet_cs.c 1.153 2003/11/09 18:53:09
  15
  16     The network driver code is based on Donald Becker's NE2000 code:
  17
  18     Written 1992,1993 by Donald Becker.
  19     Copyright 1993 United States Government as represented by the
  20     Director, National Security Agency.  This software may be used and
  21     distributed according to the terms of the GNU General Public License,
  22     incorporated herein by reference.
  23     Donald Becker may be reached at becker@scyld.com
  24
  25     Based also on Keith Moore's changes to Don Becker's code, for IBM
  26     CCAE support.  Drivers merged back together, and shared-memory
  27     Socket EA support added, by Ken Raeburn, September 1995.
  28
  29 ======================================================================*/
  30
  31 #include <linux/kernel.h>
  32 #include <linux/module.h>
  33 #include <linux/init.h>
  34 #include <linux/ptrace.h>
  35 #include <linux/slab.h>
  36 #include <linux/string.h>
  37 #include <linux/timer.h>
  38 #include <linux/delay.h>
  39 #include <linux/ethtool.h>
  40 #include <linux/netdevice.h>
  41 #include <../drivers/net/8390.h>
  42
  43 #include <pcmcia/cs_types.h>
  44 #include <pcmcia/cs.h>
  45 #include <pcmcia/cistpl.h>
  46 #include <pcmcia/ciscode.h>
  47 #include <pcmcia/ds.h>
  48 #include <pcmcia/cisreg.h>
  49
  50 #include <asm/io.h>
  51 #include <asm/system.h>
  52 #include <asm/byteorder.h>
  53 #include <asm/uaccess.h>
  54
  55 #define PCNET_CMD       0x00
  56 #define PCNET_DATAPORT  0x10    /* NatSemi-defined port window offset. */
  57 #define PCNET_RESET     0x1f    /* Issue a read to reset, a write to clear. */
  58 #define PCNET_MISC      0x18    /* For IBM CCAE and Socket EA cards */
  59
  60 #define PCNET_START_PG  0x40    /* First page of TX buffer */
  61 #define PCNET_STOP_PG   0x80    /* Last page +1 of RX ring */
  62
  63 /* Socket EA cards have a larger packet buffer */
  64 #define SOCKET_START_PG 0x01
  65 #define SOCKET_STOP_PG  0xff
  66
  67 #define PCNET_RDC_TIMEOUT (2*HZ/100)    /* Max wait in jiffies for Tx RDC */
  68
  69 static const char *if_names[] = { "auto", "10baseT", "10base2"};
  70
  71 #ifdef PCMCIA_DEBUG
  72 static int pc_debug = PCMCIA_DEBUG;
  73 module_param(pc_debug, int, 0);
  74 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  75 static char *version =
  76 "pcnet_cs.c 1.153 2003/11/09 18:53:09 (David Hinds)";
  77 #else
  78 #define DEBUG(n, args...)
  79 #endif
  80
  81 /*====================================================================*/
  82
  83 /* Module parameters */
  84
  85 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  86 MODULE_DESCRIPTION("NE2000 compatible PCMCIA ethernet driver");
  87 MODULE_LICENSE("GPL");
  88
  89 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  90
  91 INT_MODULE_PARM(if_port,        1);     /* Transceiver type */
  92 INT_MODULE_PARM(use_big_buf,    1);     /* use 64K packet buffer? */
  93 INT_MODULE_PARM(mem_speed,      0);     /* shared mem speed, in ns */
  94 INT_MODULE_PARM(delay_output,   0);     /* pause after xmit? */
  95 INT_MODULE_PARM(delay_time,     4);     /* in usec */
  96 INT_MODULE_PARM(use_shmem,      -1);    /* use shared memory? */
  97 INT_MODULE_PARM(full_duplex,    0);     /* full duplex? */
  98
  99 /* Ugh!  Let the user hardwire the hardware address for queer cards */
 100 static int hw_addr[6] = { 0, /* ... */ };
 101 module_param_array(hw_addr, int, NULL, 0);
 102
 103 /*====================================================================*/
 104
 105 static void mii_phy_probe(struct net_device *dev);
 106 static int pcnet_config(struct pcmcia_device *link);
 107 static void pcnet_release(struct pcmcia_device *link);
 108 static int pcnet_open(struct net_device *dev);
 109 static int pcnet_close(struct net_device *dev);
 110 static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 111 static struct ethtool_ops netdev_ethtool_ops;
 112 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs);
 113 static void ei_watchdog(u_long arg);
 114 static void pcnet_reset_8390(struct net_device *dev);
 115 static int set_config(struct net_device *dev, struct ifmap *map);
 116 static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
 117                               int stop_pg, int cm_offset);
 118 static int setup_dma_config(struct pcmcia_device *link, int start_pg,
 119                             int stop_pg);
 120
 121 static void pcnet_detach(struct pcmcia_device *p_dev);
 122
 123 static dev_info_t dev_info = "pcnet_cs";
 124
 125 /*====================================================================*/
 126
 127 typedef struct hw_info_t {
 128     u_int       offset;
 129     u_char      a0, a1, a2;
 130     u_int       flags;
 131 } hw_info_t;
 132
 133 #define DELAY_OUTPUT    0x01
 134 #define HAS_MISC_REG    0x02
 135 #define USE_BIG_BUF     0x04
 136 #define HAS_IBM_MISC    0x08
 137 #define IS_DL10019      0x10
 138 #define IS_DL10022      0x20
 139 #define HAS_MII         0x40
 140 #define USE_SHMEM       0x80    /* autodetected */
 141
 142 #define AM79C9XX_HOME_PHY       0x00006B90  /* HomePNA PHY */
 143 #define AM79C9XX_ETH_PHY        0x00006B70  /* 10baseT PHY */
 144 #define MII_PHYID_REV_MASK      0xfffffff0
 145 #define MII_PHYID_REG1          0x02
 146 #define MII_PHYID_REG2          0x03
 147
 148 static hw_info_t hw_info[] = {
 149     { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
 150     { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
 151     { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
 152     { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
 153       DELAY_OUTPUT | HAS_IBM_MISC },
 154     { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
 155     { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
 156     { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
 157     { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
 158     { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
 159     { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
 160     { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
 161       HAS_MISC_REG | HAS_IBM_MISC },
 162     { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
 163     { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
 164     { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
 165       HAS_MISC_REG | HAS_IBM_MISC },
 166     { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
 167       HAS_MISC_REG | HAS_IBM_MISC },
 168     { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
 169       HAS_MISC_REG | HAS_IBM_MISC },
 170     { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
 171       HAS_MISC_REG | HAS_IBM_MISC },
 172     { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
 173       HAS_MISC_REG | HAS_IBM_MISC },
 174     { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
 175       HAS_MISC_REG | HAS_IBM_MISC },
 176     { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
 177       HAS_MISC_REG | HAS_IBM_MISC },
 178     { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
 179       HAS_MISC_REG | HAS_IBM_MISC },
 180     { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
 181       HAS_MISC_REG | HAS_IBM_MISC },
 182     { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
 183       HAS_MISC_REG | HAS_IBM_MISC },
 184     { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
 185     { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
 186     { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
 187       HAS_MISC_REG | HAS_IBM_MISC },
 188     { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
 189       HAS_MISC_REG | HAS_IBM_MISC },
 190     { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
 191     { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
 192     { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
 193     { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
 194     { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
 195       HAS_MISC_REG | HAS_IBM_MISC },
 196     { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45,
 197       HAS_MISC_REG | HAS_IBM_MISC },
 198     { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
 199     { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
 200     { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
 201     { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
 202       DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
 203     { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 },
 204     { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
 205     { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
 206     { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
 207     { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }
 208 };
 209
 210 #define NR_INFO         (sizeof(hw_info)/sizeof(hw_info_t))
 211
 212 static hw_info_t default_info = { 0, 0, 0, 0, 0 };
 213 static hw_info_t dl10019_info = { 0, 0, 0, 0, IS_DL10019|HAS_MII };
 214 static hw_info_t dl10022_info = { 0, 0, 0, 0, IS_DL10022|HAS_MII };
 215
 216 typedef struct pcnet_dev_t {
 217         struct pcmcia_device    *p_dev;
 218     dev_node_t          node;
 219     u_int               flags;
 220     void                __iomem *base;
 221     struct timer_list   watchdog;
 222     int                 stale, fast_poll;
 223     u_char              phy_id;
 224     u_char              eth_phy, pna_phy;
 225     u_short             link_status;
 226     u_long              mii_reset;
 227 } pcnet_dev_t;
 228
 229 static inline pcnet_dev_t *PRIV(struct net_device *dev)
 230 {
 231         char *p = netdev_priv(dev);
 232         return (pcnet_dev_t *)(p + sizeof(struct ei_device));
 233 }
 234
 235 /*======================================================================
 236
 237     pcnet_attach() creates an "instance" of the driver, allocating
 238     local data structures for one device.  The device is registered
 239     with Card Services.
 240
 241 ======================================================================*/
 242
 243 static int pcnet_probe(struct pcmcia_device *link)
 244 {
 245     pcnet_dev_t *info;
 246     struct net_device *dev;
 247
 248     DEBUG(0, "pcnet_attach()\n");
 249
 250     /* Create new ethernet device */
 251     dev = __alloc_ei_netdev(sizeof(pcnet_dev_t));
 252     if (!dev) return -ENOMEM;
 253     info = PRIV(dev);
 254     info->p_dev = link;
 255     link->priv = dev;
 256
 257     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 258     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 259     link->conf.Attributes = CONF_ENABLE_IRQ;
 260     link->conf.IntType = INT_MEMORY_AND_IO;
 261
 262     SET_MODULE_OWNER(dev);
 263     dev->open = &pcnet_open;
 264     dev->stop = &pcnet_close;
 265     dev->set_config = &set_config;
 266
 267     link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 268     return pcnet_config(link);
 269 } /* pcnet_attach */
 270
 271 /*======================================================================
 272
 273     This deletes a driver "instance".  The device is de-registered
 274     with Card Services.  If it has been released, all local data
 275     structures are freed.  Otherwise, the structures will be freed
 276     when the device is released.
 277
 278 ======================================================================*/
 279
 280 static void pcnet_detach(struct pcmcia_device *link)
 281 {
 282         struct net_device *dev = link->priv;
 283
 284         DEBUG(0, "pcnet_detach(0x%p)\n", link);
 285
 286         if (link->dev_node)
 287                 unregister_netdev(dev);
 288
 289         if (link->state & DEV_CONFIG)
 290                 pcnet_release(link);
 291
 292         free_netdev(dev);
 293 } /* pcnet_detach */
 294
 295 /*======================================================================
 296
 297     This probes for a card's hardware address, for card types that
 298     encode this information in their CIS.
 299
 300 ======================================================================*/
 301
 302 static hw_info_t *get_hwinfo(struct pcmcia_device *link)
 303 {
 304     struct net_device *dev = link->priv;
 305     win_req_t req;
 306     memreq_t mem;
 307     u_char __iomem *base, *virt;
 308     int i, j;
 309
 310     /* Allocate a small memory window */
 311     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 312     req.Base = 0; req.Size = 0;
 313     req.AccessSpeed = 0;
 314     i = pcmcia_request_window(&link, &req, &link->win);
 315     if (i != CS_SUCCESS) {
 316         cs_error(link, RequestWindow, i);
 317         return NULL;
 318     }
 319
 320     virt = ioremap(req.Base, req.Size);
 321     mem.Page = 0;
 322     for (i = 0; i < NR_INFO; i++) {
 323         mem.CardOffset = hw_info[i].offset & ~(req.Size-1);
 324         pcmcia_map_mem_page(link->win, &mem);
 325         base = &virt[hw_info[i].offset & (req.Size-1)];
 326         if ((readb(base+0) == hw_info[i].a0) &&
 327             (readb(base+2) == hw_info[i].a1) &&
 328             (readb(base+4) == hw_info[i].a2))
 329             break;
 330     }
 331     if (i < NR_INFO) {
 332         for (j = 0; j < 6; j++)
 333             dev->dev_addr[j] = readb(base + (j<<1));
 334     }
 335
 336     iounmap(virt);
 337     j = pcmcia_release_window(link->win);
 338     if (j != CS_SUCCESS)
 339         cs_error(link, ReleaseWindow, j);
 340     return (i < NR_INFO) ? hw_info+i : NULL;
 341 } /* get_hwinfo */
 342
 343 /*======================================================================
 344
 345     This probes for a card's hardware address by reading the PROM.
 346     It checks the address against a list of known types, then falls
 347     back to a simple NE2000 clone signature check.
 348
 349 ======================================================================*/
 350
 351 static hw_info_t *get_prom(struct pcmcia_device *link)
 352 {
 353     struct net_device *dev = link->priv;
 354     kio_addr_t ioaddr = dev->base_addr;
 355     u_char prom[32];
 356     int i, j;
 357
 358     /* This is lifted straight from drivers/net/ne.c */
 359     struct {
 360         u_char value, offset;
 361     } program_seq[] = {
 362         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 363         {0x48,  EN0_DCFG},      /* Set byte-wide (0x48) access. */
 364         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 365         {0x00,  EN0_RCNTHI},
 366         {0x00,  EN0_IMR},       /* Mask completion irq. */
 367         {0xFF,  EN0_ISR},
 368         {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 369         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 370         {32,    EN0_RCNTLO},
 371         {0x00,  EN0_RCNTHI},
 372         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 373         {0x00,  EN0_RSARHI},
 374         {E8390_RREAD+E8390_START, E8390_CMD},
 375     };
 376
 377     pcnet_reset_8390(dev);
 378     mdelay(10);
 379
 380     for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
 381         outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
 382
 383     for (i = 0; i < 32; i++)
 384         prom[i] = inb(ioaddr + PCNET_DATAPORT);
 385     for (i = 0; i < NR_INFO; i++) {
 386         if ((prom[0] == hw_info[i].a0) &&
 387             (prom[2] == hw_info[i].a1) &&
 388             (prom[4] == hw_info[i].a2))
 389             break;
 390     }
 391     if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
 392         for (j = 0; j < 6; j++)
 393             dev->dev_addr[j] = prom[j<<1];
 394         return (i < NR_INFO) ? hw_info+i : &default_info;
 395     }
 396     return NULL;
 397 } /* get_prom */
 398
 399 /*======================================================================
 400
 401     For DL10019 based cards, like the Linksys EtherFast
 402
 403 ======================================================================*/
 404
 405 static hw_info_t *get_dl10019(struct pcmcia_device *link)
 406 {
 407     struct net_device *dev = link->priv;
 408     int i;
 409     u_char sum;
 410
 411     for (sum = 0, i = 0x14; i < 0x1c; i++)
 412         sum += inb_p(dev->base_addr + i);
 413     if (sum != 0xff)
 414         return NULL;
 415     for (i = 0; i < 6; i++)
 416         dev->dev_addr[i] = inb_p(dev->base_addr + 0x14 + i);
 417     i = inb(dev->base_addr + 0x1f);
 418     return ((i == 0x91)||(i == 0x99)) ? &dl10022_info : &dl10019_info;
 419 }
 420
 421 /*======================================================================
 422
 423     For Asix AX88190 based cards
 424
 425 ======================================================================*/
 426
 427 static hw_info_t *get_ax88190(struct pcmcia_device *link)
 428 {
 429     struct net_device *dev = link->priv;
 430     kio_addr_t ioaddr = dev->base_addr;
 431     int i, j;
 432
 433     /* Not much of a test, but the alternatives are messy */
 434     if (link->conf.ConfigBase != 0x03c0)
 435         return NULL;
 436
 437     outb_p(0x01, ioaddr + EN0_DCFG);    /* Set word-wide access. */
 438     outb_p(0x00, ioaddr + EN0_RSARLO);  /* DMA starting at 0x0400. */
 439     outb_p(0x04, ioaddr + EN0_RSARHI);
 440     outb_p(E8390_RREAD+E8390_START, ioaddr + E8390_CMD);
 441
 442     for (i = 0; i < 6; i += 2) {
 443         j = inw(ioaddr + PCNET_DATAPORT);
 444         dev->dev_addr[i] = j & 0xff;
 445         dev->dev_addr[i+1] = j >> 8;
 446     }
 447     printk(KERN_NOTICE "pcnet_cs: this is an AX88190 card!\n");
 448     printk(KERN_NOTICE "pcnet_cs: use axnet_cs instead.\n");
 449     return NULL;
 450 }
 451
 452 /*======================================================================
 453
 454     This should be totally unnecessary... but when we can't figure
 455     out the hardware address any other way, we'll let the user hard
 456     wire it when the module is initialized.
 457
 458 ======================================================================*/
 459
 460 static hw_info_t *get_hwired(struct pcmcia_device *link)
 461 {
 462     struct net_device *dev = link->priv;
 463     int i;
 464
 465     for (i = 0; i < 6; i++)
 466         if (hw_addr[i] != 0) break;
 467     if (i == 6)
 468         return NULL;
 469
 470     for (i = 0; i < 6; i++)
 471         dev->dev_addr[i] = hw_addr[i];
 472
 473     return &default_info;
 474 } /* get_hwired */
 475
 476 /*======================================================================
 477
 478     pcnet_config() is scheduled to run after a CARD_INSERTION event
 479     is received, to configure the PCMCIA socket, and to make the
 480     ethernet device available to the system.
 481
 482 ======================================================================*/
 483
 484 #define CS_CHECK(fn, ret) \
 485 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 486
 487 static int try_io_port(struct pcmcia_device *link)
 488 {
 489     int j, ret;
 490     if (link->io.NumPorts1 == 32) {
 491         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 492         if (link->io.NumPorts2 > 0) {
 493             /* for master/slave multifunction cards */
 494             link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 495             link->irq.Attributes =
 496                 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 497         }
 498     } else {
 499         /* This should be two 16-port windows */
 500         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 501         link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
 502     }
 503     if (link->io.BasePort1 == 0) {
 504         link->io.IOAddrLines = 16;
 505         for (j = 0; j < 0x400; j += 0x20) {
 506             link->io.BasePort1 = j ^ 0x300;
 507             link->io.BasePort2 = (j ^ 0x300) + 0x10;
 508             ret = pcmcia_request_io(link, &link->io);
 509             if (ret == CS_SUCCESS) return ret;
 510         }
 511         return ret;
 512     } else {
 513         return pcmcia_request_io(link, &link->io);
 514     }
 515 }
 516
 517 static int pcnet_config(struct pcmcia_device *link)
 518 {
 519     struct net_device *dev = link->priv;
 520     pcnet_dev_t *info = PRIV(dev);
 521     tuple_t tuple;
 522     cisparse_t parse;
 523     int i, last_ret, last_fn, start_pg, stop_pg, cm_offset;
 524     int manfid = 0, prodid = 0, has_shmem = 0;
 525     u_short buf[64];
 526     hw_info_t *hw_info;
 527
 528     DEBUG(0, "pcnet_config(0x%p)\n", link);
 529
 530     tuple.Attributes = 0;
 531     tuple.TupleData = (cisdata_t *)buf;
 532     tuple.TupleDataMax = sizeof(buf);
 533     tuple.TupleOffset = 0;
 534     tuple.DesiredTuple = CISTPL_CONFIG;
 535     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 536     CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
 537     CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
 538     link->conf.ConfigBase = parse.config.base;
 539     link->conf.Present = parse.config.rmask[0];
 540
 541     /* Configure card */
 542     link->state |= DEV_CONFIG;
 543
 544     tuple.DesiredTuple = CISTPL_MANFID;
 545     tuple.Attributes = TUPLE_RETURN_COMMON;
 546     if ((pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) &&
 547         (pcmcia_get_tuple_data(link, &tuple) == CS_SUCCESS)) {
 548         manfid = le16_to_cpu(buf[0]);
 549         prodid = le16_to_cpu(buf[1]);
 550     }
 551
 552     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 553     tuple.Attributes = 0;
 554     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 555     while (last_ret == CS_SUCCESS) {
 556         cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 557         cistpl_io_t *io = &(parse.cftable_entry.io);
 558
 559         if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
 560                         pcmcia_parse_tuple(link, &tuple, &parse) != 0 ||
 561                         cfg->index == 0 || cfg->io.nwin == 0)
 562                 goto next_entry;
 563
 564         link->conf.ConfigIndex = cfg->index;
 565         /* For multifunction cards, by convention, we configure the
 566            network function with window 0, and serial with window 1 */
 567         if (io->nwin > 1) {
 568             i = (io->win[1].len > io->win[0].len);
 569             link->io.BasePort2 = io->win[1-i].base;
 570             link->io.NumPorts2 = io->win[1-i].len;
 571         } else {
 572             i = link->io.NumPorts2 = 0;
 573         }
 574         has_shmem = ((cfg->mem.nwin == 1) &&
 575                      (cfg->mem.win[0].len >= 0x4000));
 576         link->io.BasePort1 = io->win[i].base;
 577         link->io.NumPorts1 = io->win[i].len;
 578         link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 579         if (link->io.NumPorts1 + link->io.NumPorts2 >= 32) {
 580             last_ret = try_io_port(link);
 581             if (last_ret == CS_SUCCESS) break;
 582         }
 583     next_entry:
 584         last_ret = pcmcia_get_next_tuple(link, &tuple);
 585     }
 586     if (last_ret != CS_SUCCESS) {
 587         cs_error(link, RequestIO, last_ret);
 588         goto failed;
 589     }
 590
 591     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 592
 593     if (link->io.NumPorts2 == 8) {
 594         link->conf.Attributes |= CONF_ENABLE_SPKR;
 595         link->conf.Status = CCSR_AUDIO_ENA;
 596     }
 597     if ((manfid == MANFID_IBM) &&
 598         (prodid == PRODID_IBM_HOME_AND_AWAY))
 599         link->conf.ConfigIndex |= 0x10;
 600
 601     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 602     dev->irq = link->irq.AssignedIRQ;
 603     dev->base_addr = link->io.BasePort1;
 604     if (info->flags & HAS_MISC_REG) {
 605         if ((if_port == 1) || (if_port == 2))
 606             dev->if_port = if_port;
 607         else
 608             printk(KERN_NOTICE "pcnet_cs: invalid if_port requested\n");
 609     } else {
 610         dev->if_port = 0;
 611     }
 612
 613     hw_info = get_hwinfo(link);
 614     if (hw_info == NULL)
 615         hw_info = get_prom(link);
 616     if (hw_info == NULL)
 617         hw_info = get_dl10019(link);
 618     if (hw_info == NULL)
 619         hw_info = get_ax88190(link);
 620     if (hw_info == NULL)
 621         hw_info = get_hwired(link);
 622
 623     if (hw_info == NULL) {
 624         printk(KERN_NOTICE "pcnet_cs: unable to read hardware net"
 625                " address for io base %#3lx\n", dev->base_addr);
 626         goto failed;
 627     }
 628
 629     info->flags = hw_info->flags;
 630     /* Check for user overrides */
 631     info->flags |= (delay_output) ? DELAY_OUTPUT : 0;
 632     if ((manfid == MANFID_SOCKET) &&
 633         ((prodid == PRODID_SOCKET_LPE) ||
 634          (prodid == PRODID_SOCKET_LPE_CF) ||
 635          (prodid == PRODID_SOCKET_EIO)))
 636         info->flags &= ~USE_BIG_BUF;
 637     if (!use_big_buf)
 638         info->flags &= ~USE_BIG_BUF;
 639
 640     if (info->flags & USE_BIG_BUF) {
 641         start_pg = SOCKET_START_PG;
 642         stop_pg = SOCKET_STOP_PG;
 643         cm_offset = 0x10000;
 644     } else {
 645         start_pg = PCNET_START_PG;
 646         stop_pg = PCNET_STOP_PG;
 647         cm_offset = 0;
 648     }
 649
 650     /* has_shmem is ignored if use_shmem != -1 */
 651     if ((use_shmem == 0) || (!has_shmem && (use_shmem == -1)) ||
 652         (setup_shmem_window(link, start_pg, stop_pg, cm_offset) != 0))
 653         setup_dma_config(link, start_pg, stop_pg);
 654
 655     ei_status.name = "NE2000";
 656     ei_status.word16 = 1;
 657     ei_status.reset_8390 = &pcnet_reset_8390;
 658
 659     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 660
 661     if (info->flags & (IS_DL10019|IS_DL10022)) {
 662         u_char id = inb(dev->base_addr + 0x1a);
 663         dev->do_ioctl = &ei_ioctl;
 664         mii_phy_probe(dev);
 665         if ((id == 0x30) && !info->pna_phy && (info->eth_phy == 4))
 666             info->eth_phy = 0;
 667     }
 668
 669     link->dev_node = &info->node;
 670     link->state &= ~DEV_CONFIG_PENDING;
 671     SET_NETDEV_DEV(dev, &handle_to_dev(link));
 672
 673 #ifdef CONFIG_NET_POLL_CONTROLLER
 674     dev->poll_controller = ei_poll;
 675 #endif
 676
 677     if (register_netdev(dev) != 0) {
 678         printk(KERN_NOTICE "pcnet_cs: register_netdev() failed\n");
 679         link->dev_node = NULL;
 680         goto failed;
 681     }
 682
 683     strcpy(info->node.dev_name, dev->name);
 684
 685     if (info->flags & (IS_DL10019|IS_DL10022)) {
 686         u_char id = inb(dev->base_addr + 0x1a);
 687         printk(KERN_INFO "%s: NE2000 (DL100%d rev %02x): ",
 688                dev->name, ((info->flags & IS_DL10022) ? 22 : 19), id);
 689         if (info->pna_phy)
 690             printk("PNA, ");
 691     } else {
 692         printk(KERN_INFO "%s: NE2000 Compatible: ", dev->name);
 693     }
 694     printk("io %#3lx, irq %d,", dev->base_addr, dev->irq);
 695     if (info->flags & USE_SHMEM)
 696         printk (" mem %#5lx,", dev->mem_start);
 697     if (info->flags & HAS_MISC_REG)
 698         printk(" %s xcvr,", if_names[dev->if_port]);
 699     printk(" hw_addr ");
 700     for (i = 0; i < 6; i++)
 701         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
 702     return 0;
 703
 704 cs_failed:
 705     cs_error(link, last_fn, last_ret);
 706 failed:
 707     pcnet_release(link);
 708     link->state &= ~DEV_CONFIG_PENDING;
 709     return -ENODEV;
 710 } /* pcnet_config */
 711
 712 /*======================================================================
 713
 714     After a card is removed, pcnet_release() will unregister the net
 715     device, and release the PCMCIA configuration.  If the device is
 716     still open, this will be postponed until it is closed.
 717
 718 ======================================================================*/
 719
 720 static void pcnet_release(struct pcmcia_device *link)
 721 {
 722         pcnet_dev_t *info = PRIV(link->priv);
 723
 724         DEBUG(0, "pcnet_release(0x%p)\n", link);
 725
 726         if (info->flags & USE_SHMEM)
 727                 iounmap(info->base);
 728
 729         pcmcia_disable_device(link);
 730 }
 731
 732 /*======================================================================
 733
 734     The card status event handler.  Mostly, this schedules other
 735     stuff to run after an event is received.  A CARD_REMOVAL event
 736     also sets some flags to discourage the net drivers from trying
 737     to talk to the card any more.
 738
 739 ======================================================================*/
 740
 741 static int pcnet_suspend(struct pcmcia_device *link)
 742 {
 743         struct net_device *dev = link->priv;
 744
 745         if ((link->state & DEV_CONFIG) && (link->open))
 746                 netif_device_detach(dev);
 747
 748         return 0;
 749 }
 750
 751 static int pcnet_resume(struct pcmcia_device *link)
 752 {
 753         struct net_device *dev = link->priv;
 754
 755         if ((link->state & DEV_CONFIG) && (link->open)) {
 756                 pcnet_reset_8390(dev);
 757                 NS8390_init(dev, 1);
 758                 netif_device_attach(dev);
 759         }
 760
 761         return 0;
 762 }
 763
 764
 765 /*======================================================================
 766
 767     MII interface support for DL10019 and DL10022 based cards
 768
 769     On the DL10019, the MII IO direction bit is 0x10; on the DL10022
 770     it is 0x20.  Setting both bits seems to work on both card types.
 771
 772 ======================================================================*/
 773
 774 #define DLINK_GPIO              0x1c
 775 #define DLINK_DIAG              0x1d
 776 #define DLINK_EEPROM            0x1e
 777
 778 #define MDIO_SHIFT_CLK          0x80
 779 #define MDIO_DATA_OUT           0x40
 780 #define MDIO_DIR_WRITE          0x30
 781 #define MDIO_DATA_WRITE0        (MDIO_DIR_WRITE)
 782 #define MDIO_DATA_WRITE1        (MDIO_DIR_WRITE | MDIO_DATA_OUT)
 783 #define MDIO_DATA_READ          0x10
 784 #define MDIO_MASK               0x0f
 785
 786 static void mdio_sync(kio_addr_t addr)
 787 {
 788     int bits, mask = inb(addr) & MDIO_MASK;
 789     for (bits = 0; bits < 32; bits++) {
 790         outb(mask | MDIO_DATA_WRITE1, addr);
 791         outb(mask | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
 792     }
 793 }
 794
 795 static int mdio_read(kio_addr_t addr, int phy_id, int loc)
 796 {
 797     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
 798     int i, retval = 0, mask = inb(addr) & MDIO_MASK;
 799
 800     mdio_sync(addr);
 801     for (i = 13; i >= 0; i--) {
 802         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 803         outb(mask | dat, addr);
 804         outb(mask | dat | MDIO_SHIFT_CLK, addr);
 805     }
 806     for (i = 19; i > 0; i--) {
 807         outb(mask, addr);
 808         retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
 809         outb(mask | MDIO_SHIFT_CLK, addr);
 810     }
 811     return (retval>>1) & 0xffff;
 812 }
 813
 814 static void mdio_write(kio_addr_t addr, int phy_id, int loc, int value)
 815 {
 816     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
 817     int i, mask = inb(addr) & MDIO_MASK;
 818
 819     mdio_sync(addr);
 820     for (i = 31; i >= 0; i--) {
 821         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 822         outb(mask | dat, addr);
 823         outb(mask | dat | MDIO_SHIFT_CLK, addr);
 824     }
 825     for (i = 1; i >= 0; i--) {
 826         outb(mask, addr);
 827         outb(mask | MDIO_SHIFT_CLK, addr);
 828     }
 829 }
 830
 831 static void mdio_reset(kio_addr_t addr, int phy_id)
 832 {
 833     outb_p(0x08, addr);
 834     outb_p(0x0c, addr);
 835     outb_p(0x08, addr);
 836     outb_p(0x0c, addr);
 837     outb_p(0x00, addr);
 838 }
 839
 840 /*======================================================================
 841
 842     EEPROM access routines for DL10019 and DL10022 based cards
 843
 844 ======================================================================*/
 845
 846 #define EE_EEP          0x40
 847 #define EE_ASIC         0x10
 848 #define EE_CS           0x08
 849 #define EE_CK           0x04
 850 #define EE_DO           0x02
 851 #define EE_DI           0x01
 852 #define EE_ADOT         0x01    /* DataOut for ASIC */
 853 #define EE_READ_CMD     0x06
 854
 855 #define DL19FDUPLX      0x0400  /* DL10019 Full duplex mode */
 856
 857 static int read_eeprom(kio_addr_t ioaddr, int location)
 858 {
 859     int i, retval = 0;
 860     kio_addr_t ee_addr = ioaddr + DLINK_EEPROM;
 861     int read_cmd = location | (EE_READ_CMD << 8);
 862
 863     outb(0, ee_addr);
 864     outb(EE_EEP|EE_CS, ee_addr);
 865
 866     /* Shift the read command bits out. */
 867     for (i = 10; i >= 0; i--) {
 868         short dataval = (read_cmd & (1 << i)) ? EE_DO : 0;
 869         outb_p(EE_EEP|EE_CS|dataval, ee_addr);
 870         outb_p(EE_EEP|EE_CS|dataval|EE_CK, ee_addr);
 871     }
 872     outb(EE_EEP|EE_CS, ee_addr);
 873
 874     for (i = 16; i > 0; i--) {
 875         outb_p(EE_EEP|EE_CS | EE_CK, ee_addr);
 876         retval = (retval << 1) | ((inb(ee_addr) & EE_DI) ? 1 : 0);
 877         outb_p(EE_EEP|EE_CS, ee_addr);
 878     }
 879
 880     /* Terminate the EEPROM access. */
 881     outb(0, ee_addr);
 882     return retval;
 883 }
 884
 885 /*
 886     The internal ASIC registers can be changed by EEPROM READ access
 887     with EE_ASIC bit set.
 888     In ASIC mode, EE_ADOT is used to output the data to the ASIC.
 889 */
 890
 891 static void write_asic(kio_addr_t ioaddr, int location, short asic_data)
 892 {
 893         int i;
 894         kio_addr_t ee_addr = ioaddr + DLINK_EEPROM;
 895         short dataval;
 896         int read_cmd = location | (EE_READ_CMD << 8);
 897
 898         asic_data |= read_eeprom(ioaddr, location);
 899
 900         outb(0, ee_addr);
 901         outb(EE_ASIC|EE_CS|EE_DI, ee_addr);
 902
 903         read_cmd = read_cmd >> 1;
 904
 905         /* Shift the read command bits out. */
 906         for (i = 9; i >= 0; i--) {
 907                 dataval = (read_cmd & (1 << i)) ? EE_DO : 0;
 908                 outb_p(EE_ASIC|EE_CS|EE_DI|dataval, ee_addr);
 909                 outb_p(EE_ASIC|EE_CS|EE_DI|dataval|EE_CK, ee_addr);
 910                 outb_p(EE_ASIC|EE_CS|EE_DI|dataval, ee_addr);
 911         }
 912         // sync
 913         outb(EE_ASIC|EE_CS, ee_addr);
 914         outb(EE_ASIC|EE_CS|EE_CK, ee_addr);
 915         outb(EE_ASIC|EE_CS, ee_addr);
 916
 917         for (i = 15; i >= 0; i--) {
 918                 dataval = (asic_data & (1 << i)) ? EE_ADOT : 0;
 919                 outb_p(EE_ASIC|EE_CS|dataval, ee_addr);
 920                 outb_p(EE_ASIC|EE_CS|dataval|EE_CK, ee_addr);
 921                 outb_p(EE_ASIC|EE_CS|dataval, ee_addr);
 922         }
 923
 924         /* Terminate the ASIC access. */
 925         outb(EE_ASIC|EE_DI, ee_addr);
 926         outb(EE_ASIC|EE_DI| EE_CK, ee_addr);
 927         outb(EE_ASIC|EE_DI, ee_addr);
 928
 929         outb(0, ee_addr);
 930 }
 931
 932 /*====================================================================*/
 933
 934 static void set_misc_reg(struct net_device *dev)
 935 {
 936     kio_addr_t nic_base = dev->base_addr;
 937     pcnet_dev_t *info = PRIV(dev);
 938     u_char tmp;
 939
 940     if (info->flags & HAS_MISC_REG) {
 941         tmp = inb_p(nic_base + PCNET_MISC) & ~3;
 942         if (dev->if_port == 2)
 943             tmp |= 1;
 944         if (info->flags & USE_BIG_BUF)
 945             tmp |= 2;
 946         if (info->flags & HAS_IBM_MISC)
 947             tmp |= 8;
 948         outb_p(tmp, nic_base + PCNET_MISC);
 949     }
 950     if (info->flags & IS_DL10022) {
 951         if (info->flags & HAS_MII) {
 952             mdio_reset(nic_base + DLINK_GPIO, info->eth_phy);
 953             /* Restart MII autonegotiation */
 954             mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
 955             mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
 956             info->mii_reset = jiffies;
 957         } else {
 958             outb(full_duplex ? 4 : 0, nic_base + DLINK_DIAG);
 959         }
 960     } else if (info->flags & IS_DL10019) {
 961         /* Advertise 100F, 100H, 10F, 10H */
 962         mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 4, 0x01e1);
 963         /* Restart MII autonegotiation */
 964         mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
 965         mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
 966     }
 967 }
 968
 969 /*====================================================================*/
 970
 971 static void mii_phy_probe(struct net_device *dev)
 972 {
 973     pcnet_dev_t *info = PRIV(dev);
 974     kio_addr_t mii_addr = dev->base_addr + DLINK_GPIO;
 975     int i;
 976     u_int tmp, phyid;
 977
 978     for (i = 31; i >= 0; i--) {
 979         tmp = mdio_read(mii_addr, i, 1);
 980         if ((tmp == 0) || (tmp == 0xffff))
 981             continue;
 982         tmp = mdio_read(mii_addr, i, MII_PHYID_REG1);
 983         phyid = tmp << 16;
 984         phyid |= mdio_read(mii_addr, i, MII_PHYID_REG2);
 985         phyid &= MII_PHYID_REV_MASK;
 986         DEBUG(0, "%s: MII at %d is 0x%08x\n", dev->name, i, phyid);
 987         if (phyid == AM79C9XX_HOME_PHY) {
 988             info->pna_phy = i;
 989         } else if (phyid != AM79C9XX_ETH_PHY) {
 990             info->eth_phy = i;
 991         }
 992     }
 993 }
 994
 995 static int pcnet_open(struct net_device *dev)
 996 {
 997     pcnet_dev_t *info = PRIV(dev);
 998     struct pcmcia_device *link = info->p_dev;
 999
1000     DEBUG(2, "pcnet_open('%s')\n", dev->name);
1001
1002     if (!DEV_OK(link))
1003         return -ENODEV;
1004
1005     link->open++;
1006
1007     set_misc_reg(dev);
1008     request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
1009
1010     info->phy_id = info->eth_phy;
1011     info->link_status = 0x00;
1012     init_timer(&info->watchdog);
1013     info->watchdog.function = &ei_watchdog;
1014     info->watchdog.data = (u_long)dev;
1015     info->watchdog.expires = jiffies + HZ;
1016     add_timer(&info->watchdog);
1017
1018     return ei_open(dev);
1019 } /* pcnet_open */
1020
1021 /*====================================================================*/
1022
1023 static int pcnet_close(struct net_device *dev)
1024 {
1025     pcnet_dev_t *info = PRIV(dev);
1026     struct pcmcia_device *link = info->p_dev;
1027
1028     DEBUG(2, "pcnet_close('%s')\n", dev->name);
1029
1030     ei_close(dev);
1031     free_irq(dev->irq, dev);
1032
1033     link->open--;
1034     netif_stop_queue(dev);
1035     del_timer_sync(&info->watchdog);
1036
1037     return 0;
1038 } /* pcnet_close */
1039
1040 /*======================================================================
1041
1042     Hard reset the card.  This used to pause for the same period that
1043     a 8390 reset command required, but that shouldn't be necessary.
1044
1045 ======================================================================*/
1046
1047 static void pcnet_reset_8390(struct net_device *dev)
1048 {
1049     kio_addr_t nic_base = dev->base_addr;
1050     int i;
1051
1052     ei_status.txing = ei_status.dmaing = 0;
1053
1054     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
1055
1056     outb(inb(nic_base + PCNET_RESET), nic_base + PCNET_RESET);
1057
1058     for (i = 0; i < 100; i++) {
1059         if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
1060             break;
1061         udelay(100);
1062     }
1063     outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
1064
1065     if (i == 100)
1066         printk(KERN_ERR "%s: pcnet_reset_8390() did not complete.\n",
1067                dev->name);
1068     set_misc_reg(dev);
1069
1070 } /* pcnet_reset_8390 */
1071
1072 /*====================================================================*/
1073
1074 static int set_config(struct net_device *dev, struct ifmap *map)
1075 {
1076     pcnet_dev_t *info = PRIV(dev);
1077     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1078         if (!(info->flags & HAS_MISC_REG))
1079             return -EOPNOTSUPP;
1080         else if ((map->port < 1) || (map->port > 2))
1081             return -EINVAL;
1082         dev->if_port = map->port;
1083         printk(KERN_INFO "%s: switched to %s port\n",
1084                dev->name, if_names[dev->if_port]);
1085         NS8390_init(dev, 1);
1086     }
1087     return 0;
1088 }
1089
1090 /*====================================================================*/
1091
1092 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs)
1093 {
1094     struct net_device *dev = dev_id;
1095     pcnet_dev_t *info;
1096     irqreturn_t ret = ei_interrupt(irq, dev_id, regs);
1097
1098     if (ret == IRQ_HANDLED) {
1099             info = PRIV(dev);
1100             info->stale = 0;
1101     }
1102     return ret;
1103 }
1104
1105 static void ei_watchdog(u_long arg)
1106 {
1107     struct net_device *dev = (struct net_device *)arg;
1108     pcnet_dev_t *info = PRIV(dev);
1109     kio_addr_t nic_base = dev->base_addr;
1110     kio_addr_t mii_addr = nic_base + DLINK_GPIO;
1111     u_short link;
1112
1113     if (!netif_device_present(dev)) goto reschedule;
1114
1115     /* Check for pending interrupt with expired latency timer: with
1116        this, we can limp along even if the interrupt is blocked */
1117     outb_p(E8390_NODMA+E8390_PAGE0, nic_base + E8390_CMD);
1118     if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
1119         if (!info->fast_poll)
1120             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1121         ei_irq_wrapper(dev->irq, dev, NULL);
1122         info->fast_poll = HZ;
1123     }
1124     if (info->fast_poll) {
1125         info->fast_poll--;
1126         info->watchdog.expires = jiffies + 1;
1127         add_timer(&info->watchdog);
1128         return;
1129     }
1130
1131     if (!(info->flags & HAS_MII))
1132         goto reschedule;
1133
1134     mdio_read(mii_addr, info->phy_id, 1);
1135     link = mdio_read(mii_addr, info->phy_id, 1);
1136     if (!link || (link == 0xffff)) {
1137         if (info->eth_phy) {
1138             info->phy_id = info->eth_phy = 0;
1139         } else {
1140             printk(KERN_INFO "%s: MII is missing!\n", dev->name);
1141             info->flags &= ~HAS_MII;
1142         }
1143         goto reschedule;
1144     }
1145
1146     link &= 0x0004;
1147     if (link != info->link_status) {
1148         u_short p = mdio_read(mii_addr, info->phy_id, 5);
1149         printk(KERN_INFO "%s: %s link beat\n", dev->name,
1150                (link) ? "found" : "lost");
1151         if (link && (info->flags & IS_DL10022)) {
1152             /* Disable collision detection on full duplex links */
1153             outb((p & 0x0140) ? 4 : 0, nic_base + DLINK_DIAG);
1154         } else if (link && (info->flags & IS_DL10019)) {
1155             /* Disable collision detection on full duplex links */
1156             write_asic(dev->base_addr, 4, (p & 0x140) ? DL19FDUPLX : 0);
1157         }
1158         if (link) {
1159             if (info->phy_id == info->eth_phy) {
1160                 if (p)
1161                     printk(KERN_INFO "%s: autonegotiation complete: "
1162                            "%sbaseT-%cD selected\n", dev->name,
1163                            ((p & 0x0180) ? "100" : "10"),
1164                            ((p & 0x0140) ? 'F' : 'H'));
1165                 else
1166                     printk(KERN_INFO "%s: link partner did not "
1167                            "autonegotiate\n", dev->name);
1168             }
1169             NS8390_init(dev, 1);
1170         }
1171         info->link_status = link;
1172     }
1173     if (info->pna_phy && time_after(jiffies, info->mii_reset + 6*HZ)) {
1174         link = mdio_read(mii_addr, info->eth_phy, 1) & 0x0004;
1175         if (((info->phy_id == info->pna_phy) && link) ||
1176             ((info->phy_id != info->pna_phy) && !link)) {
1177             /* isolate this MII and try flipping to the other one */
1178             mdio_write(mii_addr, info->phy_id, 0, 0x0400);
1179             info->phy_id ^= info->pna_phy ^ info->eth_phy;
1180             printk(KERN_INFO "%s: switched to %s transceiver\n", dev->name,
1181                    (info->phy_id == info->eth_phy) ? "ethernet" : "PNA");
1182             mdio_write(mii_addr, info->phy_id, 0,
1183                        (info->phy_id == info->eth_phy) ? 0x1000 : 0);
1184             info->link_status = 0;
1185             info->mii_reset = jiffies;
1186         }
1187     }
1188
1189 reschedule:
1190     info->watchdog.expires = jiffies + HZ;
1191     add_timer(&info->watchdog);
1192 }
1193
1194 /*====================================================================*/
1195
1196 static void netdev_get_drvinfo(struct net_device *dev,
1197                                struct ethtool_drvinfo *info)
1198 {
1199         strcpy(info->driver, "pcnet_cs");
1200 }
1201
1202 static struct ethtool_ops netdev_ethtool_ops = {
1203         .get_drvinfo            = netdev_get_drvinfo,
1204 };
1205
1206 /*====================================================================*/
1207
1208
1209 static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1210 {
1211     pcnet_dev_t *info = PRIV(dev);
1212     u16 *data = (u16 *)&rq->ifr_ifru;
1213     kio_addr_t mii_addr = dev->base_addr + DLINK_GPIO;
1214     switch (cmd) {
1215     case SIOCGMIIPHY:
1216         data[0] = info->phy_id;
1217     case SIOCGMIIREG:           /* Read MII PHY register. */
1218         data[3] = mdio_read(mii_addr, data[0], data[1] & 0x1f);
1219         return 0;
1220     case SIOCSMIIREG:           /* Write MII PHY register. */
1221         if (!capable(CAP_NET_ADMIN))
1222             return -EPERM;
1223         mdio_write(mii_addr, data[0], data[1] & 0x1f, data[2]);
1224         return 0;
1225     }
1226     return -EOPNOTSUPP;
1227 }
1228
1229 /*====================================================================*/
1230
1231 static void dma_get_8390_hdr(struct net_device *dev,
1232                              struct e8390_pkt_hdr *hdr,
1233                              int ring_page)
1234 {
1235     kio_addr_t nic_base = dev->base_addr;
1236
1237     if (ei_status.dmaing) {
1238         printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
1239                "[DMAstat:%1x][irqlock:%1x]\n",
1240                dev->name, ei_status.dmaing, ei_status.irqlock);
1241         return;
1242     }
1243
1244     ei_status.dmaing |= 0x01;
1245     outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1246     outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
1247     outb_p(0, nic_base + EN0_RCNTHI);
1248     outb_p(0, nic_base + EN0_RSARLO);           /* On page boundary */
1249     outb_p(ring_page, nic_base + EN0_RSARHI);
1250     outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1251
1252     insw(nic_base + PCNET_DATAPORT, hdr,
1253             sizeof(struct e8390_pkt_hdr)>>1);
1254     /* Fix for big endian systems */
1255     hdr->count = le16_to_cpu(hdr->count);
1256
1257     outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1258     ei_status.dmaing &= ~0x01;
1259 }
1260
1261 /*====================================================================*/
1262
1263 static void dma_block_input(struct net_device *dev, int count,
1264                             struct sk_buff *skb, int ring_offset)
1265 {
1266     kio_addr_t nic_base = dev->base_addr;
1267     int xfer_count = count;
1268     char *buf = skb->data;
1269
1270 #ifdef PCMCIA_DEBUG
1271     if ((ei_debug > 4) && (count != 4))
1272         printk(KERN_DEBUG "%s: [bi=%d]\n", dev->name, count+4);
1273 #endif
1274     if (ei_status.dmaing) {
1275         printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
1276                "[DMAstat:%1x][irqlock:%1x]\n",
1277                dev->name, ei_status.dmaing, ei_status.irqlock);
1278         return;
1279     }
1280     ei_status.dmaing |= 0x01;
1281     outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1282     outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1283     outb_p(count >> 8, nic_base + EN0_RCNTHI);
1284     outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
1285     outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
1286     outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1287
1288     insw(nic_base + PCNET_DATAPORT,buf,count>>1);
1289     if (count & 0x01)
1290         buf[count-1] = inb(nic_base + PCNET_DATAPORT), xfer_count++;
1291
1292     /* This was for the ALPHA version only, but enough people have been
1293        encountering problems that it is still here. */
1294 #ifdef PCMCIA_DEBUG
1295     if (ei_debug > 4) {         /* DMA termination address check... */
1296         int addr, tries = 20;
1297         do {
1298             /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
1299                -- it's broken for Rx on some cards! */
1300             int high = inb_p(nic_base + EN0_RSARHI);
1301             int low = inb_p(nic_base + EN0_RSARLO);
1302             addr = (high << 8) + low;
1303             if (((ring_offset + xfer_count) & 0xff) == (addr & 0xff))
1304                 break;
1305         } while (--tries > 0);
1306         if (tries <= 0)
1307             printk(KERN_NOTICE "%s: RX transfer address mismatch,"
1308                    "%#4.4x (expected) vs. %#4.4x (actual).\n",
1309                    dev->name, ring_offset + xfer_count, addr);
1310     }
1311 #endif
1312     outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1313     ei_status.dmaing &= ~0x01;
1314 } /* dma_block_input */
1315
1316 /*====================================================================*/
1317
1318 static void dma_block_output(struct net_device *dev, int count,
1319                              const u_char *buf, const int start_page)
1320 {
1321     kio_addr_t nic_base = dev->base_addr;
1322     pcnet_dev_t *info = PRIV(dev);
1323 #ifdef PCMCIA_DEBUG
1324     int retries = 0;
1325 #endif
1326     u_long dma_start;
1327
1328 #ifdef PCMCIA_DEBUG
1329     if (ei_debug > 4)
1330         printk(KERN_DEBUG "%s: [bo=%d]\n", dev->name, count);
1331 #endif
1332
1333     /* Round the count up for word writes.  Do we need to do this?
1334        What effect will an odd byte count have on the 8390?
1335        I should check someday. */
1336     if (count & 0x01)
1337         count++;
1338     if (ei_status.dmaing) {
1339         printk(KERN_NOTICE "%s: DMAing conflict in dma_block_output."
1340                "[DMAstat:%1x][irqlock:%1x]\n",
1341                dev->name, ei_status.dmaing, ei_status.irqlock);
1342         return;
1343     }
1344     ei_status.dmaing |= 0x01;
1345     /* We should already be in page 0, but to be safe... */
1346     outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base+PCNET_CMD);
1347
1348 #ifdef PCMCIA_DEBUG
1349   retry:
1350 #endif
1351
1352     outb_p(ENISR_RDC, nic_base + EN0_ISR);
1353
1354     /* Now the normal output. */
1355     outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1356     outb_p(count >> 8,   nic_base + EN0_RCNTHI);
1357     outb_p(0x00, nic_base + EN0_RSARLO);
1358     outb_p(start_page, nic_base + EN0_RSARHI);
1359
1360     outb_p(E8390_RWRITE+E8390_START, nic_base + PCNET_CMD);
1361     outsw(nic_base + PCNET_DATAPORT, buf, count>>1);
1362
1363     dma_start = jiffies;
1364
1365 #ifdef PCMCIA_DEBUG
1366     /* This was for the ALPHA version only, but enough people have been
1367        encountering problems that it is still here. */
1368     if (ei_debug > 4) { /* DMA termination address check... */
1369         int addr, tries = 20;
1370         do {
1371             int high = inb_p(nic_base + EN0_RSARHI);
1372             int low = inb_p(nic_base + EN0_RSARLO);
1373             addr = (high << 8) + low;
1374             if ((start_page << 8) + count == addr)
1375                 break;
1376         } while (--tries > 0);
1377         if (tries <= 0) {
1378             printk(KERN_NOTICE "%s: Tx packet transfer address mismatch,"
1379                    "%#4.4x (expected) vs. %#4.4x (actual).\n",
1380                    dev->name, (start_page << 8) + count, addr);
1381             if (retries++ == 0)
1382                 goto retry;
1383         }
1384     }
1385 #endif
1386
1387     while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
1388         if (time_after(jiffies, dma_start + PCNET_RDC_TIMEOUT)) {
1389             printk(KERN_NOTICE "%s: timeout waiting for Tx RDC.\n",
1390                    dev->name);
1391             pcnet_reset_8390(dev);
1392             NS8390_init(dev, 1);
1393             break;
1394         }
1395
1396     outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1397     if (info->flags & DELAY_OUTPUT)
1398         udelay((long)delay_time);
1399     ei_status.dmaing &= ~0x01;
1400 }
1401
1402 /*====================================================================*/
1403
1404 static int setup_dma_config(struct pcmcia_device *link, int start_pg,
1405                             int stop_pg)
1406 {
1407     struct net_device *dev = link->priv;
1408
1409     ei_status.tx_start_page = start_pg;
1410     ei_status.rx_start_page = start_pg + TX_PAGES;
1411     ei_status.stop_page = stop_pg;
1412
1413     /* set up block i/o functions */
1414     ei_status.get_8390_hdr = &dma_get_8390_hdr;
1415     ei_status.block_input = &dma_block_input;
1416     ei_status.block_output = &dma_block_output;
1417
1418     return 0;
1419 }
1420
1421 /*====================================================================*/
1422
1423 static void copyin(void *dest, void __iomem *src, int c)
1424 {
1425     u_short *d = dest;
1426     u_short __iomem *s = src;
1427     int odd;
1428
1429     if (c <= 0)
1430         return;
1431     odd = (c & 1); c >>= 1;
1432
1433     if (c) {
1434         do { *d++ = __raw_readw(s++); } while (--c);
1435     }
1436     /* get last byte by fetching a word and masking */
1437     if (odd)
1438         *((u_char *)d) = readw(s) & 0xff;
1439 }
1440
1441 static void copyout(void __iomem *dest, const void *src, int c)
1442 {
1443     u_short __iomem *d = dest;
1444     const u_short *s = src;
1445     int odd;
1446
1447     if (c <= 0)
1448         return;
1449     odd = (c & 1); c >>= 1;
1450
1451     if (c) {
1452         do { __raw_writew(*s++, d++); } while (--c);
1453     }
1454     /* copy last byte doing a read-modify-write */
1455     if (odd)
1456         writew((readw(d) & 0xff00) | *(u_char *)s, d);
1457 }
1458
1459 /*====================================================================*/
1460
1461 static void shmem_get_8390_hdr(struct net_device *dev,
1462                                struct e8390_pkt_hdr *hdr,
1463                                int ring_page)
1464 {
1465     void __iomem *xfer_start = ei_status.mem + (TX_PAGES<<8)
1466                                 + (ring_page << 8)
1467                                 - (ei_status.rx_start_page << 8);
1468
1469     copyin(hdr, xfer_start, sizeof(struct e8390_pkt_hdr));
1470     /* Fix for big endian systems */
1471     hdr->count = le16_to_cpu(hdr->count);
1472 }
1473
1474 /*====================================================================*/
1475
1476 static void shmem_block_input(struct net_device *dev, int count,
1477                               struct sk_buff *skb, int ring_offset)
1478 {
1479     void __iomem *base = ei_status.mem;
1480     unsigned long offset = (TX_PAGES<<8) + ring_offset
1481                                 - (ei_status.rx_start_page << 8);
1482     char *buf = skb->data;
1483
1484     if (offset + count > ei_status.priv) {
1485         /* We must wrap the input move. */
1486         int semi_count = ei_status.priv - offset;
1487         copyin(buf, base + offset, semi_count);
1488         buf += semi_count;
1489         offset = TX_PAGES<<8;
1490         count -= semi_count;
1491     }
1492     copyin(buf, base + offset, count);
1493 }
1494
1495 /*====================================================================*/
1496
1497 static void shmem_block_output(struct net_device *dev, int count,
1498                                const u_char *buf, const int start_page)
1499 {
1500     void __iomem *shmem = ei_status.mem + (start_page << 8);
1501     shmem -= ei_status.tx_start_page << 8;
1502     copyout(shmem, buf, count);
1503 }
1504
1505 /*====================================================================*/
1506
1507 static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
1508                               int stop_pg, int cm_offset)
1509 {
1510     struct net_device *dev = link->priv;
1511     pcnet_dev_t *info = PRIV(dev);
1512     win_req_t req;
1513     memreq_t mem;
1514     int i, window_size, offset, last_ret, last_fn;
1515
1516     window_size = (stop_pg - start_pg) << 8;
1517     if (window_size > 32 * 1024)
1518         window_size = 32 * 1024;
1519
1520     /* Make sure it's a power of two.  */
1521     while ((window_size & (window_size - 1)) != 0)
1522         window_size += window_size & ~(window_size - 1);
1523
1524     /* Allocate a memory window */
1525     req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
1526     req.Attributes |= WIN_USE_WAIT;
1527     req.Base = 0; req.Size = window_size;
1528     req.AccessSpeed = mem_speed;
1529     CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
1530
1531     mem.CardOffset = (start_pg << 8) + cm_offset;
1532     offset = mem.CardOffset % window_size;
1533     mem.CardOffset -= offset;
1534     mem.Page = 0;
1535     CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
1536
1537     /* Try scribbling on the buffer */
1538     info->base = ioremap(req.Base, window_size);
1539     for (i = 0; i < (TX_PAGES<<8); i += 2)
1540         __raw_writew((i>>1), info->base+offset+i);
1541     udelay(100);
1542     for (i = 0; i < (TX_PAGES<<8); i += 2)
1543         if (__raw_readw(info->base+offset+i) != (i>>1)) break;
1544     pcnet_reset_8390(dev);
1545     if (i != (TX_PAGES<<8)) {
1546         iounmap(info->base);
1547         pcmcia_release_window(link->win);
1548         info->base = NULL; link->win = NULL;
1549         goto failed;
1550     }
1551
1552     ei_status.mem = info->base + offset;
1553     ei_status.priv = req.Size;
1554     dev->mem_start = (u_long)ei_status.mem;
1555     dev->mem_end = dev->mem_start + req.Size;
1556
1557     ei_status.tx_start_page = start_pg;
1558     ei_status.rx_start_page = start_pg + TX_PAGES;
1559     ei_status.stop_page = start_pg + ((req.Size - offset) >> 8);
1560
1561     /* set up block i/o functions */
1562     ei_status.get_8390_hdr = &shmem_get_8390_hdr;
1563     ei_status.block_input = &shmem_block_input;
1564     ei_status.block_output = &shmem_block_output;
1565
1566     info->flags |= USE_SHMEM;
1567     return 0;
1568
1569 cs_failed:
1570     cs_error(link, last_fn, last_ret);
1571 failed:
1572     return 1;
1573 }
1574
1575 /*====================================================================*/
1576
1577 static struct pcmcia_device_id pcnet_ids[] = {
1578         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0057, 0x0021),
1579         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0104, 0x000a),
1580         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0xea15),
1581         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0x3341),
1582         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0xc0ab),
1583         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x021b, 0x0101),
1584         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x08a1, 0xc0ab),
1585         PCMCIA_PFC_DEVICE_PROD_ID12(0, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
1586         PCMCIA_PFC_DEVICE_PROD_ID12(0, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
1587         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
1588         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
1589         PCMCIA_PFC_DEVICE_PROD_ID12(0, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
1590         PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1591         PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
1592         PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
1593         PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
1594         PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
1595         PCMCIA_MFC_DEVICE_PROD_ID123(0, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
1596         PCMCIA_MFC_DEVICE_PROD_ID2(0, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
1597         PCMCIA_DEVICE_MANF_CARD(0x0057, 0x1004),
1598         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x000d),
1599         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0075),
1600         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0145),
1601         PCMCIA_DEVICE_MANF_CARD(0x0149, 0x0230),
1602         PCMCIA_DEVICE_MANF_CARD(0x0149, 0x4530),
1603 /*      PCMCIA_DEVICE_MANF_CARD(0x0149, 0xc1ab), conflict with axnet_cs */
1604         PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0110),
1605         PCMCIA_DEVICE_MANF_CARD(0x01bf, 0x2328),
1606         PCMCIA_DEVICE_MANF_CARD(0x01bf, 0x8041),
1607         PCMCIA_DEVICE_MANF_CARD(0x0213, 0x2452),
1608 /*      PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202), conflict with axnet_cs */
1609         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0300),
1610         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0307),
1611         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x030a),
1612         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1103),
1613         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1121),
1614         PCMCIA_DEVICE_PROD_ID12("2408LAN", "Ethernet", 0x352fff7f, 0x00b2e941),
1615         PCMCIA_DEVICE_PROD_ID123("Cardwell", "PCMCIA", "ETHERNET", 0x9533672e, 0x281f1c5d, 0x3ff7175b),
1616         PCMCIA_DEVICE_PROD_ID123("CNet  ", "CN30BC", "ETHERNET", 0x9fe55d3d, 0x85601198, 0x3ff7175b),
1617         PCMCIA_DEVICE_PROD_ID123("Digital", "Ethernet", "Adapter", 0x9999ab35, 0x00b2e941, 0x4b0d829e),
1618         PCMCIA_DEVICE_PROD_ID123("Edimax Technology Inc.", "PCMCIA", "Ethernet Card", 0x738a0019, 0x281f1c5d, 0x5e9d92c0),
1619         PCMCIA_DEVICE_PROD_ID123("EFA   ", "EFA207", "ETHERNET", 0x3d294be4, 0xeb9aab6c, 0x3ff7175b),
1620         PCMCIA_DEVICE_PROD_ID123("I-O DATA", "PCLA", "ETHERNET", 0x1d55d7ec, 0xe4c64d34, 0x3ff7175b),
1621         PCMCIA_DEVICE_PROD_ID123("IO DATA", "PCLATE", "ETHERNET", 0x547e66dc, 0x6b260753, 0x3ff7175b),
1622         PCMCIA_DEVICE_PROD_ID123("KingMax Technology Inc.", "EN10-T2", "PCMCIA Ethernet Card", 0x932b7189, 0x699e4436, 0x6f6652e0),
1623         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2216", 0x281f1c5d, 0xd4cd2f20, 0xb87add82),
1624         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2620", 0x281f1c5d, 0xd4cd2f20, 0x7d3d83a8),
1625         PCMCIA_DEVICE_PROD_ID1("2412LAN", 0x67f236ab),
1626         PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2212", 0xdfc6b5b2, 0xcb112a11),
1627         PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2216-PCMCIA-ETHERNET", 0xdfc6b5b2, 0x5542bfff),
1628         PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA100-PCM-T V2 100/10M LAN PC Card", 0xbb7fbdd7, 0xcd91cc68),
1629         PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA100-PCM V2", 0x36634a66, 0xc6d05997),
1630         PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA-PCM_V2", 0xbb7fBdd7, 0x28e299f8),
1631         PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA-PCM V3", 0x36634a66, 0x62241d96),
1632         PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8010", 0x5070a7f9, 0x82f96e96),
1633         PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8610", 0x5070a7f9, 0x86741224),
1634         PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002", 0x93b15570, 0x75ec3efb),
1635         PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002T", 0x93b15570, 0x461c5247),
1636         PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8010", 0x93b15570, 0x82f96e96),
1637         PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet", 0x578ba6e7, 0x0a9888c1),
1638         PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet 10/100", 0x578ba6e7, 0x939fedbd),
1639         PCMCIA_DEVICE_PROD_ID12("AROWANA", "PCMCIA Ethernet LAN Card", 0x313adbc8, 0x08d9f190),
1640         PCMCIA_DEVICE_PROD_ID12("ASANTE", "FriendlyNet PC Card", 0x3a7ade0f, 0x41c64504),
1641         PCMCIA_DEVICE_PROD_ID12("Billionton", "LNT-10TB", 0x552ab682, 0xeeb1ba6a),
1642         PCMCIA_DEVICE_PROD_ID12("CF", "10Base-Ethernet", 0x44ebf863, 0x93ae4d79),
1643         PCMCIA_DEVICE_PROD_ID12("CNet", "CN40BC Ethernet", 0xbc477dde, 0xfba775a7),
1644         PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "BASEline PCMCIA 10 MBit Ethernetadapter", 0xfa2e424d, 0xe9190d8a),
1645         PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "FASTline PCMCIA 10/100 Fast-Ethernet", 0xfa2e424d, 0x3953d9b9),
1646         PCMCIA_DEVICE_PROD_ID12("CONTEC", "C-NET(PC)C-10L", 0x21cab552, 0xf6f90722),
1647         PCMCIA_DEVICE_PROD_ID12("corega", "FEther PCC-TXF", 0x0a21501a, 0xa51564a2),
1648         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-T", 0x5261440f, 0xfa9d85bd),
1649         PCMCIA_DEVICE_PROD_ID12("Corega K.K.", "corega EtherII PCC-TD", 0xd4fdcbd8, 0xc49bd73d),
1650         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-T", 0x5261440f, 0x6705fcaa),
1651         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FastEther PCC-TX", 0x5261440f, 0x485e85d9),
1652         PCMCIA_DEVICE_PROD_ID12("Corega,K.K.", "Ethernet LAN Card", 0x110d26d9, 0x9fd2f0a2),
1653         PCMCIA_DEVICE_PROD_ID12("corega,K.K.", "Ethernet LAN Card", 0x9791a90e, 0x9fd2f0a2),
1654         PCMCIA_DEVICE_PROD_ID12("CouplerlessPCMCIA", "100BASE", 0xee5af0ad, 0x7c2add04),
1655         PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-010", 0x77008979, 0x9d8d445d),
1656         PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-110E 10/100M LAN Card", 0x77008979, 0xfd184814),
1657         PCMCIA_DEVICE_PROD_ID12("DataTrek.", "NetCard ", 0x5cd66d9d, 0x84697ce0),
1658         PCMCIA_DEVICE_PROD_ID12("Dayna Communications, Inc.", "CommuniCard E", 0x0c629325, 0xb4e7dbaf),
1659         PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100", 0x697403d8, 0xe160b995),
1660         PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100 Dongless", 0x697403d8, 0xa6d3b233),
1661         PCMCIA_DEVICE_PROD_ID12("DIGITAL", "DEPCM-XX", 0x69616cb3, 0xe600e76e),
1662         PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-650", 0x1a424a1c, 0xf28c8398),
1663         PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660", 0x1a424a1c, 0xd9a1d05b),
1664         PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660+", 0x1a424a1c, 0x50dcd0ec),
1665         PCMCIA_DEVICE_PROD_ID12("D-Link", "DFE-650", 0x1a424a1c, 0x0f0073f9),
1666         PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 PC Card", 0x725b842d, 0xf1efee84),
1667         PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 Port Attached PC Card", 0x725b842d, 0x2db1f8e9),
1668         PCMCIA_DEVICE_PROD_ID12("Dynalink", "L10BC", 0x55632fd5, 0xdc65f2b1),
1669         PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10BC", 0x6a26d1cf, 0xdc65f2b1),
1670         PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10C", 0x6a26d1cf, 0xc4f84efb),
1671         PCMCIA_DEVICE_PROD_ID12("E-CARD", "E-CARD", 0x6701da11, 0x6701da11),
1672         PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet 10BaseT card", 0x53c864c6, 0xedd059f6),
1673         PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet Combo card", 0x53c864c6, 0x929c486c),
1674         PCMCIA_DEVICE_PROD_ID12("Ethernet", "Adapter", 0x00b2e941, 0x4b0d829e),
1675         PCMCIA_DEVICE_PROD_ID12("Ethernet Adapter", "E2000 PCMCIA Ethernet", 0x96767301, 0x71fbbc61),
1676         PCMCIA_DEVICE_PROD_ID12("Ethernet PCMCIA adapter", "EP-210", 0x8dd86181, 0xf2b52517),
1677         PCMCIA_DEVICE_PROD_ID12("Fast Ethernet", "Adapter", 0xb4be14e3, 0x4b0d829e),
1678         PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2000", 0x2a151fac, 0xf00555cb),
1679         PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2220", 0x2a151fac, 0xc1b7e327),
1680         PCMCIA_DEVICE_PROD_ID12("GVC", "NIC-2000p", 0x76e171bd, 0x6eb1c947),
1681         PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "Ethernet", 0xe3736c88, 0x00b2e941),
1682         PCMCIA_DEVICE_PROD_ID12("IC-CARD", "IC-CARD", 0x60cb09a6, 0x60cb09a6),
1683         PCMCIA_DEVICE_PROD_ID12("IC-CARD+", "IC-CARD+", 0x93693494, 0x93693494),
1684         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCETTX", 0x547e66dc, 0x6fc5459b),
1685         PCMCIA_DEVICE_PROD_ID12("iPort", "10/100 Ethernet Card", 0x56c538d2, 0x11b0ffc0),
1686         PCMCIA_DEVICE_PROD_ID12("KANSAI ELECTRIC CO.,LTD", "KLA-PCM/T", 0xb18dc3b4, 0xcc51a956),
1687         PCMCIA_DEVICE_PROD_ID12("KCI", "PE520 PCMCIA Ethernet Adapter", 0xa89b87d3, 0x1eb88e64),
1688         PCMCIA_DEVICE_PROD_ID12("KINGMAX", "EN10T2T", 0x7bcb459a, 0xa5c81fa5),
1689         PCMCIA_DEVICE_PROD_ID12("Kingston", "KNE-PC2", 0x1128e633, 0xce2a89b3),
1690         PCMCIA_DEVICE_PROD_ID12("Kingston Technology Corp.", "EtheRx PC Card Ethernet Adapter", 0x313c7be3, 0x0afb54a2),
1691         PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-10/100CD", 0x1b7827b2, 0xcda71d1c),
1692         PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDF", 0x1b7827b2, 0xfec71e40),
1693         PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDL/T", 0x1b7827b2, 0x79fba4f7),
1694         PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDS", 0x1b7827b2, 0x931afaab),
1695         PCMCIA_DEVICE_PROD_ID12("Linksys", "Combo PCMCIA EthernetCard (EC2T)", 0x0733cc81, 0x32ee8c78),
1696         PCMCIA_DEVICE_PROD_ID12("LINKSYS", "E-CARD", 0xf7cb0b07, 0x6701da11),
1697         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 Integrated PC Card (PCM100)", 0x0733cc81, 0x453c3f9d),
1698         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100)", 0x0733cc81, 0x66c5a389),
1699         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V2)", 0x0733cc81, 0x3a3b28e9),
1700         PCMCIA_DEVICE_PROD_ID12("Linksys", "HomeLink Phoneline + 10/100 Network PC Card (PCM100H1)", 0x733cc81, 0x7a3e5c3a),
1701         PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TX", 0x88fcdeda, 0x6d772737),
1702         PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TE", 0x88fcdeda, 0x0e714bee),
1703         PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN20T", 0x88fcdeda, 0x81090922),
1704         PCMCIA_DEVICE_PROD_ID12("LONGSHINE", "PCMCIA Ethernet Card", 0xf866b0b0, 0x6f6652e0),
1705         PCMCIA_DEVICE_PROD_ID12("MACNICA", "ME1-JEIDA", 0x20841b68, 0xaf8a3578),
1706         PCMCIA_DEVICE_PROD_ID12("Macsense", "MPC-10", 0xd830297f, 0xd265c307),
1707         PCMCIA_DEVICE_PROD_ID12("Matsushita Electric Industrial Co.,LTD.", "CF-VEL211", 0x44445376, 0x8ded41d4),
1708         PCMCIA_DEVICE_PROD_ID12("MAXTECH", "PCN2000", 0x78d64bc0, 0xca0ca4b8),
1709         PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-T", 0x481e0094, 0xa2eb0cf3),
1710         PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-TX", 0x481e0094, 0x41a6916c),
1711         PCMCIA_DEVICE_PROD_ID12("Microcom C.E.", "Travel Card LAN 10/100", 0x4b91cec7, 0xe70220d6),
1712         PCMCIA_DEVICE_PROD_ID12("Microdyne", "NE4200", 0x2e6da59b, 0x0478e472),
1713         PCMCIA_DEVICE_PROD_ID12("MIDORI ELEC.", "LT-PCMT", 0x648d55c1, 0xbde526c7),
1714         PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover 4100", 0x36e1191f, 0x60c229b9),
1715         PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover NE4100", 0x36e1191f, 0xa6617ec8),
1716         PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J12", 0x18df0ba0, 0xbc912d76),
1717         PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA410TX", 0x9aa79dc3, 0x60e5bc0e),
1718         PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
1719         PCMCIA_DEVICE_PROD_ID12("Network Everywhere", "Fast Ethernet 10/100 PC Card", 0x820a67b6, 0x31ed1a5f),
1720         PCMCIA_DEVICE_PROD_ID12("NextCom K.K.", "Next Hawk", 0xaedaec74, 0xad050ef1),
1721         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100Mbps Ethernet Card", 0x281f1c5d, 0x6e41773b),
1722         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet", 0x281f1c5d, 0x00b2e941),
1723         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET", 0x281f1c5d, 0x3ff7175b),
1724         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet 10BaseT Card", 0x281f1c5d, 0x4de2f6c8),
1725         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Card", 0x281f1c5d, 0x5e9d92c0),
1726         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Combo card", 0x281f1c5d, 0x929c486c),
1727         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET V1.0", 0x281f1c5d, 0x4d8817c8),
1728         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEthernet", 0x281f1c5d, 0xfe871eeb),
1729         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast-Ethernet", 0x281f1c5d, 0x45f1f3b4),
1730         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FAST ETHERNET CARD", 0x281f1c5d, 0xec5dbca7),
1731         PCMCIA_DEVICE_PROD_ID12("PCMCIA LAN", "Ethernet", 0x7500e246, 0x00b2e941),
1732         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "LNT-10TN", 0x281f1c5d, 0xe707f641),
1733         PCMCIA_DEVICE_PROD_ID12("PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1734         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "UE2212", 0x281f1c5d, 0xbf17199b),
1735         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "    Ethernet NE2000 Compatible", 0x281f1c5d, 0x42d5d7e1),
1736         PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10baseT 3.3V", 0xebf91155, 0x30074c80),
1737         PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10BaseT 3.3V", 0xebf91155, 0x7f5a4f50),
1738         PCMCIA_DEVICE_PROD_ID12("Psion Dacom", "Gold Card Ethernet", 0xf5f025c2, 0x3a30e110),
1739         PCMCIA_DEVICE_PROD_ID12("=RELIA==", "Ethernet", 0xcdd0644a, 0x00b2e941),
1740         PCMCIA_DEVICE_PROD_ID12("RP", "1625B Ethernet NE2000 Compatible", 0xe3e66e22, 0xb96150df),
1741         PCMCIA_DEVICE_PROD_ID12("RPTI", "EP400 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4a7e2ae0),
1742         PCMCIA_DEVICE_PROD_ID12("RPTI", "EP401 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4bcbd7fd),
1743         PCMCIA_DEVICE_PROD_ID12("RPTI LTD.", "EP400", 0xc53ac515, 0x81e39388),
1744         PCMCIA_DEVICE_PROD_ID12("SCM", "Ethernet Combo card", 0xbdc3b102, 0x929c486c),
1745         PCMCIA_DEVICE_PROD_ID12("Seiko Epson Corp.", "Ethernet", 0x09928730, 0x00b2e941),
1746         PCMCIA_DEVICE_PROD_ID12("SMC", "EZCard-10-PCMCIA", 0xc4f8b18b, 0xfb21d265),
1747         PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision D", 0xc70a4760, 0x2ade483e),
1748         PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision E", 0xc70a4760, 0x5dd978a8),
1749         PCMCIA_DEVICE_PROD_ID12("TDK", "LAK-CD031 for PCMCIA", 0x1eae9475, 0x0ed386fa),
1750         PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE450T", 0x466b05f0, 0x8b74bc4f),
1751         PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE550T", 0x466b05f0, 0x33c8db2a),
1752         PCMCIA_DEVICE_PROD_ID13("Hypertec",  "EP401", 0x8787bec7, 0xf6e4a31e),
1753         PCMCIA_DEVICE_PROD_ID13("KingMax Technology Inc.", "Ethernet Card", 0x932b7189, 0x5e9d92c0),
1754         PCMCIA_DEVICE_PROD_ID13("LONGSHINE", "EP401", 0xf866b0b0, 0xf6e4a31e),
1755         PCMCIA_DEVICE_PROD_ID13("Xircom", "CFE-10", 0x2e3ee845, 0x22a49f89),
1756         PCMCIA_DEVICE_PROD_ID1("CyQ've 10 Base-T LAN CARD", 0x94faf360),
1757         PCMCIA_DEVICE_PROD_ID1("EP-210 PCMCIA LAN CARD.", 0x8850b4de),
1758         PCMCIA_DEVICE_PROD_ID1("ETHER-C16", 0x06a8514f),
1759         PCMCIA_DEVICE_PROD_ID1("IC-CARD", 0x60cb09a6),
1760         PCMCIA_DEVICE_PROD_ID1("NE2000 Compatible", 0x75b8ad5a),
1761         PCMCIA_DEVICE_PROD_ID2("EN-6200P2", 0xa996d078),
1762         /* too generic! */
1763         /* PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100 Ethernet Card", 0x281f1c5d, 0x11b0ffc0), */
1764         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
1765         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
1766         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
1767         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
1768         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
1769         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(0, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
1770         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
1771         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "DP83903.cis"),
1772         PCMCIA_DEVICE_CIS_MANF_CARD(0xc00f, 0x0002, "LA-PCM.cis"),
1773         PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "PE520.cis"),
1774         PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "NE2K.cis"),
1775         PCMCIA_DEVICE_CIS_PROD_ID12("PMX   ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "PE-200.cis"),
1776         PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "tamarack.cis"),
1777         PCMCIA_DEVICE_NULL
1778 };
1779 MODULE_DEVICE_TABLE(pcmcia, pcnet_ids);
1780
1781 static struct pcmcia_driver pcnet_driver = {
1782         .drv            = {
1783                 .name   = "pcnet_cs",
1784         },
1785         .probe          = pcnet_probe,
1786         .remove         = pcnet_detach,
1787         .owner          = THIS_MODULE,
1788         .id_table       = pcnet_ids,
1789         .suspend        = pcnet_suspend,
1790         .resume         = pcnet_resume,
1791 };
1792
1793 static int __init init_pcnet_cs(void)
1794 {
1795     return pcmcia_register_driver(&pcnet_driver);
1796 }
1797
1798 static void __exit exit_pcnet_cs(void)
1799 {
1800     DEBUG(0, "pcnet_cs: unloading\n");
1801     pcmcia_unregister_driver(&pcnet_driver);
1802 }
1803
1804 module_init(init_pcnet_cs);
1805 module_exit(exit_pcnet_cs);