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