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