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 	/* fall through */
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), xfer_count++;
1183 
1184     /* This was for the ALPHA version only, but enough people have been
1185        encountering problems that it is still here. */
1186 #ifdef PCMCIA_DEBUG
1187       /* DMA termination address check... */
1188     if (netif_msg_rx_status(ei_local)) {
1189 	int addr, tries = 20;
1190 	do {
1191 	    /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
1192 	       -- it's broken for Rx on some cards! */
1193 	    int high = inb_p(nic_base + EN0_RSARHI);
1194 	    int low = inb_p(nic_base + EN0_RSARLO);
1195 	    addr = (high << 8) + low;
1196 	    if (((ring_offset + xfer_count) & 0xff) == (addr & 0xff))
1197 		break;
1198 	} while (--tries > 0);
1199 	if (tries <= 0)
1200 	    netdev_notice(dev, "RX transfer address mismatch,"
1201 			  "%#4.4x (expected) vs. %#4.4x (actual).\n",
1202 			  ring_offset + xfer_count, addr);
1203     }
1204 #endif
1205     outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
1206     ei_status.dmaing &= ~0x01;
1207 } /* dma_block_input */
1208 
1209 /*====================================================================*/
1210 
1211 static void dma_block_output(struct net_device *dev, int count,
1212 			     const u_char *buf, const int start_page)
1213 {
1214     unsigned int nic_base = dev->base_addr;
1215     struct pcnet_dev *info = PRIV(dev);
1216 #ifdef PCMCIA_DEBUG
1217     int retries = 0;
1218     struct ei_device *ei_local = netdev_priv(dev);
1219 #endif
1220     u_long dma_start;
1221 
1222 #ifdef PCMCIA_DEBUG
1223     netif_dbg(ei_local, tx_queued, dev, "[bo=%d]\n", count);
1224 #endif
1225 
1226     /* Round the count up for word writes.  Do we need to do this?
1227        What effect will an odd byte count have on the 8390?
1228        I should check someday. */
1229     if (count & 0x01)
1230 	count++;
1231     if (ei_status.dmaing) {
1232 	netdev_err(dev, "DMAing conflict in dma_block_output."
1233 		   "[DMAstat:%1x][irqlock:%1x]\n",
1234 		   ei_status.dmaing, ei_status.irqlock);
1235 	return;
1236     }
1237     ei_status.dmaing |= 0x01;
1238     /* We should already be in page 0, but to be safe... */
1239     outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base+PCNET_CMD);
1240 
1241 #ifdef PCMCIA_DEBUG
1242   retry:
1243 #endif
1244 
1245     outb_p(ENISR_RDC, nic_base + EN0_ISR);
1246 
1247     /* Now the normal output. */
1248     outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1249     outb_p(count >> 8,   nic_base + EN0_RCNTHI);
1250     outb_p(0x00, nic_base + EN0_RSARLO);
1251     outb_p(start_page, nic_base + EN0_RSARHI);
1252 
1253     outb_p(E8390_RWRITE+E8390_START, nic_base + PCNET_CMD);
1254     outsw(nic_base + PCNET_DATAPORT, buf, count>>1);
1255 
1256     dma_start = jiffies;
1257 
1258 #ifdef PCMCIA_DEBUG
1259     /* This was for the ALPHA version only, but enough people have been
1260        encountering problems that it is still here. */
1261     /* DMA termination address check... */
1262     if (netif_msg_tx_queued(ei_local)) {
1263 	int addr, tries = 20;
1264 	do {
1265 	    int high = inb_p(nic_base + EN0_RSARHI);
1266 	    int low = inb_p(nic_base + EN0_RSARLO);
1267 	    addr = (high << 8) + low;
1268 	    if ((start_page << 8) + count == addr)
1269 		break;
1270 	} while (--tries > 0);
1271 	if (tries <= 0) {
1272 	    netdev_notice(dev, "Tx packet transfer address mismatch,"
1273 			  "%#4.4x (expected) vs. %#4.4x (actual).\n",
1274 			  (start_page << 8) + count, addr);
1275 	    if (retries++ == 0)
1276 		goto retry;
1277 	}
1278     }
1279 #endif
1280 
1281     while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
1282 	if (time_after(jiffies, dma_start + PCNET_RDC_TIMEOUT)) {
1283 		netdev_warn(dev, "timeout waiting for Tx RDC.\n");
1284 		pcnet_reset_8390(dev);
1285 		NS8390_init(dev, 1);
1286 		break;
1287 	}
1288 
1289     outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
1290     if (info->flags & DELAY_OUTPUT)
1291 	udelay((long)delay_time);
1292     ei_status.dmaing &= ~0x01;
1293 }
1294 
1295 /*====================================================================*/
1296 
1297 static int setup_dma_config(struct pcmcia_device *link, int start_pg,
1298 			    int stop_pg)
1299 {
1300     struct net_device *dev = link->priv;
1301 
1302     ei_status.tx_start_page = start_pg;
1303     ei_status.rx_start_page = start_pg + TX_PAGES;
1304     ei_status.stop_page = stop_pg;
1305 
1306     /* set up block i/o functions */
1307     ei_status.get_8390_hdr = dma_get_8390_hdr;
1308     ei_status.block_input = dma_block_input;
1309     ei_status.block_output = dma_block_output;
1310 
1311     return 0;
1312 }
1313 
1314 /*====================================================================*/
1315 
1316 static void copyin(void *dest, void __iomem *src, int c)
1317 {
1318     u_short *d = dest;
1319     u_short __iomem *s = src;
1320     int odd;
1321 
1322     if (c <= 0)
1323 	return;
1324     odd = (c & 1); c >>= 1;
1325 
1326     if (c) {
1327 	do { *d++ = __raw_readw(s++); } while (--c);
1328     }
1329     /* get last byte by fetching a word and masking */
1330     if (odd)
1331 	*((u_char *)d) = readw(s) & 0xff;
1332 }
1333 
1334 static void copyout(void __iomem *dest, const void *src, int c)
1335 {
1336     u_short __iomem *d = dest;
1337     const u_short *s = src;
1338     int odd;
1339 
1340     if (c <= 0)
1341 	return;
1342     odd = (c & 1); c >>= 1;
1343 
1344     if (c) {
1345 	do { __raw_writew(*s++, d++); } while (--c);
1346     }
1347     /* copy last byte doing a read-modify-write */
1348     if (odd)
1349 	writew((readw(d) & 0xff00) | *(u_char *)s, d);
1350 }
1351 
1352 /*====================================================================*/
1353 
1354 static void shmem_get_8390_hdr(struct net_device *dev,
1355 			       struct e8390_pkt_hdr *hdr,
1356 			       int ring_page)
1357 {
1358     void __iomem *xfer_start = ei_status.mem + (TX_PAGES<<8)
1359 				+ (ring_page << 8)
1360 				- (ei_status.rx_start_page << 8);
1361 
1362     copyin(hdr, xfer_start, sizeof(struct e8390_pkt_hdr));
1363     /* Fix for big endian systems */
1364     hdr->count = le16_to_cpu(hdr->count);
1365 }
1366 
1367 /*====================================================================*/
1368 
1369 static void shmem_block_input(struct net_device *dev, int count,
1370 			      struct sk_buff *skb, int ring_offset)
1371 {
1372     void __iomem *base = ei_status.mem;
1373     unsigned long offset = (TX_PAGES<<8) + ring_offset
1374 				- (ei_status.rx_start_page << 8);
1375     char *buf = skb->data;
1376 
1377     if (offset + count > ei_status.priv) {
1378 	/* We must wrap the input move. */
1379 	int semi_count = ei_status.priv - offset;
1380 	copyin(buf, base + offset, semi_count);
1381 	buf += semi_count;
1382 	offset = TX_PAGES<<8;
1383 	count -= semi_count;
1384     }
1385     copyin(buf, base + offset, count);
1386 }
1387 
1388 /*====================================================================*/
1389 
1390 static void shmem_block_output(struct net_device *dev, int count,
1391 			       const u_char *buf, const int start_page)
1392 {
1393     void __iomem *shmem = ei_status.mem + (start_page << 8);
1394     shmem -= ei_status.tx_start_page << 8;
1395     copyout(shmem, buf, count);
1396 }
1397 
1398 /*====================================================================*/
1399 
1400 static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
1401 			      int stop_pg, int cm_offset)
1402 {
1403     struct net_device *dev = link->priv;
1404     struct pcnet_dev *info = PRIV(dev);
1405     int i, window_size, offset, ret;
1406 
1407     window_size = (stop_pg - start_pg) << 8;
1408     if (window_size > 32 * 1024)
1409 	window_size = 32 * 1024;
1410 
1411     /* Make sure it's a power of two.  */
1412     window_size = roundup_pow_of_two(window_size);
1413 
1414     /* Allocate a memory window */
1415     link->resource[3]->flags |= WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
1416     link->resource[3]->flags |= WIN_USE_WAIT;
1417     link->resource[3]->start = 0; link->resource[3]->end = window_size;
1418     ret = pcmcia_request_window(link, link->resource[3], mem_speed);
1419     if (ret)
1420 	    goto failed;
1421 
1422     offset = (start_pg << 8) + cm_offset;
1423     offset -= offset % window_size;
1424     ret = pcmcia_map_mem_page(link, link->resource[3], offset);
1425     if (ret)
1426 	    goto failed;
1427 
1428     /* Try scribbling on the buffer */
1429     info->base = ioremap(link->resource[3]->start,
1430 			resource_size(link->resource[3]));
1431     if (unlikely(!info->base)) {
1432 	    ret = -ENOMEM;
1433 	    goto failed;
1434     }
1435 
1436     for (i = 0; i < (TX_PAGES<<8); i += 2)
1437 	__raw_writew((i>>1), info->base+offset+i);
1438     udelay(100);
1439     for (i = 0; i < (TX_PAGES<<8); i += 2)
1440 	if (__raw_readw(info->base+offset+i) != (i>>1)) break;
1441     pcnet_reset_8390(dev);
1442     if (i != (TX_PAGES<<8)) {
1443 	iounmap(info->base);
1444 	pcmcia_release_window(link, link->resource[3]);
1445 	info->base = NULL;
1446 	goto failed;
1447     }
1448 
1449     ei_status.mem = info->base + offset;
1450     ei_status.priv = resource_size(link->resource[3]);
1451     dev->mem_start = (u_long)ei_status.mem;
1452     dev->mem_end = dev->mem_start + resource_size(link->resource[3]);
1453 
1454     ei_status.tx_start_page = start_pg;
1455     ei_status.rx_start_page = start_pg + TX_PAGES;
1456     ei_status.stop_page = start_pg + (
1457 	    (resource_size(link->resource[3]) - offset) >> 8);
1458 
1459     /* set up block i/o functions */
1460     ei_status.get_8390_hdr = shmem_get_8390_hdr;
1461     ei_status.block_input = shmem_block_input;
1462     ei_status.block_output = shmem_block_output;
1463 
1464     info->flags |= USE_SHMEM;
1465     return 0;
1466 
1467 failed:
1468     return 1;
1469 }
1470 
1471 /*====================================================================*/
1472 
1473 static const struct pcmcia_device_id pcnet_ids[] = {
1474 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0057, 0x0021),
1475 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0104, 0x000a),
1476 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0xea15),
1477 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0x3341),
1478 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0143, 0xc0ab),
1479 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x021b, 0x0101),
1480 	PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x08a1, 0xc0ab),
1481 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
1482 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "ATKK", "LM33-PCM-T", 0xba9eb7e2, 0x077c174e),
1483 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
1484 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
1485 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
1486 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
1487 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "MICRO RESEARCH", "COMBO-L/M-336", 0xb2ced065, 0x3ced0555),
1488 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1489 	PCMCIA_PFC_DEVICE_PROD_ID12(0, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
1490 	PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
1491 	PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
1492 	PCMCIA_MFC_DEVICE_PROD_ID12(0, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
1493 	PCMCIA_MFC_DEVICE_PROD_ID123(0, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
1494 	PCMCIA_MFC_DEVICE_PROD_ID2(0, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
1495 	PCMCIA_DEVICE_MANF_CARD(0x0057, 0x1004),
1496 	PCMCIA_DEVICE_MANF_CARD(0x0104, 0x000d),
1497 	PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0075),
1498 	PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0145),
1499 	PCMCIA_DEVICE_MANF_CARD(0x0149, 0x0230),
1500 	PCMCIA_DEVICE_MANF_CARD(0x0149, 0x4530),
1501 	PCMCIA_DEVICE_MANF_CARD(0x0149, 0xc1ab),
1502 	PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0110),
1503 	PCMCIA_DEVICE_MANF_CARD(0x01bf, 0x8041),
1504 	PCMCIA_DEVICE_MANF_CARD(0x0213, 0x2452),
1505 	PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0300),
1506 	PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0307),
1507 	PCMCIA_DEVICE_MANF_CARD(0x026f, 0x030a),
1508 	PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1103),
1509 	PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1121),
1510 	PCMCIA_DEVICE_MANF_CARD(0xc001, 0x0009),
1511 	PCMCIA_DEVICE_PROD_ID12("2408LAN", "Ethernet", 0x352fff7f, 0x00b2e941),
1512 	PCMCIA_DEVICE_PROD_ID1234("Socket", "CF 10/100 Ethernet Card", "Revision B", "05/11/06", 0xb38bcc2e, 0x4de88352, 0xeaca6c8d, 0x7e57c22e),
1513 	PCMCIA_DEVICE_PROD_ID123("Cardwell", "PCMCIA", "ETHERNET", 0x9533672e, 0x281f1c5d, 0x3ff7175b),
1514 	PCMCIA_DEVICE_PROD_ID123("CNet  ", "CN30BC", "ETHERNET", 0x9fe55d3d, 0x85601198, 0x3ff7175b),
1515 	PCMCIA_DEVICE_PROD_ID123("Digital", "Ethernet", "Adapter", 0x9999ab35, 0x00b2e941, 0x4b0d829e),
1516 	PCMCIA_DEVICE_PROD_ID123("Edimax Technology Inc.", "PCMCIA", "Ethernet Card", 0x738a0019, 0x281f1c5d, 0x5e9d92c0),
1517 	PCMCIA_DEVICE_PROD_ID123("EFA   ", "EFA207", "ETHERNET", 0x3d294be4, 0xeb9aab6c, 0x3ff7175b),
1518 	PCMCIA_DEVICE_PROD_ID123("I-O DATA", "PCLA", "ETHERNET", 0x1d55d7ec, 0xe4c64d34, 0x3ff7175b),
1519 	PCMCIA_DEVICE_PROD_ID123("IO DATA", "PCLATE", "ETHERNET", 0x547e66dc, 0x6b260753, 0x3ff7175b),
1520 	PCMCIA_DEVICE_PROD_ID123("KingMax Technology Inc.", "EN10-T2", "PCMCIA Ethernet Card", 0x932b7189, 0x699e4436, 0x6f6652e0),
1521 	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2216", 0x281f1c5d, 0xd4cd2f20, 0xb87add82),
1522 	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "PCMCIA-ETHERNET-CARD", "UE2620", 0x281f1c5d, 0xd4cd2f20, 0x7d3d83a8),
1523 	PCMCIA_DEVICE_PROD_ID1("2412LAN", 0x67f236ab),
1524 	PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2212", 0xdfc6b5b2, 0xcb112a11),
1525 	PCMCIA_DEVICE_PROD_ID12("ACCTON", "EN2216-PCMCIA-ETHERNET", 0xdfc6b5b2, 0x5542bfff),
1526 	PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA100-PCM-T V2 100/10M LAN PC Card", 0xbb7fbdd7, 0xcd91cc68),
1527 	PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA100-PCM V2", 0x36634a66, 0xc6d05997),
1528   	PCMCIA_DEVICE_PROD_ID12("Allied Telesis, K.K.", "CentreCOM LA-PCM_V2", 0xbb7fBdd7, 0x28e299f8),
1529 	PCMCIA_DEVICE_PROD_ID12("Allied Telesis K.K.", "LA-PCM V3", 0x36634a66, 0x62241d96),
1530 	PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8010", 0x5070a7f9, 0x82f96e96),
1531 	PCMCIA_DEVICE_PROD_ID12("AmbiCom", "AMB8610", 0x5070a7f9, 0x86741224),
1532 	PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002", 0x93b15570, 0x75ec3efb),
1533 	PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8002T", 0x93b15570, 0x461c5247),
1534 	PCMCIA_DEVICE_PROD_ID12("AmbiCom Inc", "AMB8010", 0x93b15570, 0x82f96e96),
1535 	PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet", 0x578ba6e7, 0x0a9888c1),
1536 	PCMCIA_DEVICE_PROD_ID12("AnyCom", "ECO Ethernet 10/100", 0x578ba6e7, 0x939fedbd),
1537 	PCMCIA_DEVICE_PROD_ID12("AROWANA", "PCMCIA Ethernet LAN Card", 0x313adbc8, 0x08d9f190),
1538 	PCMCIA_DEVICE_PROD_ID12("ASANTE", "FriendlyNet PC Card", 0x3a7ade0f, 0x41c64504),
1539 	PCMCIA_DEVICE_PROD_ID12("Billionton", "LNT-10TB", 0x552ab682, 0xeeb1ba6a),
1540 	PCMCIA_DEVICE_PROD_ID12("CF", "10Base-Ethernet", 0x44ebf863, 0x93ae4d79),
1541 	PCMCIA_DEVICE_PROD_ID12("CNet", "CN40BC Ethernet", 0xbc477dde, 0xfba775a7),
1542 	PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "BASEline PCMCIA 10 MBit Ethernetadapter", 0xfa2e424d, 0xe9190d8a),
1543 	PCMCIA_DEVICE_PROD_ID12("COMPU-SHACK", "FASTline PCMCIA 10/100 Fast-Ethernet", 0xfa2e424d, 0x3953d9b9),
1544 	PCMCIA_DEVICE_PROD_ID12("CONTEC", "C-NET(PC)C-10L", 0x21cab552, 0xf6f90722),
1545 	PCMCIA_DEVICE_PROD_ID12("corega", "FEther PCC-TXF", 0x0a21501a, 0xa51564a2),
1546 	PCMCIA_DEVICE_PROD_ID12("corega", "Ether CF-TD", 0x0a21501a, 0x6589340a),
1547 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether CF-TD LAN Card", 0x5261440f, 0x8797663b),
1548 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-T", 0x5261440f, 0xfa9d85bd),
1549 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-TD", 0x5261440f, 0xc49bd73d),
1550 	PCMCIA_DEVICE_PROD_ID12("Corega K.K.", "corega EtherII PCC-TD", 0xd4fdcbd8, 0xc49bd73d),
1551 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-T", 0x5261440f, 0x6705fcaa),
1552 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-TD", 0x5261440f, 0x47d5ca83),
1553 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FastEther PCC-TX", 0x5261440f, 0x485e85d9),
1554 	PCMCIA_DEVICE_PROD_ID12("Corega,K.K.", "Ethernet LAN Card", 0x110d26d9, 0x9fd2f0a2),
1555 	PCMCIA_DEVICE_PROD_ID12("corega,K.K.", "Ethernet LAN Card", 0x9791a90e, 0x9fd2f0a2),
1556 	PCMCIA_DEVICE_PROD_ID12("corega K.K.", "(CG-LAPCCTXD)", 0x5261440f, 0x73ec0d88),
1557 	PCMCIA_DEVICE_PROD_ID12("CouplerlessPCMCIA", "100BASE", 0xee5af0ad, 0x7c2add04),
1558 	PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-010", 0x77008979, 0x9d8d445d),
1559 	PCMCIA_DEVICE_PROD_ID12("CyQ've", "ELA-110E 10/100M LAN Card", 0x77008979, 0xfd184814),
1560 	PCMCIA_DEVICE_PROD_ID12("DataTrek.", "NetCard ", 0x5cd66d9d, 0x84697ce0),
1561 	PCMCIA_DEVICE_PROD_ID12("Dayna Communications, Inc.", "CommuniCard E", 0x0c629325, 0xb4e7dbaf),
1562 	PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100", 0x697403d8, 0xe160b995),
1563 	PCMCIA_DEVICE_PROD_ID12("Digicom", "Palladio LAN 10/100 Dongless", 0x697403d8, 0xa6d3b233),
1564 	PCMCIA_DEVICE_PROD_ID12("DIGITAL", "DEPCM-XX", 0x69616cb3, 0xe600e76e),
1565 	PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-650", 0x1a424a1c, 0xf28c8398),
1566 	PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660", 0x1a424a1c, 0xd9a1d05b),
1567 	PCMCIA_DEVICE_PROD_ID12("D-Link", "DE-660+", 0x1a424a1c, 0x50dcd0ec),
1568 	PCMCIA_DEVICE_PROD_ID12("D-Link", "DFE-650", 0x1a424a1c, 0x0f0073f9),
1569 	PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 PC Card", 0x725b842d, 0xf1efee84),
1570 	PCMCIA_DEVICE_PROD_ID12("Dual Speed", "10/100 Port Attached PC Card", 0x725b842d, 0x2db1f8e9),
1571 	PCMCIA_DEVICE_PROD_ID12("Dynalink", "L10BC", 0x55632fd5, 0xdc65f2b1),
1572 	PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10BC", 0x6a26d1cf, 0xdc65f2b1),
1573 	PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L10C", 0x6a26d1cf, 0xc4f84efb),
1574 	PCMCIA_DEVICE_PROD_ID12("E-CARD", "E-CARD", 0x6701da11, 0x6701da11),
1575 	PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet 10BaseT card", 0x53c864c6, 0xedd059f6),
1576 	PCMCIA_DEVICE_PROD_ID12("EIGER Labs Inc.", "Ethernet Combo card", 0x53c864c6, 0x929c486c),
1577 	PCMCIA_DEVICE_PROD_ID12("Ethernet", "Adapter", 0x00b2e941, 0x4b0d829e),
1578 	PCMCIA_DEVICE_PROD_ID12("Ethernet Adapter", "E2000 PCMCIA Ethernet", 0x96767301, 0x71fbbc61),
1579 	PCMCIA_DEVICE_PROD_ID12("Ethernet PCMCIA adapter", "EP-210", 0x8dd86181, 0xf2b52517),
1580 	PCMCIA_DEVICE_PROD_ID12("Fast Ethernet", "Adapter", 0xb4be14e3, 0x4b0d829e),
1581 	PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2000", 0x2a151fac, 0xf00555cb),
1582 	PCMCIA_DEVICE_PROD_ID12("Grey Cell", "GCS2220", 0x2a151fac, 0xc1b7e327),
1583 	PCMCIA_DEVICE_PROD_ID12("GVC", "NIC-2000p", 0x76e171bd, 0x6eb1c947),
1584 	PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "Ethernet", 0xe3736c88, 0x00b2e941),
1585 	PCMCIA_DEVICE_PROD_ID12("IC-CARD", "IC-CARD", 0x60cb09a6, 0x60cb09a6),
1586 	PCMCIA_DEVICE_PROD_ID12("IC-CARD+", "IC-CARD+", 0x93693494, 0x93693494),
1587 	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCETTX", 0x547e66dc, 0x6fc5459b),
1588 	PCMCIA_DEVICE_PROD_ID12("iPort", "10/100 Ethernet Card", 0x56c538d2, 0x11b0ffc0),
1589 	PCMCIA_DEVICE_PROD_ID12("KANSAI ELECTRIC CO.,LTD", "KLA-PCM/T", 0xb18dc3b4, 0xcc51a956),
1590 	PCMCIA_DEVICE_PROD_ID12("KENTRONICS", "KEP-230", 0xaf8144c9, 0x868f6616),
1591 	PCMCIA_DEVICE_PROD_ID12("KCI", "PE520 PCMCIA Ethernet Adapter", 0xa89b87d3, 0x1eb88e64),
1592 	PCMCIA_DEVICE_PROD_ID12("KINGMAX", "EN10T2T", 0x7bcb459a, 0xa5c81fa5),
1593 	PCMCIA_DEVICE_PROD_ID12("Kingston", "KNE-PC2", 0x1128e633, 0xce2a89b3),
1594 	PCMCIA_DEVICE_PROD_ID12("Kingston Technology Corp.", "EtheRx PC Card Ethernet Adapter", 0x313c7be3, 0x0afb54a2),
1595 	PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-10/100CD", 0x1b7827b2, 0xcda71d1c),
1596 	PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDF", 0x1b7827b2, 0xfec71e40),
1597 	PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDL/T", 0x1b7827b2, 0x79fba4f7),
1598 	PCMCIA_DEVICE_PROD_ID12("Laneed", "LD-CDS", 0x1b7827b2, 0x931afaab),
1599 	PCMCIA_DEVICE_PROD_ID12("LEMEL", "LM-N89TX PRO", 0xbbefb52f, 0xd2897a97),
1600 	PCMCIA_DEVICE_PROD_ID12("Linksys", "Combo PCMCIA EthernetCard (EC2T)", 0x0733cc81, 0x32ee8c78),
1601 	PCMCIA_DEVICE_PROD_ID12("LINKSYS", "E-CARD", 0xf7cb0b07, 0x6701da11),
1602 	PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 Integrated PC Card (PCM100)", 0x0733cc81, 0x453c3f9d),
1603 	PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100)", 0x0733cc81, 0x66c5a389),
1604 	PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V2)", 0x0733cc81, 0x3a3b28e9),
1605 	PCMCIA_DEVICE_PROD_ID12("Linksys", "HomeLink Phoneline + 10/100 Network PC Card (PCM100H1)", 0x733cc81, 0x7a3e5c3a),
1606 	PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TX", 0x88fcdeda, 0x6d772737),
1607 	PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN100TE", 0x88fcdeda, 0x0e714bee),
1608 	PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN20T", 0x88fcdeda, 0x81090922),
1609 	PCMCIA_DEVICE_PROD_ID12("Logitec", "LPM-LN10TE", 0x88fcdeda, 0xc1e2521c),
1610 	PCMCIA_DEVICE_PROD_ID12("LONGSHINE", "PCMCIA Ethernet Card", 0xf866b0b0, 0x6f6652e0),
1611 	PCMCIA_DEVICE_PROD_ID12("MACNICA", "ME1-JEIDA", 0x20841b68, 0xaf8a3578),
1612 	PCMCIA_DEVICE_PROD_ID12("Macsense", "MPC-10", 0xd830297f, 0xd265c307),
1613 	PCMCIA_DEVICE_PROD_ID12("Matsushita Electric Industrial Co.,LTD.", "CF-VEL211", 0x44445376, 0x8ded41d4),
1614 	PCMCIA_DEVICE_PROD_ID12("MAXTECH", "PCN2000", 0x78d64bc0, 0xca0ca4b8),
1615 	PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-T", 0x481e0094, 0xa2eb0cf3),
1616 	PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC2-TX", 0x481e0094, 0x41a6916c),
1617 	PCMCIA_DEVICE_PROD_ID12("Microcom C.E.", "Travel Card LAN 10/100", 0x4b91cec7, 0xe70220d6),
1618 	PCMCIA_DEVICE_PROD_ID12("Microdyne", "NE4200", 0x2e6da59b, 0x0478e472),
1619 	PCMCIA_DEVICE_PROD_ID12("MIDORI ELEC.", "LT-PCMT", 0x648d55c1, 0xbde526c7),
1620 	PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover 4100", 0x36e1191f, 0x60c229b9),
1621 	PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover NE4100", 0x36e1191f, 0xa6617ec8),
1622 	PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J12", 0x18df0ba0, 0xbc912d76),
1623 	PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA410TX", 0x9aa79dc3, 0x60e5bc0e),
1624 	PCMCIA_DEVICE_PROD_ID12("Network Everywhere", "Fast Ethernet 10/100 PC Card", 0x820a67b6, 0x31ed1a5f),
1625 	PCMCIA_DEVICE_PROD_ID12("NextCom K.K.", "Next Hawk", 0xaedaec74, 0xad050ef1),
1626 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100Mbps Ethernet Card", 0x281f1c5d, 0x6e41773b),
1627 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet", 0x281f1c5d, 0x00b2e941),
1628 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET", 0x281f1c5d, 0x3ff7175b),
1629 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet 10BaseT Card", 0x281f1c5d, 0x4de2f6c8),
1630 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Card", 0x281f1c5d, 0x5e9d92c0),
1631 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Ethernet Combo card", 0x281f1c5d, 0x929c486c),
1632 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "ETHERNET V1.0", 0x281f1c5d, 0x4d8817c8),
1633 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEthernet", 0x281f1c5d, 0xfe871eeb),
1634 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast-Ethernet", 0x281f1c5d, 0x45f1f3b4),
1635 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FAST ETHERNET CARD", 0x281f1c5d, 0xec5dbca7),
1636 	PCMCIA_DEVICE_PROD_ID12("PCMCIA LAN", "Ethernet", 0x7500e246, 0x00b2e941),
1637 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "LNT-10TN", 0x281f1c5d, 0xe707f641),
1638 	PCMCIA_DEVICE_PROD_ID12("PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
1639 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "UE2212", 0x281f1c5d, 0xbf17199b),
1640 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "    Ethernet NE2000 Compatible", 0x281f1c5d, 0x42d5d7e1),
1641 	PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10baseT 3.3V", 0xebf91155, 0x30074c80),
1642 	PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10BaseT 3.3V", 0xebf91155, 0x7f5a4f50),
1643 	PCMCIA_DEVICE_PROD_ID12("Psion Dacom", "Gold Card Ethernet", 0xf5f025c2, 0x3a30e110),
1644 	PCMCIA_DEVICE_PROD_ID12("=RELIA==", "Ethernet", 0xcdd0644a, 0x00b2e941),
1645 	PCMCIA_DEVICE_PROD_ID12("RIOS Systems Co.", "PC CARD3 ETHERNET", 0x7dd33481, 0x10b41826),
1646 	PCMCIA_DEVICE_PROD_ID12("RP", "1625B Ethernet NE2000 Compatible", 0xe3e66e22, 0xb96150df),
1647 	PCMCIA_DEVICE_PROD_ID12("RPTI", "EP400 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4a7e2ae0),
1648 	PCMCIA_DEVICE_PROD_ID12("RPTI", "EP401 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4bcbd7fd),
1649 	PCMCIA_DEVICE_PROD_ID12("RPTI LTD.", "EP400", 0xc53ac515, 0x81e39388),
1650 	PCMCIA_DEVICE_PROD_ID12("SCM", "Ethernet Combo card", 0xbdc3b102, 0x929c486c),
1651 	PCMCIA_DEVICE_PROD_ID12("Seiko Epson Corp.", "Ethernet", 0x09928730, 0x00b2e941),
1652 	PCMCIA_DEVICE_PROD_ID12("SMC", "EZCard-10-PCMCIA", 0xc4f8b18b, 0xfb21d265),
1653 	PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision D", 0xc70a4760, 0x2ade483e),
1654 	PCMCIA_DEVICE_PROD_ID12("Socket Communications Inc", "Socket EA PCMCIA LAN Adapter Revision E", 0xc70a4760, 0x5dd978a8),
1655 	PCMCIA_DEVICE_PROD_ID12("TDK", "LAK-CD031 for PCMCIA", 0x1eae9475, 0x0ed386fa),
1656 	PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE450T", 0x466b05f0, 0x8b74bc4f),
1657 	PCMCIA_DEVICE_PROD_ID12("Telecom Device K.K.", "SuperSocket RE550T", 0x466b05f0, 0x33c8db2a),
1658 	PCMCIA_DEVICE_PROD_ID13("Hypertec",  "EP401", 0x8787bec7, 0xf6e4a31e),
1659 	PCMCIA_DEVICE_PROD_ID13("KingMax Technology Inc.", "Ethernet Card", 0x932b7189, 0x5e9d92c0),
1660 	PCMCIA_DEVICE_PROD_ID13("LONGSHINE", "EP401", 0xf866b0b0, 0xf6e4a31e),
1661 	PCMCIA_DEVICE_PROD_ID13("Xircom", "CFE-10", 0x2e3ee845, 0x22a49f89),
1662 	PCMCIA_DEVICE_PROD_ID1("CyQ've 10 Base-T LAN CARD", 0x94faf360),
1663 	PCMCIA_DEVICE_PROD_ID1("EP-210 PCMCIA LAN CARD.", 0x8850b4de),
1664 	PCMCIA_DEVICE_PROD_ID1("ETHER-C16", 0x06a8514f),
1665 	PCMCIA_DEVICE_PROD_ID1("NE2000 Compatible", 0x75b8ad5a),
1666 	PCMCIA_DEVICE_PROD_ID2("EN-6200P2", 0xa996d078),
1667 	/* too generic! */
1668 	/* PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100 Ethernet Card", 0x281f1c5d, 0x11b0ffc0), */
1669 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "cis/PCMLM28.cis"),
1670 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "cis/PCMLM28.cis"),
1671 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"),
1672 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"),
1673 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"),
1674 	PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "TOSHIBA", "Modem/LAN Card", 0xb4585a1a, 0x53f922f8, "cis/PCMLM28.cis"),
1675 	PCMCIA_MFC_DEVICE_CIS_PROD_ID12(0, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "cis/DP83903.cis"),
1676 	PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"),
1677 	PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "cis/DP83903.cis"),
1678 	PCMCIA_DEVICE_CIS_PROD_ID12("Allied Telesis,K.K", "Ethernet LAN Card", 0x2ad62f3c, 0x9fd2f0a2, "cis/LA-PCM.cis"),
1679 	PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "cis/PE520.cis"),
1680 	PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "cis/NE2K.cis"),
1681 	PCMCIA_DEVICE_CIS_PROD_ID12("PMX   ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "cis/PE-200.cis"),
1682 	PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "cis/tamarack.cis"),
1683 	PCMCIA_DEVICE_PROD_ID12("Ethernet", "CF Size PC Card", 0x00b2e941, 0x43ac239b),
1684 	PCMCIA_DEVICE_PROD_ID123("Fast Ethernet", "CF Size PC Card", "1.0",
1685 		0xb4be14e3, 0x43ac239b, 0x0877b627),
1686 	PCMCIA_DEVICE_NULL
1687 };
1688 MODULE_DEVICE_TABLE(pcmcia, pcnet_ids);
1689 MODULE_FIRMWARE("cis/PCMLM28.cis");
1690 MODULE_FIRMWARE("cis/DP83903.cis");
1691 MODULE_FIRMWARE("cis/LA-PCM.cis");
1692 MODULE_FIRMWARE("cis/PE520.cis");
1693 MODULE_FIRMWARE("cis/NE2K.cis");
1694 MODULE_FIRMWARE("cis/PE-200.cis");
1695 MODULE_FIRMWARE("cis/tamarack.cis");
1696 
1697 static struct pcmcia_driver pcnet_driver = {
1698 	.name		= "pcnet_cs",
1699 	.probe		= pcnet_probe,
1700 	.remove		= pcnet_detach,
1701 	.owner		= THIS_MODULE,
1702 	.id_table	= pcnet_ids,
1703 	.suspend	= pcnet_suspend,
1704 	.resume		= pcnet_resume,
1705 };
1706 module_pcmcia_driver(pcnet_driver);
1707