drivers/net/ethernet/8390/pcnet_cs.c

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