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