1 /* ne2k-pci.c: A NE2000 clone on PCI bus driver for Linux. */
2 /*
3 A Linux device driver for PCI NE2000 clones.
4
5 Authors and other copyright holders:
6 1992-2000 by Donald Becker, NE2000 core and various modifications.
7 1995-1998 by Paul Gortmaker, core modifications and PCI support.
8 Copyright 1993 assigned to the United States Government as represented
9 by the Director, National Security Agency.
10
11 This software may be used and distributed according to the terms of
12 the GNU General Public License (GPL), incorporated herein by reference.
13 Drivers based on or derived from this code fall under the GPL and must
14 retain the authorship, copyright and license notice. This file is not
15 a complete program and may only be used when the entire operating
16 system is licensed under the GPL.
17
18 The author may be reached as becker@scyld.com, or C/O
19 Scyld Computing Corporation
20 410 Severn Ave., Suite 210
21 Annapolis MD 21403
22
23 Issues remaining:
24 People are making PCI ne2000 clones! Oh the horror, the horror...
25 Limited full-duplex support.
26 */
27
28 /* These identify the driver base version and may not be removed. */
29 static const char version1[] =
30 "ne2k-pci.c:v1.02 10/19/2000 D. Becker/P. Gortmaker\n";
31 static const char version2[] =
32 " http://www.scyld.com/network/ne2k-pci.html\n";
33
34 /* The user-configurable values.
35 These may be modified when a driver module is loaded.*/
36
37 static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
38
39 #define MAX_UNITS 8 /* More are supported, limit only on options */
40 /* Used to pass the full-duplex flag, etc. */
41 static int full_duplex[MAX_UNITS];
42 static int options[MAX_UNITS];
43
44 /* Force a non std. amount of memory. Units are 256 byte pages. */
45 /* #define PACKETBUF_MEMSIZE 0x40 */
46
47
48 #include <linux/module.h>
49 #include <linux/kernel.h>
50 #include <linux/sched.h>
51 #include <linux/errno.h>
52 #include <linux/pci.h>
53 #include <linux/init.h>
54
55 #include <asm/system.h>
56 #include <asm/io.h>
57 #include <asm/irq.h>
58
59 #include <linux/netdevice.h>
60 #include <linux/etherdevice.h>
61 #include "8390.h"
62
63 #if defined(__powerpc__)
64 #define inl_le(addr) le32_to_cpu(inl(addr))
65 #define inw_le(addr) le16_to_cpu(inw(addr))
66 #define insl insl_ns
67 #define outsl outsl_ns
68 #endif
69
70 MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
71 MODULE_DESCRIPTION("PCI NE2000 clone driver");
72 MODULE_PARM(debug, "i");
73 MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
74 MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
75
76 /* Some defines that people can play with if so inclined. */
77
78 /* Use 32 bit data-movement operations instead of 16 bit. */
79 #define USE_LONGIO
80
81 /* Do we implement the read before write bugfix ? */
82 /* #define NE_RW_BUGFIX */
83
84 /* Flags. We rename an existing ei_status field to store flags! */
85 /* Thus only the low 8 bits are usable for non-init-time flags. */
86 #define ne2k_flags reg0
87 enum {
88 ONLY_16BIT_IO=8, ONLY_32BIT_IO=4, /* Chip can do only 16/32-bit xfers. */
89 FORCE_FDX=0x20, /* User override. */
90 REALTEK_FDX=0x40, HOLTEK_FDX=0x80,
91 STOP_PG_0x60=0x100,
92 };
93
94 enum ne2k_pci_chipsets {
95 CH_RealTek_RTL_8029 = 0,
96 CH_Winbond_89C940,
97 CH_Compex_RL2000,
98 CH_KTI_ET32P2,
99 CH_NetVin_NV5000SC,
100 CH_Via_86C926,
101 CH_SureCom_NE34,
102 CH_Winbond_W89C940F,
103 CH_Holtek_HT80232,
104 CH_Holtek_HT80229,
105 };
106
107
108 static struct {
109 char *name;
110 int flags;
111 } pci_clone_list[] __devinitdata = {
112 {"RealTek RTL-8029", REALTEK_FDX},
113 {"Winbond 89C940", 0},
114 {"Compex RL2000", 0},
115 {"KTI ET32P2", 0},
116 {"NetVin NV5000SC", 0},
117 {"Via 86C926", ONLY_16BIT_IO},
118 {"SureCom NE34", 0},
119 {"Winbond W89C940F", 0},
120 {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
121 {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
122 {0,}
123 };
124
125
126 static struct pci_device_id ne2k_pci_tbl[] __devinitdata = {
127 { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
128 { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
129 { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
130 { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
131 { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
132 { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
133 { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
134 { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
135 { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
136 { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
137 { 0, }
138 };
139 MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
140
141
142 /* ---- No user-serviceable parts below ---- */
143
144 #define NE_BASE (dev->base_addr)
145 #define NE_CMD 0x00
146 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
147 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
148 #define NE_IO_EXTENT 0x20
149
150 #define NESM_START_PG 0x40 /* First page of TX buffer */
151 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
152
153
154 static int ne2k_pci_open(struct net_device *dev);
155 static int ne2k_pci_close(struct net_device *dev);
156
157 static void ne2k_pci_reset_8390(struct net_device *dev);
158 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
159 int ring_page);
160 static void ne2k_pci_block_input(struct net_device *dev, int count,
161 struct sk_buff *skb, int ring_offset);
162 static void ne2k_pci_block_output(struct net_device *dev, const int count,
163 const unsigned char *buf, const int start_page);
164
165
166
167 /* There is no room in the standard 8390 structure for extra info we need,
168 so we build a meta/outer-wrapper structure.. */
169 struct ne2k_pci_card {
170 struct net_device *dev;
171 struct pci_dev *pci_dev;
172 };
173
174
175
176 /*
177 NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
178 buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
179 0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
180 detected by their SA prefix.
181
182 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
183 mode results in doubled values, which can be detected and compensated for.
184
185 The probe is also responsible for initializing the card and filling
186 in the 'dev' and 'ei_status' structures.
187 */
188
189
190 static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
191 const struct pci_device_id *ent)
192 {
193 struct net_device *dev;
194 int i;
195 unsigned char SA_prom[32];
196 int start_page, stop_page;
197 int irq, reg0, chip_idx = ent->driver_data;
198 static unsigned int fnd_cnt;
199 long ioaddr;
200 int flags = pci_clone_list[chip_idx].flags;
201
202 if (fnd_cnt++ == 0)
203 printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
204
205 ioaddr = pci_resource_start (pdev, 0);
206 irq = pdev->irq;
207
208 if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
209 printk (KERN_ERR "ne2k-pci: no I/O resource at PCI BAR #0\n");
210 return -ENODEV;
211 }
212
213 i = pci_enable_device (pdev);
214 if (i)
215 return i;
216
217 if (request_region (ioaddr, NE_IO_EXTENT, "ne2k-pci") == NULL) {
218 printk (KERN_ERR "ne2k-pci: I/O resource 0x%x @ 0x%lx busy\n",
219 NE_IO_EXTENT, ioaddr);
220 return -EBUSY;
221 }
222
223 reg0 = inb(ioaddr);
224 if (reg0 == 0xFF)
225 goto err_out_free_res;
226
227 /* Do a preliminary verification that we have a 8390. */
228 {
229 int regd;
230 outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
231 regd = inb(ioaddr + 0x0d);
232 outb(0xff, ioaddr + 0x0d);
233 outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
234 inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
235 if (inb(ioaddr + EN0_COUNTER0) != 0) {
236 outb(reg0, ioaddr);
237 outb(regd, ioaddr + 0x0d); /* Restore the old values. */
238 goto err_out_free_res;
239 }
240 }
241
242 dev = init_etherdev(NULL, 0);
243 if (!dev) {
244 printk (KERN_ERR "ne2k-pci: cannot allocate ethernet device\n");
245 goto err_out_free_res;
246 }
247 SET_MODULE_OWNER(dev);
248
249 /* Reset card. Who knows what dain-bramaged state it was left in. */
250 {
251 unsigned long reset_start_time = jiffies;
252
253 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
254
255 /* This looks like a horrible timing loop, but it should never take
256 more than a few cycles.
257 */
258 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
259 /* Limit wait: '2' avoids jiffy roll-over. */
260 if (jiffies - reset_start_time > 2) {
261 printk("ne2k-pci: Card failure (no reset ack).\n");
262 goto err_out_free_netdev;
263 }
264
265 outb(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
266 }
267
268 /* Read the 16 bytes of station address PROM.
269 We must first initialize registers, similar to NS8390_init(eifdev, 0).
270 We can't reliably read the SAPROM address without this.
271 (I learned the hard way!). */
272 {
273 struct {unsigned char value, offset; } program_seq[] = {
274 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
275 {0x49, EN0_DCFG}, /* Set word-wide access. */
276 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
277 {0x00, EN0_RCNTHI},
278 {0x00, EN0_IMR}, /* Mask completion irq. */
279 {0xFF, EN0_ISR},
280 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
281 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
282 {32, EN0_RCNTLO},
283 {0x00, EN0_RCNTHI},
284 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
285 {0x00, EN0_RSARHI},
286 {E8390_RREAD+E8390_START, E8390_CMD},
287 };
288 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
289 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
290
291 }
292
293 /* Note: all PCI cards have at least 16 bit access, so we don't have
294 to check for 8 bit cards. Most cards permit 32 bit access. */
295 if (flags & ONLY_32BIT_IO) {
296 for (i = 0; i < 4 ; i++)
297 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
298 } else
299 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i++)
300 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
301
302 /* We always set the 8390 registers for word mode. */
303 outb(0x49, ioaddr + EN0_DCFG);
304 start_page = NESM_START_PG;
305
306 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
307
308 /* Set up the rest of the parameters. */
309 dev->irq = irq;
310 dev->base_addr = ioaddr;
311 pci_set_drvdata(pdev, dev);
312
313 /* Allocate dev->priv and fill in 8390 specific dev fields. */
314 if (ethdev_init(dev)) {
315 printk (KERN_ERR "%s: unable to get memory for dev->priv.\n", dev->name);
316 goto err_out_free_netdev;
317 }
318
319 printk("%s: %s found at %#lx, IRQ %d, ",
320 dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq);
321 for(i = 0; i < 6; i++) {
322 printk("%2.2X%s", SA_prom[i], i == 5 ? ".\n": ":");
323 dev->dev_addr[i] = SA_prom[i];
324 }
325
326 ei_status.name = pci_clone_list[chip_idx].name;
327 ei_status.tx_start_page = start_page;
328 ei_status.stop_page = stop_page;
329 ei_status.word16 = 1;
330 ei_status.ne2k_flags = flags;
331 if (fnd_cnt < MAX_UNITS) {
332 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
333 ei_status.ne2k_flags |= FORCE_FDX;
334 }
335
336 ei_status.rx_start_page = start_page + TX_PAGES;
337 #ifdef PACKETBUF_MEMSIZE
338 /* Allow the packet buffer size to be overridden by know-it-alls. */
339 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
340 #endif
341
342 ei_status.reset_8390 = &ne2k_pci_reset_8390;
343 ei_status.block_input = &ne2k_pci_block_input;
344 ei_status.block_output = &ne2k_pci_block_output;
345 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
346 dev->open = &ne2k_pci_open;
347 dev->stop = &ne2k_pci_close;
348 NS8390_init(dev, 0);
349 return 0;
350
351 err_out_free_netdev:
352 unregister_netdev (dev);
353 kfree (dev);
354 err_out_free_res:
355 release_region (ioaddr, NE_IO_EXTENT);
356 return -ENODEV;
357
358 }
359
360 static int ne2k_pci_open(struct net_device *dev)
361 {
362 int ret = request_irq(dev->irq, ei_interrupt, SA_SHIRQ, dev->name, dev);
363 if (ret)
364 return ret;
365
366 /* Set full duplex for the chips that we know about. */
367 if (ei_status.ne2k_flags & FORCE_FDX) {
368 long ioaddr = dev->base_addr;
369 if (ei_status.ne2k_flags & REALTEK_FDX) {
370 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
371 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
372 } else if (ei_status.ne2k_flags & HOLTEK_FDX)
373 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
374 }
375 ei_open(dev);
376 return 0;
377 }
378
379 static int ne2k_pci_close(struct net_device *dev)
380 {
381 ei_close(dev);
382 free_irq(dev->irq, dev);
383 return 0;
384 }
385
386 /* Hard reset the card. This used to pause for the same period that a
387 8390 reset command required, but that shouldn't be necessary. */
388 static void ne2k_pci_reset_8390(struct net_device *dev)
389 {
390 unsigned long reset_start_time = jiffies;
391
392 if (debug > 1) printk("%s: Resetting the 8390 t=%ld...",
393 dev->name, jiffies);
394
395 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
396
397 ei_status.txing = 0;
398 ei_status.dmaing = 0;
399
400 /* This check _should_not_ be necessary, omit eventually. */
401 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
402 if (jiffies - reset_start_time > 2) {
403 printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev->name);
404 break;
405 }
406 outb(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
407 }
408
409 /* Grab the 8390 specific header. Similar to the block_input routine, but
410 we don't need to be concerned with ring wrap as the header will be at
411 the start of a page, so we optimize accordingly. */
412
413 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
414 {
415
416 long nic_base = dev->base_addr;
417
418 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
419 if (ei_status.dmaing) {
420 printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
421 "[DMAstat:%d][irqlock:%d].\n",
422 dev->name, ei_status.dmaing, ei_status.irqlock);
423 return;
424 }
425
426 ei_status.dmaing |= 0x01;
427 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
428 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
429 outb(0, nic_base + EN0_RCNTHI);
430 outb(0, nic_base + EN0_RSARLO); /* On page boundary */
431 outb(ring_page, nic_base + EN0_RSARHI);
432 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
433
434 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
435 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
436 } else {
437 *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
438 le16_to_cpus(&hdr->count);
439 }
440
441 outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
442 ei_status.dmaing &= ~0x01;
443 }
444
445 /* Block input and output, similar to the Crynwr packet driver. If you
446 are porting to a new ethercard, look at the packet driver source for hints.
447 The NEx000 doesn't share the on-board packet memory -- you have to put
448 the packet out through the "remote DMA" dataport using outb. */
449
450 static void ne2k_pci_block_input(struct net_device *dev, int count,
451 struct sk_buff *skb, int ring_offset)
452 {
453 long nic_base = dev->base_addr;
454 char *buf = skb->data;
455
456 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
457 if (ei_status.dmaing) {
458 printk("%s: DMAing conflict in ne2k_pci_block_input "
459 "[DMAstat:%d][irqlock:%d].\n",
460 dev->name, ei_status.dmaing, ei_status.irqlock);
461 return;
462 }
463 ei_status.dmaing |= 0x01;
464 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
465 count = (count + 3) & 0xFFFC;
466 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
467 outb(count & 0xff, nic_base + EN0_RCNTLO);
468 outb(count >> 8, nic_base + EN0_RCNTHI);
469 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
470 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
471 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
472
473 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
474 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
475 if (count & 0x01) {
476 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
477 }
478 } else {
479 insl(NE_BASE + NE_DATAPORT, buf, count>>2);
480 if (count & 3) {
481 buf += count & ~3;
482 if (count & 2)
483 *((u16*)buf)++ = le16_to_cpu(inw(NE_BASE + NE_DATAPORT));
484 if (count & 1)
485 *buf = inb(NE_BASE + NE_DATAPORT);
486 }
487 }
488
489 outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
490 ei_status.dmaing &= ~0x01;
491 }
492
493 static void ne2k_pci_block_output(struct net_device *dev, int count,
494 const unsigned char *buf, const int start_page)
495 {
496 long nic_base = NE_BASE;
497 unsigned long dma_start;
498
499 /* On little-endian it's always safe to round the count up for
500 word writes. */
501 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
502 count = (count + 3) & 0xFFFC;
503 else
504 if (count & 0x01)
505 count++;
506
507 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
508 if (ei_status.dmaing) {
509 printk("%s: DMAing conflict in ne2k_pci_block_output."
510 "[DMAstat:%d][irqlock:%d]\n",
511 dev->name, ei_status.dmaing, ei_status.irqlock);
512 return;
513 }
514 ei_status.dmaing |= 0x01;
515 /* We should already be in page 0, but to be safe... */
516 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
517
518 #ifdef NE8390_RW_BUGFIX
519 /* Handle the read-before-write bug the same way as the
520 Crynwr packet driver -- the NatSemi method doesn't work.
521 Actually this doesn't always work either, but if you have
522 problems with your NEx000 this is better than nothing! */
523 outb(0x42, nic_base + EN0_RCNTLO);
524 outb(0x00, nic_base + EN0_RCNTHI);
525 outb(0x42, nic_base + EN0_RSARLO);
526 outb(0x00, nic_base + EN0_RSARHI);
527 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
528 #endif
529 outb(ENISR_RDC, nic_base + EN0_ISR);
530
531 /* Now the normal output. */
532 outb(count & 0xff, nic_base + EN0_RCNTLO);
533 outb(count >> 8, nic_base + EN0_RCNTHI);
534 outb(0x00, nic_base + EN0_RSARLO);
535 outb(start_page, nic_base + EN0_RSARHI);
536 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
537 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
538 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
539 } else {
540 outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
541 if (count & 3) {
542 buf += count & ~3;
543 if (count & 2)
544 outw(cpu_to_le16(*((u16*)buf)++), NE_BASE + NE_DATAPORT);
545 }
546 }
547
548 dma_start = jiffies;
549
550 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
551 if (jiffies - dma_start > 2) { /* Avoid clock roll-over. */
552 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
553 ne2k_pci_reset_8390(dev);
554 NS8390_init(dev,1);
555 break;
556 }
557
558 outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
559 ei_status.dmaing &= ~0x01;
560 return;
561 }
562
563
564 static void __devexit ne2k_pci_remove_one (struct pci_dev *pdev)
565 {
566 struct net_device *dev = pci_get_drvdata(pdev);
567
568 if (!dev)
569 BUG();
570
571 unregister_netdev(dev);
572 release_region(dev->base_addr, NE_IO_EXTENT);
573 kfree(dev);
574 pci_set_drvdata(pdev, NULL);
575 }
576
577
578 static struct pci_driver ne2k_driver = {
579 name: "ne2k-pci",
580 probe: ne2k_pci_init_one,
581 remove: ne2k_pci_remove_one,
582 id_table: ne2k_pci_tbl,
583 };
584
585
586 static int __init ne2k_pci_init(void)
587 {
588 return pci_module_init (&ne2k_driver);
589 }
590
591
592 static void __exit ne2k_pci_cleanup(void)
593 {
594 pci_unregister_driver (&ne2k_driver);
595 }
596
597 module_init(ne2k_pci_init);
598 module_exit(ne2k_pci_cleanup);
599
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.