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