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