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 <linux/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"};
  69
  70/*====================================================================*/
  71
  72/* Module parameters */
  73
  74MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  75MODULE_DESCRIPTION("NE2000 compatible PCMCIA ethernet driver");
  76MODULE_LICENSE("GPL");
  77
  78#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  79
  80INT_MODULE_PARM(if_port,        1);     /* Transceiver type */
  81INT_MODULE_PARM(use_big_buf,    1);     /* use 64K packet buffer? */
  82INT_MODULE_PARM(mem_speed,      0);     /* shared mem speed, in ns */
  83INT_MODULE_PARM(delay_output,   0);     /* pause after xmit? */
  84INT_MODULE_PARM(delay_time,     4);     /* in usec */
  85INT_MODULE_PARM(use_shmem,      -1);    /* use shared memory? */
  86INT_MODULE_PARM(full_duplex,    0);     /* full duplex? */
  87
  88/* Ugh!  Let the user hardwire the hardware address for queer cards */
  89static int hw_addr[6] = { 0, /* ... */ };
  90module_param_array(hw_addr, int, NULL, 0);
  91
  92/*====================================================================*/
  93
  94static void mii_phy_probe(struct net_device *dev);
  95static int pcnet_config(struct pcmcia_device *link);
  96static void pcnet_release(struct pcmcia_device *link);
  97static int pcnet_open(struct net_device *dev);
  98static int pcnet_close(struct net_device *dev);
  99static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 100static irqreturn_t ei_irq_wrapper(int irq, void *dev_id);
 101static void ei_watchdog(struct timer_list *t);
 102static void pcnet_reset_8390(struct net_device *dev);
 103static int set_config(struct net_device *dev, struct ifmap *map);
 104static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
 105                              int stop_pg, int cm_offset);
 106static int setup_dma_config(struct pcmcia_device *link, int start_pg,
 107                            int stop_pg);
 108
 109static void pcnet_detach(struct pcmcia_device *p_dev);
 110
 111/*====================================================================*/
 112
 113struct hw_info {
 114    u_int       offset;
 115    u_char      a0, a1, a2;
 116    u_int       flags;
 117};
 118
 119#define DELAY_OUTPUT    0x01
 120#define HAS_MISC_REG    0x02
 121#define USE_BIG_BUF     0x04
 122#define HAS_IBM_MISC    0x08
 123#define IS_DL10019      0x10
 124#define IS_DL10022      0x20
 125#define HAS_MII         0x40
 126#define USE_SHMEM       0x80    /* autodetected */
 127
 128#define AM79C9XX_HOME_PHY       0x00006B90  /* HomePNA PHY */
 129#define AM79C9XX_ETH_PHY        0x00006B70  /* 10baseT PHY */
 130#define MII_PHYID_REV_MASK      0xfffffff0
 131#define MII_PHYID_REG1          0x02
 132#define MII_PHYID_REG2          0x03
 133
 134static struct hw_info hw_info[] = {
 135    { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
 136    { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
 137    { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
 138    { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
 139      DELAY_OUTPUT | HAS_IBM_MISC },
 140    { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
 141    { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
 142    { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
 143    { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
 144    { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
 145    { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
 146    { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
 147      HAS_MISC_REG | HAS_IBM_MISC },
 148    { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
 149    { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
 150    { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
 151      HAS_MISC_REG | HAS_IBM_MISC },
 152    { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
 153      HAS_MISC_REG | HAS_IBM_MISC },
 154    { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
 155      HAS_MISC_REG | HAS_IBM_MISC },
 156    { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
 157      HAS_MISC_REG | HAS_IBM_MISC },
 158    { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
 159      HAS_MISC_REG | HAS_IBM_MISC },
 160    { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
 161      HAS_MISC_REG | HAS_IBM_MISC },
 162    { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
 163      HAS_MISC_REG | HAS_IBM_MISC },
 164    { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
 165      HAS_MISC_REG | HAS_IBM_MISC },
 166    { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
 167      HAS_MISC_REG | HAS_IBM_MISC },
 168    { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
 169      HAS_MISC_REG | HAS_IBM_MISC },
 170    { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
 171    { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
 172    { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
 173      HAS_MISC_REG | HAS_IBM_MISC },
 174    { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
 175      HAS_MISC_REG | HAS_IBM_MISC },
 176    { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
 177    { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
 178    { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
 179    { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
 180    { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
 181      HAS_MISC_REG | HAS_IBM_MISC },
 182    { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45,
 183      HAS_MISC_REG | HAS_IBM_MISC },
 184    { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
 185    { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
 186    { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
 187    { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
 188      DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
 189    { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 },
 190    { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
 191    { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
 192    { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
 193    { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }
 194};
 195
 196#define NR_INFO         ARRAY_SIZE(hw_info)
 197
 198static struct hw_info default_info = { 0, 0, 0, 0, 0 };
 199static struct hw_info dl10019_info = { 0, 0, 0, 0, IS_DL10019|HAS_MII };
 200static struct hw_info dl10022_info = { 0, 0, 0, 0, IS_DL10022|HAS_MII };
 201
 202struct pcnet_dev {
 203        struct pcmcia_device    *p_dev;
 204    u_int               flags;
 205    void                __iomem *base;
 206    struct timer_list   watchdog;
 207    int                 stale, fast_poll;
 208    u_char              phy_id;
 209    u_char              eth_phy, pna_phy;
 210    u_short             link_status;
 211    u_long              mii_reset;
 212};
 213
 214static inline struct pcnet_dev *PRIV(struct net_device *dev)
 215{
 216        char *p = netdev_priv(dev);
 217        return (struct pcnet_dev *)(p + sizeof(struct ei_device));
 218}
 219
 220static const struct net_device_ops pcnet_netdev_ops = {
 221        .ndo_open               = pcnet_open,
 222        .ndo_stop               = pcnet_close,
 223        .ndo_set_config         = set_config,
 224        .ndo_start_xmit         = ei_start_xmit,
 225        .ndo_get_stats          = ei_get_stats,
 226        .ndo_do_ioctl           = ei_ioctl,
 227        .ndo_set_rx_mode        = ei_set_multicast_list,
 228        .ndo_tx_timeout         = ei_tx_timeout,
 229        .ndo_set_mac_address    = eth_mac_addr,
 230        .ndo_validate_addr      = eth_validate_addr,
 231#ifdef CONFIG_NET_POLL_CONTROLLER
 232        .ndo_poll_controller    = ei_poll,
 233#endif
 234};
 235
 236static int pcnet_probe(struct pcmcia_device *link)
 237{
 238    struct pcnet_dev *info;
 239    struct net_device *dev;
 240
 241    dev_dbg(&link->dev, "pcnet_attach()\n");
 242
 243    /* Create new ethernet device */
 244    dev = __alloc_ei_netdev(sizeof(struct pcnet_dev));
 245    if (!dev) return -ENOMEM;
 246    info = PRIV(dev);
 247    info->p_dev = link;
 248    link->priv = dev;
 249
 250    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 251
 252    dev->netdev_ops = &pcnet_netdev_ops;
 253
 254    return pcnet_config(link);
 255} /* pcnet_attach */
 256
 257static void pcnet_detach(struct pcmcia_device *link)
 258{
 259        struct net_device *dev = link->priv;
 260
 261        dev_dbg(&link->dev, "pcnet_detach\n");
 262
 263        unregister_netdev(dev);
 264
 265        pcnet_release(link);
 266
 267        free_netdev(dev);
 268} /* pcnet_detach */
 269
 270/*======================================================================
 271
 272    This probes for a card's hardware address, for card types that
 273    encode this information in their CIS.
 274
 275======================================================================*/
 276
 277static struct hw_info *get_hwinfo(struct pcmcia_device *link)
 278{
 279    struct net_device *dev = link->priv;
 280    u_char __iomem *base, *virt;
 281    int i, j;
 282
 283    /* Allocate a small memory window */
 284    link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 285    link->resource[2]->start = 0; link->resource[2]->end = 0;
 286    i = pcmcia_request_window(link, link->resource[2], 0);
 287    if (i != 0)
 288        return NULL;
 289
 290    virt = ioremap(link->resource[2]->start,
 291            resource_size(link->resource[2]));
 292    if (unlikely(!virt)) {
 293            pcmcia_release_window(link, link->resource[2]);
 294            return NULL;
 295    }
 296
 297    for (i = 0; i < NR_INFO; i++) {
 298        pcmcia_map_mem_page(link, link->resource[2],
 299                hw_info[i].offset & ~(resource_size(link->resource[2])-1));
 300        base = &virt[hw_info[i].offset & (resource_size(link->resource[2])-1)];
 301        if ((readb(base+0) == hw_info[i].a0) &&
 302            (readb(base+2) == hw_info[i].a1) &&
 303            (readb(base+4) == hw_info[i].a2)) {
 304                for (j = 0; j < 6; j++)
 305                    dev->dev_addr[j] = readb(base + (j<<1));
 306                break;
 307        }
 308    }
 309
 310    iounmap(virt);
 311    j = pcmcia_release_window(link, link->resource[2]);
 312    return (i < NR_INFO) ? hw_info+i : NULL;
 313} /* get_hwinfo */
 314
 315/*======================================================================
 316
 317    This probes for a card's hardware address by reading the PROM.
 318    It checks the address against a list of known types, then falls
 319    back to a simple NE2000 clone signature check.
 320
 321======================================================================*/
 322
 323static struct hw_info *get_prom(struct pcmcia_device *link)
 324{
 325    struct net_device *dev = link->priv;
 326    unsigned int ioaddr = dev->base_addr;
 327    u_char prom[32];
 328    int i, j;
 329
 330    /* This is lifted straight from drivers/net/ethernet/8390/ne.c */
 331    struct {
 332        u_char value, offset;
 333    } program_seq[] = {
 334        {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 335        {0x48,  EN0_DCFG},      /* Set byte-wide (0x48) access. */
 336        {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 337        {0x00,  EN0_RCNTHI},
 338        {0x00,  EN0_IMR},       /* Mask completion irq. */
 339        {0xFF,  EN0_ISR},
 340        {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 341        {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 342        {32,    EN0_RCNTLO},
 343        {0x00,  EN0_RCNTHI},
 344        {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 345        {0x00,  EN0_RSARHI},
 346        {E8390_RREAD+E8390_START, E8390_CMD},
 347    };
 348
 349    pcnet_reset_8390(dev);
 350    mdelay(10);
 351
 352    for (i = 0; i < ARRAY_SIZE(program_seq); i++)
 353        outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
 354
 355    for (i = 0; i < 32; i++)
 356        prom[i] = inb(ioaddr + PCNET_DATAPORT);
 357    for (i = 0; i < NR_INFO; i++) {
 358        if ((prom[0] == hw_info[i].a0) &&
 359            (prom[2] == hw_info[i].a1) &&
 360            (prom[4] == hw_info[i].a2))
 361            break;
 362    }
 363    if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
 364        for (j = 0; j < 6; j++)
 365            dev->dev_addr[j] = prom[j<<1];
 366        return (i < NR_INFO) ? hw_info+i : &default_info;
 367    }
 368    return NULL;
 369} /* get_prom */
 370
 371/*======================================================================
 372
 373    For DL10019 based cards, like the Linksys EtherFast
 374
 375======================================================================*/
 376
 377static struct hw_info *get_dl10019(struct pcmcia_device *link)
 378{
 379    struct net_device *dev = link->priv;
 380    int i;
 381    u_char sum;
 382
 383    for (sum = 0, i = 0x14; i < 0x1c; i++)
 384        sum += inb_p(dev->base_addr + i);
 385    if (sum != 0xff)
 386        return NULL;
 387    for (i = 0; i < 6; i++)
 388        dev->dev_addr[i] = inb_p(dev->base_addr + 0x14 + i);
 389    i = inb(dev->base_addr + 0x1f);
 390    return ((i == 0x91)||(i == 0x99)) ? &dl10022_info : &dl10019_info;
 391}
 392
 393/*======================================================================
 394
 395    For Asix AX88190 based cards
 396
 397======================================================================*/
 398
 399static struct hw_info *get_ax88190(struct pcmcia_device *link)
 400{
 401    struct net_device *dev = link->priv;
 402    unsigned int ioaddr = dev->base_addr;
 403    int i, j;
 404
 405    /* Not much of a test, but the alternatives are messy */
 406    if (link->config_base != 0x03c0)
 407        return NULL;
 408
 409    outb_p(0x01, ioaddr + EN0_DCFG);    /* Set word-wide access. */
 410    outb_p(0x00, ioaddr + EN0_RSARLO);  /* DMA starting at 0x0400. */
 411    outb_p(0x04, ioaddr + EN0_RSARHI);
 412    outb_p(E8390_RREAD+E8390_START, ioaddr + E8390_CMD);
 413
 414    for (i = 0; i < 6; i += 2) {
 415        j = inw(ioaddr + PCNET_DATAPORT);
 416        dev->dev_addr[i] = j & 0xff;
 417        dev->dev_addr[i+1] = j >> 8;
 418    }
 419    return NULL;
 420}
 421
 422/*======================================================================
 423
 424    This should be totally unnecessary... but when we can't figure
 425    out the hardware address any other way, we'll let the user hard
 426    wire it when the module is initialized.
 427
 428======================================================================*/
 429
 430static struct hw_info *get_hwired(struct pcmcia_device *link)
 431{
 432    struct net_device *dev = link->priv;
 433    int i;
 434
 435    for (i = 0; i < 6; i++)
 436        if (hw_addr[i] != 0) break;
 437    if (i == 6)
 438        return NULL;
 439
 440    for (i = 0; i < 6; i++)
 441        dev->dev_addr[i] = hw_addr[i];
 442
 443    return &default_info;
 444} /* get_hwired */
 445
 446static int try_io_port(struct pcmcia_device *link)
 447{
 448    int j, ret;
 449    link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 450    link->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
 451    if (link->resource[0]->end == 32) {
 452        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 453        if (link->resource[1]->end > 0) {
 454            /* for master/slave multifunction cards */
 455            link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 456        }
 457    } else {
 458        /* This should be two 16-port windows */
 459        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 460        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
 461    }
 462    if (link->resource[0]->start == 0) {
 463        for (j = 0; j < 0x400; j += 0x20) {
 464            link->resource[0]->start = j ^ 0x300;
 465            link->resource[1]->start = (j ^ 0x300) + 0x10;
 466            link->io_lines = 16;
 467            ret = pcmcia_request_io(link);
 468            if (ret == 0)
 469                    return ret;
 470        }
 471        return ret;
 472    } else {
 473        return pcmcia_request_io(link);
 474    }
 475}
 476
 477static int pcnet_confcheck(struct pcmcia_device *p_dev, void *priv_data)
 478{
 479        int *priv = priv_data;
 480        int try = (*priv & 0x1);
 481
 482        *priv &= (p_dev->resource[2]->end >= 0x4000) ? 0x10 : ~0x10;
 483
 484        if (p_dev->config_index == 0)
 485                return -EINVAL;
 486
 487        if (p_dev->resource[0]->end + p_dev->resource[1]->end < 32)
 488                return -EINVAL;
 489
 490        if (try)
 491                p_dev->io_lines = 16;
 492        return try_io_port(p_dev);
 493}
 494
 495static struct hw_info *pcnet_try_config(struct pcmcia_device *link,
 496                                        int *has_shmem, int try)
 497{
 498        struct net_device *dev = link->priv;
 499        struct hw_info *local_hw_info;
 500        struct pcnet_dev *info = PRIV(dev);
 501        int priv = try;
 502        int ret;
 503
 504        ret = pcmcia_loop_config(link, pcnet_confcheck, &priv);
 505        if (ret) {
 506                dev_warn(&link->dev, "no useable port range found\n");
 507                return NULL;
 508        }
 509        *has_shmem = (priv & 0x10);
 510
 511        if (!link->irq)
 512                return NULL;
 513
 514        if (resource_size(link->resource[1]) == 8)
 515                link->config_flags |= CONF_ENABLE_SPKR;
 516
 517        if ((link->manf_id == MANFID_IBM) &&
 518            (link->card_id == PRODID_IBM_HOME_AND_AWAY))
 519                link->config_index |= 0x10;
 520
 521        ret = pcmcia_enable_device(link);
 522        if (ret)
 523                return NULL;
 524
 525        dev->irq = link->irq;
 526        dev->base_addr = link->resource[0]->start;
 527
 528        if (info->flags & HAS_MISC_REG) {
 529                if ((if_port == 1) || (if_port == 2))
 530                        dev->if_port = if_port;
 531                else
 532                        dev_notice(&link->dev, "invalid if_port requested\n");
 533        } else
 534                dev->if_port = 0;
 535
 536        if ((link->config_base == 0x03c0) &&
 537            (link->manf_id == 0x149) && (link->card_id == 0xc1ab)) {
 538                dev_info(&link->dev,
 539                        "this is an AX88190 card - use axnet_cs instead.\n");
 540                return NULL;
 541        }
 542
 543        local_hw_info = get_hwinfo(link);
 544        if (!local_hw_info)
 545                local_hw_info = get_prom(link);
 546        if (!local_hw_info)
 547                local_hw_info = get_dl10019(link);
 548        if (!local_hw_info)
 549                local_hw_info = get_ax88190(link);
 550        if (!local_hw_info)
 551                local_hw_info = get_hwired(link);
 552
 553        return local_hw_info;
 554}
 555
 556static int pcnet_config(struct pcmcia_device *link)
 557{
 558    struct net_device *dev = link->priv;
 559    struct pcnet_dev *info = PRIV(dev);
 560    int start_pg, stop_pg, cm_offset;
 561    int has_shmem = 0;
 562    struct hw_info *local_hw_info;
 563
 564    dev_dbg(&link->dev, "pcnet_config\n");
 565
 566    local_hw_info = pcnet_try_config(link, &has_shmem, 0);
 567    if (!local_hw_info) {
 568            /* check whether forcing io_lines to 16 helps... */
 569            pcmcia_disable_device(link);
 570            local_hw_info = pcnet_try_config(link, &has_shmem, 1);
 571            if (local_hw_info == NULL) {
 572                    dev_notice(&link->dev, "unable to read hardware net"
 573                            " address for io base %#3lx\n", dev->base_addr);
 574                    goto failed;
 575            }
 576    }
 577
 578    info->flags = local_hw_info->flags;
 579    /* Check for user overrides */
 580    info->flags |= (delay_output) ? DELAY_OUTPUT : 0;
 581    if ((link->manf_id == MANFID_SOCKET) &&
 582        ((link->card_id == PRODID_SOCKET_LPE) ||
 583         (link->card_id == PRODID_SOCKET_LPE_CF) ||
 584         (link->card_id == PRODID_SOCKET_EIO)))
 585        info->flags &= ~USE_BIG_BUF;
 586    if (!use_big_buf)
 587        info->flags &= ~USE_BIG_BUF;
 588
 589    if (info->flags & USE_BIG_BUF) {
 590        start_pg = SOCKET_START_PG;
 591        stop_pg = SOCKET_STOP_PG;
 592        cm_offset = 0x10000;
 593    } else {
 594        start_pg = PCNET_START_PG;
 595        stop_pg = PCNET_STOP_PG;
 596        cm_offset = 0;
 597    }
 598
 599    /* has_shmem is ignored if use_shmem != -1 */
 600    if ((use_shmem == 0) || (!has_shmem && (use_shmem == -1)) ||
 601        (setup_shmem_window(link, start_pg, stop_pg, cm_offset) != 0))
 602        setup_dma_config(link, start_pg, stop_pg);
 603
 604    ei_status.name = "NE2000";
 605    ei_status.word16 = 1;
 606    ei_status.reset_8390 = pcnet_reset_8390;
 607
 608    if (info->flags & (IS_DL10019|IS_DL10022))
 609        mii_phy_probe(dev);
 610
 611    SET_NETDEV_DEV(dev, &link->dev);
 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    timer_setup(&info->watchdog, ei_watchdog, 0);
 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(struct timer_list *t)
1011{
1012    struct pcnet_dev *info = from_timer(info, t, watchdog);
1013    struct net_device *dev = info->p_dev->priv;
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        fallthrough;
1112    case SIOCGMIIREG:           /* Read MII PHY register. */
1113        data->val_out = mdio_read(mii_addr, data->phy_id, data->reg_num & 0x1f);
1114        return 0;
1115    case SIOCSMIIREG:           /* Write MII PHY register. */
1116        mdio_write(mii_addr, data->phy_id, data->reg_num & 0x1f, data->val_in);
1117        return 0;
1118    }
1119    return -EOPNOTSUPP;
1120}
1121
1122/*====================================================================*/
1123
1124static void dma_get_8390_hdr(struct net_device *dev,
1125                             struct e8390_pkt_hdr *hdr,
1126                             int ring_page)
1127{
1128    unsigned int nic_base = dev->base_addr;
1129
1130    if (ei_status.dmaing) {
1131        netdev_err(dev, "DMAing conflict in dma_block_input."
1132                   "[DMAstat:%1x][irqlock:%1x]\n",
1133                   ei_status.dmaing, ei_status.irqlock);
1134        return;
1135    }
1136
1137    ei_status.dmaing |= 0x01;
1138    outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1139    outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
1140    outb_p(0, nic_base + EN0_RCNTHI);
1141    outb_p(0, nic_base + EN0_RSARLO);           /* On page boundary */
1142    outb_p(ring_page, nic_base + EN0_RSARHI);
1143    outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1144
1145    insw(nic_base + PCNET_DATAPORT, hdr,
1146            sizeof(struct e8390_pkt_hdr)>>1);
1147    /* Fix for big endian systems */
1148    hdr->count = le16_to_cpu(hdr->count);
1149
1150    outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1151    ei_status.dmaing &= ~0x01;
1152}
1153
1154/*====================================================================*/
1155
1156static void dma_block_input(struct net_device *dev, int count,
1157                            struct sk_buff *skb, int ring_offset)
1158{
1159    unsigned int nic_base = dev->base_addr;
1160    int xfer_count = count;
1161    char *buf = skb->data;
1162    struct ei_device *ei_local = netdev_priv(dev);
1163
1164    if ((netif_msg_rx_status(ei_local)) && (count != 4))
1165        netdev_dbg(dev, "[bi=%d]\n", count+4);
1166    if (ei_status.dmaing) {
1167        netdev_err(dev, "DMAing conflict in dma_block_input."
1168                   "[DMAstat:%1x][irqlock:%1x]\n",
1169                   ei_status.dmaing, ei_status.irqlock);
1170        return;
1171    }
1172    ei_status.dmaing |= 0x01;
1173    outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1174    outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1175    outb_p(count >> 8, nic_base + EN0_RCNTHI);
1176    outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
1177    outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
1178    outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1179
1180    insw(nic_base + PCNET_DATAPORT,buf,count>>1);
1181    if (count & 0x01) {
1182        buf[count-1] = inb(nic_base + PCNET_DATAPORT);
1183        xfer_count++;
1184    }
1185
1186    /* This was for the ALPHA version only, but enough people have been
1187       encountering problems that it is still here. */
1188#ifdef PCMCIA_DEBUG
1189      /* DMA termination address check... */
1190    if (netif_msg_rx_status(ei_local)) {
1191        int addr, tries = 20;
1192        do {
1193            /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
1194               -- it's broken for Rx on some cards! */
1195            int high = inb_p(nic_base + EN0_RSARHI);
1196            int low = inb_p(nic_base + EN0_RSARLO);
1197            addr = (high << 8) + low;
1198            if (((ring_offset + xfer_count) & 0xff) == (addr & 0xff))
1199                break;
1200        } while (--tries > 0);
1201        if (tries <= 0)
1202            netdev_notice(dev, "RX transfer address mismatch,"
1203                          "%#4.4x (expected) vs. %#4.4x (actual).\n",
1204                          ring_offset + xfer_count, addr);
1205    }
1206#endif
1207    outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1208    ei_status.dmaing &= ~0x01;
1209} /* dma_block_input */
1210
1211/*====================================================================*/
1212
1213static void dma_block_output(struct net_device *dev, int count,
1214                             const u_char *buf, const int start_page)
1215{
1216    unsigned int nic_base = dev->base_addr;
1217    struct pcnet_dev *info = PRIV(dev);
1218#ifdef PCMCIA_DEBUG
1219    int retries = 0;
1220    struct ei_device *ei_local = netdev_priv(dev);
1221#endif
1222    u_long dma_start;
1223
1224#ifdef PCMCIA_DEBUG
1225    netif_dbg(ei_local, tx_queued, dev, "[bo=%d]\n", count);
1226#endif
1227
1228    /* Round the count up for word writes.  Do we need to do this?
1229       What effect will an odd byte count have on the 8390?
1230       I should check someday. */
1231    if (count & 0x01)
1232        count++;
1233    if (ei_status.dmaing) {
1234        netdev_err(dev, "DMAing conflict in dma_block_output."
1235                   "[DMAstat:%1x][irqlock:%1x]\n",
1236                   ei_status.dmaing, ei_status.irqlock);
1237        return;
1238    }
1239    ei_status.dmaing |= 0x01;
1240    /* We should already be in page 0, but to be safe... */
1241    outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base+PCNET_CMD);
1242
1243#ifdef PCMCIA_DEBUG
1244  retry:
1245#endif
1246
1247    outb_p(ENISR_RDC, nic_base + EN0_ISR);
1248
1249    /* Now the normal output. */
1250    outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1251    outb_p(count >> 8,   nic_base + EN0_RCNTHI);
1252    outb_p(0x00, nic_base + EN0_RSARLO);
1253    outb_p(start_page, nic_base + EN0_RSARHI);
1254
1255    outb_p(E8390_RWRITE+E8390_START, nic_base + PCNET_CMD);
1256    outsw(nic_base + PCNET_DATAPORT, buf, count>>1);
1257
1258    dma_start = jiffies;
1259
1260#ifdef PCMCIA_DEBUG
1261    /* This was for the ALPHA version only, but enough people have been
1262       encountering problems that it is still here. */
1263    /* DMA termination address check... */
1264    if (netif_msg_tx_queued(ei_local)) {
1265        int addr, tries = 20;
1266        do {
1267            int high = inb_p(nic_base + EN0_RSARHI);
1268            int low = inb_p(nic_base + EN0_RSARLO);
1269            addr = (high << 8) + low;
1270            if ((start_page << 8) + count == addr)
1271                break;
1272        } while (--tries > 0);
1273        if (tries <= 0) {
1274            netdev_notice(dev, "Tx packet transfer address mismatch,"
1275                          "%#4.4x (expected) vs. %#4.4x (actual).\n",
1276                          (start_page << 8) + count, addr);
1277            if (retries++ == 0)
1278                goto retry;
1279        }
1280    }
1281#endif
1282
1283    while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
1284        if (time_after(jiffies, dma_start + PCNET_RDC_TIMEOUT)) {
1285                netdev_warn(dev, "timeout waiting for Tx RDC.\n");
1286                pcnet_reset_8390(dev);
1287                NS8390_init(dev, 1);
1288                break;
1289        }
1290
1291    outb_p(ENISR_RDC, nic_base + EN0_ISR);      /* Ack intr. */
1292    if (info->flags & DELAY_OUTPUT)
1293        udelay((long)delay_time);
1294    ei_status.dmaing &= ~0x01;
1295}
1296
1297/*====================================================================*/
1298
1299static int setup_dma_config(struct pcmcia_device *link, int start_pg,
1300                            int stop_pg)
1301{
1302    struct net_device *dev = link->priv;
1303
1304    ei_status.tx_start_page = start_pg;
1305    ei_status.rx_start_page = start_pg + TX_PAGES;
1306    ei_status.stop_page = stop_pg;
1307
1308    /* set up block i/o functions */
1309    ei_status.get_8390_hdr = dma_get_8390_hdr;
1310    ei_status.block_input = dma_block_input;
1311    ei_status.block_output = dma_block_output;
1312
1313    return 0;
1314}
1315
1316/*====================================================================*/
1317
1318static void copyin(void *dest, void __iomem *src, int c)
1319{
1320    u_short *d = dest;
1321    u_short __iomem *s = src;
1322    int odd;
1323
1324    if (c <= 0)
1325        return;
1326    odd = (c & 1); c >>= 1;
1327
1328    if (c) {
1329        do { *d++ = __raw_readw(s++); } while (--c);
1330    }
1331    /* get last byte by fetching a word and masking */
1332    if (odd)
1333        *((u_char *)d) = readw(s) & 0xff;
1334}
1335
1336static void copyout(void __iomem *dest, const void *src, int c)
1337{
1338    u_short __iomem *d = dest;
1339    const u_short *s = src;
1340    int odd;
1341
1342    if (c <= 0)
1343        return;
1344    odd = (c & 1); c >>= 1;
1345
1346    if (c) {
1347        do { __raw_writew(*s++, d++); } while (--c);
1348    }
1349    /* copy last byte doing a read-modify-write */
1350    if (odd)
1351        writew((readw(d) & 0xff00) | *(u_char *)s, d);
1352}
1353
1354/*====================================================================*/
1355
1356static void shmem_get_8390_hdr(struct net_device *dev,
1357                               struct e8390_pkt_hdr *hdr,
1358                               int ring_page)
1359{
1360    void __iomem *xfer_start = ei_status.mem + (TX_PAGES<<8)
1361                                + (ring_page << 8)
1362                                - (ei_status.rx_start_page << 8);
1363
1364    copyin(hdr, xfer_start, sizeof(struct e8390_pkt_hdr));
1365    /* Fix for big endian systems */
1366    hdr->count = le16_to_cpu(hdr->count);
1367}
1368
1369/*====================================================================*/
1370
1371static void shmem_block_input(struct net_device *dev, int count,
1372                              struct sk_buff *skb, int ring_offset)
1373{
1374    void __iomem *base = ei_status.mem;
1375    unsigned long offset = (TX_PAGES<<8) + ring_offset
1376                                - (ei_status.rx_start_page << 8);
1377    char *buf = skb->data;
1378
1379    if (offset + count > ei_status.priv) {
1380        /* We must wrap the input move. */
1381        int semi_count = ei_status.priv - offset;
1382        copyin(buf, base + offset, semi_count);
1383        buf += semi_count;
1384        offset = TX_PAGES<<8;
1385        count -= semi_count;
1386    }
1387    copyin(buf, base + offset, count);
1388}
1389
1390/*====================================================================*/
1391
1392static void shmem_block_output(struct net_device *dev, int count,
1393                               const u_char *buf, const int start_page)
1394{
1395    void __iomem *shmem = ei_status.mem + (start_page << 8);
1396    shmem -= ei_status.tx_start_page << 8;
1397    copyout(shmem, buf, count);
1398}
1399
1400/*====================================================================*/
1401
1402static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
1403                              int stop_pg, int cm_offset)
1404{
1405    struct net_device *dev = link->priv;
1406    struct pcnet_dev *info = PRIV(dev);
1407    int i, window_size, offset, ret;
1408
1409    window_size = (stop_pg - start_pg) << 8;
1410    if (window_size > 32 * 1024)
1411        window_size = 32 * 1024;
1412
1413    /* Make sure it's a power of two.  */
1414    window_size = roundup_pow_of_two(window_size);
1415
1416    /* Allocate a memory window */
1417    link->resource[3]->flags |= WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
1418    link->resource[3]->flags |= WIN_USE_WAIT;
1419    link->resource[3]->start = 0; link->resource[3]->end = window_size;
1420    ret = pcmcia_request_window(link, link->resource[3], mem_speed);
1421    if (ret)
1422            goto failed;
1423
1424    offset = (start_pg << 8) + cm_offset;
1425    offset -= offset % window_size;
1426    ret = pcmcia_map_mem_page(link, link->resource[3], offset);
1427    if (ret)
1428            goto failed;
1429
1430    /* Try scribbling on the buffer */
1431    info->base = ioremap(link->resource[3]->start,
1432                        resource_size(link->resource[3]));
1433    if (unlikely(!info->base)) {
1434            ret = -ENOMEM;
1435            goto failed;
1436    }
1437
1438    for (i = 0; i < (TX_PAGES<<8); i += 2)
1439        __raw_writew((i>>1), info->base+offset+i);
1440    udelay(100);
1441    for (i = 0; i < (TX_PAGES<<8); i += 2)
1442        if (__raw_readw(info->base+offset+i) != (i>>1)) break;
1443    pcnet_reset_8390(dev);
1444    if (i != (TX_PAGES<<8)) {
1445        iounmap(info->base);
1446        pcmcia_release_window(link, link->resource[3]);
1447        info->base = NULL;
1448        goto failed;
1449    }
1450
1451    ei_status.mem = info->base + offset;
1452    ei_status.priv = resource_size(link->resource[3]);
1453    dev->mem_start = (u_long)ei_status.mem;
1454    dev->mem_end = dev->mem_start + resource_size(link->resource[3]);
1455
1456    ei_status.tx_start_page = start_pg;
1457    ei_status.rx_start_page = start_pg + TX_PAGES;
1458    ei_status.stop_page = start_pg + (
1459            (resource_size(link->resource[3]) - offset) >> 8);
1460
1461    /* set up block i/o functions */
1462    ei_status.get_8390_hdr = shmem_get_8390_hdr;
1463    ei_status.block_input = shmem_block_input;
1464    ei_status.block_output = shmem_block_output;
1465
1466    info->flags |= USE_SHMEM;
1467    return 0;
1468
1469failed:
1470    return 1;
1471}
1472
1473/*====================================================================*/
1474
1475static const struct pcmcia_device_id pcnet_ids[] = {
1476        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0057, 0x0021),
1477        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0104, 0x000a),
1478        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0xea15),
1479        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0x3341),
1480        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0xc0ab),
1481        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x021b, 0x0101),
1482        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x08a1, 0xc0ab),
1483        PCMCIA_PFC_DEVICE_PROD_ID12(0, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
1484        PCMCIA_PFC_DEVICE_PROD_ID12(0, "ATKK", "LM33-PCM-T", 0xba9eb7e2, 0x077c174e),
1485        PCMCIA_PFC_DEVICE_PROD_ID12(0, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
1486        PCMCIA_PFC_DEVICE_PROD_ID12(0, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
1487        PCMCIA_PFC_DEVICE_PROD_ID12(0, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
1488        PCMCIA_PFC_DEVICE_PROD_ID12(0, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
1489        PCMCIA_PFC_DEVICE_PROD_ID12(0, "MICRO RESEARCH", "COMBO-L/M-336", 0xb2ced065, 0x3ced0555),
1490        PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1491        PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
1492        PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
1493        PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
1494        PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
1495        PCMCIA_MFC_DEVICE_PROD_ID123(0, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
1496        PCMCIA_MFC_DEVICE_PROD_ID2(0, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
1497        PCMCIA_DEVICE_MANF_CARD(0x0057, 0x1004),
1498        PCMCIA_DEVICE_MANF_CARD(0x0104, 0x000d),
1499        PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0075),
1500        PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0145),
1501        PCMCIA_DEVICE_MANF_CARD(0x0149, 0x0230),
1502        PCMCIA_DEVICE_MANF_CARD(0x0149, 0x4530),
1503        PCMCIA_DEVICE_MANF_CARD(0x0149, 0xc1ab),
1504        PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0110),
1505        PCMCIA_DEVICE_MANF_CARD(0x01bf, 0x8041),
1506        PCMCIA_DEVICE_MANF_CARD(0x0213, 0x2452),
1507        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0300),
1508        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0307),
1509        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x030a),
1510        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1103),
1511        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1121),
1512        PCMCIA_DEVICE_MANF_CARD(0xc001, 0x0009),
1513        PCMCIA_DEVICE_PROD_ID12("2408LAN", "Ethernet", 0x352fff7f, 0x00b2e941),
1514        PCMCIA_DEVICE_PROD_ID1234("Socket", "CF 10/100 Ethernet Card", "Revision B", "05/11/06", 0xb38bcc2e, 0x4de88352, 0xeaca6c8d, 0x7e57c22e),
1515        PCMCIA_DEVICE_PROD_ID123("Cardwell", "PCMCIA", "ETHERNET", 0x9533672e, 0x281f1c5d, 0x3ff7175b),
1516        PCMCIA_DEVICE_PROD_ID123("CNet  ", "CN30BC", "ETHERNET", 0x9fe55d3d, 0x85601198, 0x3ff7175b),
1517        PCMCIA_DEVICE_PROD_ID123("Digital", "Ethernet", "Adapter", 0x9999ab35, 0x00b2e941, 0x4b0d829e),
1518        PCMCIA_DEVICE_PROD_ID123("Edimax Technology Inc.", "PCMCIA", "Ethernet Card", 0x738a0019, 0x281f1c5d, 0x5e9d92c0),
1519        PCMCIA_DEVICE_PROD_ID123("EFA   ", "EFA207", "ETHERNET", 0x3d294be4, 0xeb9aab6c, 0x3ff7175b),
1520        PCMCIA_DEVICE_PROD_ID123("I-O DATA", "PCLA", "ETHERNET", 0x1d55d7ec, 0xe4c64d34, 0x3ff7175b),
1521        PCMCIA_DEVICE_PROD_ID123("IO DATA", "PCLATE", "ETHERNET", 0x547e66dc, 0x6b260753, 0x3ff7175b),
1522        PCMCIA_DEVICE_PROD_ID123("KingMax Technology Inc.", "EN10-T2", "PCMCIA Ethernet Card", 0x932b7189, 0x699e4436, 0x6f6652e0),
1523        PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2216", 0x281f1c5d, 0xd4cd2f20, 0xb87add82),
1524        PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2620", 0x281f1c5d, 0xd4cd2f20, 0x7d3d83a8),
1525        PCMCIA_DEVICE_PROD_ID1("2412LAN", 0x67f236ab),
1526        PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2212", 0xdfc6b5b2, 0xcb112a11),
1527        PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2216-PCMCIA-ETHERNET", 0xdfc6b5b2, 0x5542bfff),
1528        PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA100-PCM-T V2 100/10M LAN PC Card", 0xbb7fbdd7, 0xcd91cc68),
1529        PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA100-PCM V2", 0x36634a66, 0xc6d05997),
1530        PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA-PCM_V2", 0xbb7fBdd7, 0x28e299f8),
1531        PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA-PCM V3", 0x36634a66, 0x62241d96),
1532        PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8010", 0x5070a7f9, 0x82f96e96),
1533        PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8610", 0x5070a7f9, 0x86741224),
1534        PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002", 0x93b15570, 0x75ec3efb),
1535        PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002T", 0x93b15570, 0x461c5247),
1536        PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8010", 0x93b15570, 0x82f96e96),
1537        PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet", 0x578ba6e7, 0x0a9888c1),
1538        PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet 10/100", 0x578ba6e7, 0x939fedbd),
1539        PCMCIA_DEVICE_PROD_ID12("AROWANA", "PCMCIA Ethernet LAN Card", 0x313adbc8, 0x08d9f190),
1540        PCMCIA_DEVICE_PROD_ID12("ASANTE", "FriendlyNet PC Card", 0x3a7ade0f, 0x41c64504),
1541        PCMCIA_DEVICE_PROD_ID12("Billionton", "LNT-10TB", 0x552ab682, 0xeeb1ba6a),
1542        PCMCIA_DEVICE_PROD_ID12("CF", "10Base-Ethernet", 0x44ebf863, 0x93ae4d79),
1543        PCMCIA_DEVICE_PROD_ID12("CNet", "CN40BC Ethernet", 0xbc477dde, 0xfba775a7),
1544        PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "BASEline PCMCIA 10 MBit Ethernetadapter", 0xfa2e424d, 0xe9190d8a),
1545        PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "FASTline PCMCIA 10/100 Fast-Ethernet", 0xfa2e424d, 0x3953d9b9),
1546        PCMCIA_DEVICE_PROD_ID12("CONTEC", "C-NET(PC)C-10L", 0x21cab552, 0xf6f90722),
1547        PCMCIA_DEVICE_PROD_ID12("corega", "FEther PCC-TXF", 0x0a21501a, 0xa51564a2),
1548        PCMCIA_DEVICE_PROD_ID12("corega", "Ether CF-TD", 0x0a21501a, 0x6589340a),
1549        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether CF-TD LAN Card", 0x5261440f, 0x8797663b),
1550        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-T", 0x5261440f, 0xfa9d85bd),
1551        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-TD", 0x5261440f, 0xc49bd73d),
1552        PCMCIA_DEVICE_PROD_ID12("Corega K.K.", "corega EtherII PCC-TD", 0xd4fdcbd8, 0xc49bd73d),
1553        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-T", 0x5261440f, 0x6705fcaa),
1554        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-TD", 0x5261440f, 0x47d5ca83),
1555        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FastEther PCC-TX", 0x5261440f, 0x485e85d9),
1556        PCMCIA_DEVICE_PROD_ID12("Corega,K.K.", "Ethernet LAN Card", 0x110d26d9, 0x9fd2f0a2),
1557        PCMCIA_DEVICE_PROD_ID12("corega,K.K.", "Ethernet LAN Card", 0x9791a90e, 0x9fd2f0a2),
1558        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "(CG-LAPCCTXD)", 0x5261440f, 0x73ec0d88),
1559        PCMCIA_DEVICE_PROD_ID12("CouplerlessPCMCIA", "100BASE", 0xee5af0ad, 0x7c2add04),
1560        PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-010", 0x77008979, 0x9d8d445d),
1561        PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-110E 10/100M LAN Card", 0x77008979, 0xfd184814),
1562        PCMCIA_DEVICE_PROD_ID12("DataTrek.", "NetCard ", 0x5cd66d9d, 0x84697ce0),
1563        PCMCIA_DEVICE_PROD_ID12("Dayna Communications, Inc.", "CommuniCard E", 0x0c629325, 0xb4e7dbaf),
1564        PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100", 0x697403d8, 0xe160b995),
1565        PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100 Dongless", 0x697403d8, 0xa6d3b233),
1566        PCMCIA_DEVICE_PROD_ID12("DIGITAL", "DEPCM-XX", 0x69616cb3, 0xe600e76e),
1567        PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-650", 0x1a424a1c, 0xf28c8398),
1568        PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660", 0x1a424a1c, 0xd9a1d05b),
1569        PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660+", 0x1a424a1c, 0x50dcd0ec),
1570        PCMCIA_DEVICE_PROD_ID12("D-Link", "DFE-650", 0x1a424a1c, 0x0f0073f9),
1571        PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 PC Card", 0x725b842d, 0xf1efee84),
1572        PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 Port Attached PC Card", 0x725b842d, 0x2db1f8e9),
1573        PCMCIA_DEVICE_PROD_ID12("Dynalink", "L10BC", 0x55632fd5, 0xdc65f2b1),
1574        PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10BC", 0x6a26d1cf, 0xdc65f2b1),
1575        PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10C", 0x6a26d1cf, 0xc4f84efb),
1576        PCMCIA_DEVICE_PROD_ID12("E-CARD", "E-CARD", 0x6701da11, 0x6701da11),
1577        PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet 10BaseT card", 0x53c864c6, 0xedd059f6),
1578        PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet Combo card", 0x53c864c6, 0x929c486c),
1579        PCMCIA_DEVICE_PROD_ID12("Ethernet", "Adapter", 0x00b2e941, 0x4b0d829e),
1580        PCMCIA_DEVICE_PROD_ID12("Ethernet Adapter", "E2000 PCMCIA Ethernet", 0x96767301, 0x71fbbc61),
1581        PCMCIA_DEVICE_PROD_ID12("Ethernet PCMCIA adapter", "EP-210", 0x8dd86181, 0xf2b52517),
1582        PCMCIA_DEVICE_PROD_ID12("Fast Ethernet", "Adapter", 0xb4be14e3, 0x4b0d829e),
1583        PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2000", 0x2a151fac, 0xf00555cb),
1584        PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2220", 0x2a151fac, 0xc1b7e327),
1585        PCMCIA_DEVICE_PROD_ID12("GVC", "NIC-2000p", 0x76e171bd, 0x6eb1c947),
1586        PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "Ethernet", 0xe3736c88, 0x00b2e941),
1587        PCMCIA_DEVICE_PROD_ID12("IC-CARD", "IC-CARD", 0x60cb09a6, 0x60cb09a6),
1588        PCMCIA_DEVICE_PROD_ID12("IC-CARD+", "IC-CARD+", 0x93693494, 0x93693494),
1589        PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCETTX", 0x547e66dc, 0x6fc5459b),
1590        PCMCIA_DEVICE_PROD_ID12("iPort", "10/100 Ethernet Card", 0x56c538d2, 0x11b0ffc0),
1591        PCMCIA_DEVICE_PROD_ID12("KANSAI ELECTRIC CO.,LTD", "KLA-PCM/T", 0xb18dc3b4, 0xcc51a956),
1592        PCMCIA_DEVICE_PROD_ID12("KENTRONICS", "KEP-230", 0xaf8144c9, 0x868f6616),
1593        PCMCIA_DEVICE_PROD_ID12("KCI", "PE520 PCMCIA Ethernet Adapter", 0xa89b87d3, 0x1eb88e64),
1594        PCMCIA_DEVICE_PROD_ID12("KINGMAX", "EN10T2T", 0x7bcb459a, 0xa5c81fa5),
1595        PCMCIA_DEVICE_PROD_ID12("Kingston", "KNE-PC2", 0x1128e633, 0xce2a89b3),
1596        PCMCIA_DEVICE_PROD_ID12("Kingston Technology Corp.", "EtheRx PC Card Ethernet Adapter", 0x313c7be3, 0x0afb54a2),
1597        PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-10/100CD", 0x1b7827b2, 0xcda71d1c),
1598        PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDF", 0x1b7827b2, 0xfec71e40),
1599        PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDL/T", 0x1b7827b2, 0x79fba4f7),
1600        PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDS", 0x1b7827b2, 0x931afaab),
1601        PCMCIA_DEVICE_PROD_ID12("LEMEL", "LM-N89TX PRO", 0xbbefb52f, 0xd2897a97),
1602        PCMCIA_DEVICE_PROD_ID12("Linksys", "Combo PCMCIA EthernetCard (EC2T)", 0x0733cc81, 0x32ee8c78),
1603        PCMCIA_DEVICE_PROD_ID12("LINKSYS", "E-CARD", 0xf7cb0b07, 0x6701da11),
1604        PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 Integrated PC Card (PCM100)", 0x0733cc81, 0x453c3f9d),
1605        PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100)", 0x0733cc81, 0x66c5a389),
1606        PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V2)", 0x0733cc81, 0x3a3b28e9),
1607        PCMCIA_DEVICE_PROD_ID12("Linksys", "HomeLink Phoneline + 10/100 Network PC Card (PCM100H1)", 0x733cc81, 0x7a3e5c3a),
1608        PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TX", 0x88fcdeda, 0x6d772737),
1609        PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TE", 0x88fcdeda, 0x0e714bee),
1610        PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN20T", 0x88fcdeda, 0x81090922),
1611        PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN10TE", 0x88fcdeda, 0xc1e2521c),
1612        PCMCIA_DEVICE_PROD_ID12("LONGSHINE", "PCMCIA Ethernet Card", 0xf866b0b0, 0x6f6652e0),
1613        PCMCIA_DEVICE_PROD_ID12("MACNICA", "ME1-JEIDA", 0x20841b68, 0xaf8a3578),
1614        PCMCIA_DEVICE_PROD_ID12("Macsense", "MPC-10", 0xd830297f, 0xd265c307),
1615        PCMCIA_DEVICE_PROD_ID12("Matsushita Electric Industrial Co.,LTD.", "CF-VEL211", 0x44445376, 0x8ded41d4),
1616        PCMCIA_DEVICE_PROD_ID12("MAXTECH", "PCN2000", 0x78d64bc0, 0xca0ca4b8),
1617        PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-T", 0x481e0094, 0xa2eb0cf3),
1618        PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-TX", 0x481e0094, 0x41a6916c),
1619        PCMCIA_DEVICE_PROD_ID12("Microcom C.E.", "Travel Card LAN 10/100", 0x4b91cec7, 0xe70220d6),
1620        PCMCIA_DEVICE_PROD_ID12("Microdyne", "NE4200", 0x2e6da59b, 0x0478e472),
1621        PCMCIA_DEVICE_PROD_ID12("MIDORI ELEC.", "LT-PCMT", 0x648d55c1, 0xbde526c7),
1622        PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover 4100", 0x36e1191f, 0x60c229b9),
1623        PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover NE4100", 0x36e1191f, 0xa6617ec8),
1624        PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J12", 0x18df0ba0, 0xbc912d76),
1625        PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA410TX", 0x9aa79dc3, 0x60e5bc0e),
1626        PCMCIA_DEVICE_PROD_ID12("Network Everywhere", "Fast Ethernet 10/100 PC Card", 0x820a67b6, 0x31ed1a5f),
1627        PCMCIA_DEVICE_PROD_ID12("NextCom K.K.", "Next Hawk", 0xaedaec74, 0xad050ef1),
1628        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100Mbps Ethernet Card", 0x281f1c5d, 0x6e41773b),
1629        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet", 0x281f1c5d, 0x00b2e941),
1630        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET", 0x281f1c5d, 0x3ff7175b),
1631        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet 10BaseT Card", 0x281f1c5d, 0x4de2f6c8),
1632        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Card", 0x281f1c5d, 0x5e9d92c0),
1633        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Combo card", 0x281f1c5d, 0x929c486c),
1634        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET V1.0", 0x281f1c5d, 0x4d8817c8),
1635        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEthernet", 0x281f1c5d, 0xfe871eeb),
1636        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast-Ethernet", 0x281f1c5d, 0x45f1f3b4),
1637        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FAST ETHERNET CARD", 0x281f1c5d, 0xec5dbca7),
1638        PCMCIA_DEVICE_PROD_ID12("PCMCIA LAN", "Ethernet", 0x7500e246, 0x00b2e941),
1639        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "LNT-10TN", 0x281f1c5d, 0xe707f641),
1640        PCMCIA_DEVICE_PROD_ID12("PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1641        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "UE2212", 0x281f1c5d, 0xbf17199b),
1642        PCMCIA_DEVICE_PROD_ID12("PCMCIA", "    Ethernet NE2000 Compatible", 0x281f1c5d, 0x42d5d7e1),
1643        PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10baseT 3.3V", 0xebf91155, 0x30074c80),
1644        PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10BaseT 3.3V", 0xebf91155, 0x7f5a4f50),
1645        PCMCIA_DEVICE_PROD_ID12("Psion Dacom", "Gold Card Ethernet", 0xf5f025c2, 0x3a30e110),
1646        PCMCIA_DEVICE_PROD_ID12("=RELIA==", "Ethernet", 0xcdd0644a, 0x00b2e941),
1647        PCMCIA_DEVICE_PROD_ID12("RIOS Systems Co.", "PC CARD3 ETHERNET", 0x7dd33481, 0x10b41826),
1648        PCMCIA_DEVICE_PROD_ID12("RP", "1625B Ethernet NE2000 Compatible", 0xe3e66e22, 0xb96150df),
1649        PCMCIA_DEVICE_PROD_ID12("RPTI", "EP400 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4a7e2ae0),
1650        PCMCIA_DEVICE_PROD_ID12("RPTI", "EP401 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4bcbd7fd),
1651        PCMCIA_DEVICE_PROD_ID12("RPTI LTD.", "EP400", 0xc53ac515, 0x81e39388),
1652        PCMCIA_DEVICE_PROD_ID12("SCM", "Ethernet Combo card", 0xbdc3b102, 0x929c486c),
1653        PCMCIA_DEVICE_PROD_ID12("Seiko Epson Corp.", "Ethernet", 0x09928730, 0x00b2e941),
1654        PCMCIA_DEVICE_PROD_ID12("SMC", "EZCard-10-PCMCIA", 0xc4f8b18b, 0xfb21d265),
1655        PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision D", 0xc70a4760, 0x2ade483e),
1656        PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision E", 0xc70a4760, 0x5dd978a8),
1657        PCMCIA_DEVICE_PROD_ID12("TDK", "LAK-CD031 for PCMCIA", 0x1eae9475, 0x0ed386fa),
1658        PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE450T", 0x466b05f0, 0x8b74bc4f),
1659        PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE550T", 0x466b05f0, 0x33c8db2a),
1660        PCMCIA_DEVICE_PROD_ID13("Hypertec",  "EP401", 0x8787bec7, 0xf6e4a31e),
1661        PCMCIA_DEVICE_PROD_ID13("KingMax Technology Inc.", "Ethernet Card", 0x932b7189, 0x5e9d92c0),
1662        PCMCIA_DEVICE_PROD_ID13("LONGSHINE", "EP401", 0xf866b0b0, 0xf6e4a31e),
1663        PCMCIA_DEVICE_PROD_ID13("Xircom", "CFE-10", 0x2e3ee845, 0x22a49f89),
1664        PCMCIA_DEVICE_PROD_ID1("CyQ've 10 Base-T LAN CARD", 0x94faf360),
1665        PCMCIA_DEVICE_PROD_ID1("EP-210 PCMCIA LAN CARD.", 0x8850b4de),
1666        PCMCIA_DEVICE_PROD_ID1("ETHER-C16", 0x06a8514f),
1667        PCMCIA_DEVICE_PROD_ID1("NE2000 Compatible", 0x75b8ad5a),
1668        PCMCIA_DEVICE_PROD_ID2("EN-6200P2", 0xa996d078),
1669        /* too generic! */
1670        /* PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100 Ethernet Card", 0x281f1c5d, 0x11b0ffc0), */
1671        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "cis/PCMLM28.cis"),
1672        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "cis/PCMLM28.cis"),
1673        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"),
1674        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"),
1675        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"),
1676        PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "TOSHIBA", "Modem/LAN Card", 0xb4585a1a, 0x53f922f8, "cis/PCMLM28.cis"),
1677        PCMCIA_MFC_DEVICE_CIS_PROD_ID12(0, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "cis/DP83903.cis"),
1678        PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"),
1679        PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "cis/DP83903.cis"),
1680        PCMCIA_DEVICE_CIS_PROD_ID12("Allied Telesis,K.K", "Ethernet LAN Card", 0x2ad62f3c, 0x9fd2f0a2, "cis/LA-PCM.cis"),
1681        PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "cis/PE520.cis"),
1682        PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "cis/NE2K.cis"),
1683        PCMCIA_DEVICE_CIS_PROD_ID12("PMX   ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "cis/PE-200.cis"),
1684        PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "cis/tamarack.cis"),
1685        PCMCIA_DEVICE_PROD_ID12("Ethernet", "CF Size PC Card", 0x00b2e941, 0x43ac239b),
1686        PCMCIA_DEVICE_PROD_ID123("Fast Ethernet", "CF Size PC Card", "1.0",
1687                0xb4be14e3, 0x43ac239b, 0x0877b627),
1688        PCMCIA_DEVICE_NULL
1689};
1690MODULE_DEVICE_TABLE(pcmcia, pcnet_ids);
1691MODULE_FIRMWARE("cis/PCMLM28.cis");
1692MODULE_FIRMWARE("cis/DP83903.cis");
1693MODULE_FIRMWARE("cis/LA-PCM.cis");
1694MODULE_FIRMWARE("cis/PE520.cis");
1695MODULE_FIRMWARE("cis/NE2K.cis");
1696MODULE_FIRMWARE("cis/PE-200.cis");
1697MODULE_FIRMWARE("cis/tamarack.cis");
1698
1699static struct pcmcia_driver pcnet_driver = {
1700        .name           = "pcnet_cs",
1701        .probe          = pcnet_probe,
1702        .remove         = pcnet_detach,
1703        .owner          = THIS_MODULE,
1704        .id_table       = pcnet_ids,
1705        .suspend        = pcnet_suspend,
1706        .resume         = pcnet_resume,
1707};
1708module_pcmcia_driver(pcnet_driver);
1709