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