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