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