1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#define DRV_NAME "ne2k-pci"
29#define DRV_VERSION "1.03"
30#define DRV_RELDATE "9/22/2003"
31
32
33
34
35
36#define MAX_UNITS 8
37
38static int full_duplex[MAX_UNITS];
39static int options[MAX_UNITS];
40
41
42
43
44
45#include <linux/module.h>
46#include <linux/kernel.h>
47#include <linux/errno.h>
48#include <linux/pci.h>
49#include <linux/init.h>
50#include <linux/interrupt.h>
51#include <linux/ethtool.h>
52#include <linux/netdevice.h>
53#include <linux/etherdevice.h>
54
55#include <asm/io.h>
56#include <asm/irq.h>
57#include <asm/uaccess.h>
58
59#include "8390.h"
60
61static u32 ne2k_msg_enable;
62
63
64static const char version[] =
65 KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE
66 " D. Becker/P. Gortmaker\n";
67
68#if defined(__powerpc__)
69#define inl_le(addr) le32_to_cpu(inl(addr))
70#define inw_le(addr) le16_to_cpu(inw(addr))
71#endif
72
73#define PFX DRV_NAME ": "
74
75MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
76MODULE_DESCRIPTION("PCI NE2000 clone driver");
77MODULE_LICENSE("GPL");
78
79module_param_named(msg_enable, ne2k_msg_enable, uint, (S_IRUSR|S_IRGRP|S_IROTH));
80module_param_array(options, int, NULL, 0);
81module_param_array(full_duplex, int, NULL, 0);
82MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
83MODULE_PARM_DESC(options, "Bit 5: full duplex");
84MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
85
86
87
88
89#define USE_LONGIO
90
91
92
93
94
95
96#define ne2k_flags reg0
97enum {
98 ONLY_16BIT_IO=8, ONLY_32BIT_IO=4,
99 FORCE_FDX=0x20,
100 REALTEK_FDX=0x40, HOLTEK_FDX=0x80,
101 STOP_PG_0x60=0x100,
102};
103
104enum ne2k_pci_chipsets {
105 CH_RealTek_RTL_8029 = 0,
106 CH_Winbond_89C940,
107 CH_Compex_RL2000,
108 CH_KTI_ET32P2,
109 CH_NetVin_NV5000SC,
110 CH_Via_86C926,
111 CH_SureCom_NE34,
112 CH_Winbond_W89C940F,
113 CH_Holtek_HT80232,
114 CH_Holtek_HT80229,
115 CH_Winbond_89C940_8c4a,
116};
117
118
119static struct {
120 char *name;
121 int flags;
122} pci_clone_list[] = {
123 {"RealTek RTL-8029", REALTEK_FDX},
124 {"Winbond 89C940", 0},
125 {"Compex RL2000", 0},
126 {"KTI ET32P2", 0},
127 {"NetVin NV5000SC", 0},
128 {"Via 86C926", ONLY_16BIT_IO},
129 {"SureCom NE34", 0},
130 {"Winbond W89C940F", 0},
131 {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
132 {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
133 {"Winbond W89C940(misprogrammed)", 0},
134 {NULL,}
135};
136
137
138static const struct pci_device_id ne2k_pci_tbl[] = {
139 { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
140 { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
141 { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
142 { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
143 { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
144 { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
145 { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
146 { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
147 { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
148 { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
149 { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
150 { 0, }
151};
152MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
153
154
155
156
157#define NE_BASE (dev->base_addr)
158#define NE_CMD 0x00
159#define NE_DATAPORT 0x10
160#define NE_RESET 0x1f
161#define NE_IO_EXTENT 0x20
162
163#define NESM_START_PG 0x40
164#define NESM_STOP_PG 0x80
165
166
167static int ne2k_pci_open(struct net_device *dev);
168static int ne2k_pci_close(struct net_device *dev);
169
170static void ne2k_pci_reset_8390(struct net_device *dev);
171static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
172 int ring_page);
173static void ne2k_pci_block_input(struct net_device *dev, int count,
174 struct sk_buff *skb, int ring_offset);
175static void ne2k_pci_block_output(struct net_device *dev, const int count,
176 const unsigned char *buf, const int start_page);
177static const struct ethtool_ops ne2k_pci_ethtool_ops;
178
179
180
181
182
183struct ne2k_pci_card {
184 struct net_device *dev;
185 struct pci_dev *pci_dev;
186};
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203static const struct net_device_ops ne2k_netdev_ops = {
204 .ndo_open = ne2k_pci_open,
205 .ndo_stop = ne2k_pci_close,
206 .ndo_start_xmit = ei_start_xmit,
207 .ndo_tx_timeout = ei_tx_timeout,
208 .ndo_get_stats = ei_get_stats,
209 .ndo_set_rx_mode = ei_set_multicast_list,
210 .ndo_validate_addr = eth_validate_addr,
211 .ndo_set_mac_address = eth_mac_addr,
212 .ndo_change_mtu = eth_change_mtu,
213#ifdef CONFIG_NET_POLL_CONTROLLER
214 .ndo_poll_controller = ei_poll,
215#endif
216};
217
218static int ne2k_pci_init_one(struct pci_dev *pdev,
219 const struct pci_device_id *ent)
220{
221 struct net_device *dev;
222 int i;
223 unsigned char SA_prom[32];
224 int start_page, stop_page;
225 int irq, reg0, chip_idx = ent->driver_data;
226 static unsigned int fnd_cnt;
227 long ioaddr;
228 int flags = pci_clone_list[chip_idx].flags;
229 struct ei_device *ei_local;
230
231
232#ifndef MODULE
233 static int printed_version;
234 if (!printed_version++)
235 printk(version);
236#endif
237
238 fnd_cnt++;
239
240 i = pci_enable_device (pdev);
241 if (i)
242 return i;
243
244 ioaddr = pci_resource_start (pdev, 0);
245 irq = pdev->irq;
246
247 if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
248 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
249 goto err_out;
250 }
251
252 if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
253 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
254 NE_IO_EXTENT, ioaddr);
255 goto err_out;
256 }
257
258 reg0 = inb(ioaddr);
259 if (reg0 == 0xFF)
260 goto err_out_free_res;
261
262
263 {
264 int regd;
265 outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
266 regd = inb(ioaddr + 0x0d);
267 outb(0xff, ioaddr + 0x0d);
268 outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
269 inb(ioaddr + EN0_COUNTER0);
270 if (inb(ioaddr + EN0_COUNTER0) != 0) {
271 outb(reg0, ioaddr);
272 outb(regd, ioaddr + 0x0d);
273 goto err_out_free_res;
274 }
275 }
276
277
278 dev = alloc_ei_netdev();
279 if (!dev) {
280 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
281 goto err_out_free_res;
282 }
283 dev->netdev_ops = &ne2k_netdev_ops;
284 ei_local = netdev_priv(dev);
285 ei_local->msg_enable = ne2k_msg_enable;
286
287 SET_NETDEV_DEV(dev, &pdev->dev);
288
289
290 {
291 unsigned long reset_start_time = jiffies;
292
293 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
294
295
296
297
298 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
299
300 if (jiffies - reset_start_time > 2) {
301 dev_err(&pdev->dev,
302 "Card failure (no reset ack).\n");
303 goto err_out_free_netdev;
304 }
305
306 outb(0xff, ioaddr + EN0_ISR);
307 }
308
309
310
311
312
313 {
314 struct {unsigned char value, offset; } program_seq[] = {
315 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD},
316 {0x49, EN0_DCFG},
317 {0x00, EN0_RCNTLO},
318 {0x00, EN0_RCNTHI},
319 {0x00, EN0_IMR},
320 {0xFF, EN0_ISR},
321 {E8390_RXOFF, EN0_RXCR},
322 {E8390_TXOFF, EN0_TXCR},
323 {32, EN0_RCNTLO},
324 {0x00, EN0_RCNTHI},
325 {0x00, EN0_RSARLO},
326 {0x00, EN0_RSARHI},
327 {E8390_RREAD+E8390_START, E8390_CMD},
328 };
329 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
330 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
331
332 }
333
334
335
336 if (flags & ONLY_32BIT_IO) {
337 for (i = 0; i < 4 ; i++)
338 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
339 } else
340 for(i = 0; i < 32 ; i++)
341 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
342
343
344 outb(0x49, ioaddr + EN0_DCFG);
345 start_page = NESM_START_PG;
346
347 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
348
349
350 dev->irq = irq;
351 dev->base_addr = ioaddr;
352 pci_set_drvdata(pdev, dev);
353
354 ei_status.name = pci_clone_list[chip_idx].name;
355 ei_status.tx_start_page = start_page;
356 ei_status.stop_page = stop_page;
357 ei_status.word16 = 1;
358 ei_status.ne2k_flags = flags;
359 if (fnd_cnt < MAX_UNITS) {
360 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
361 ei_status.ne2k_flags |= FORCE_FDX;
362 }
363
364 ei_status.rx_start_page = start_page + TX_PAGES;
365#ifdef PACKETBUF_MEMSIZE
366
367 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
368#endif
369
370 ei_status.reset_8390 = &ne2k_pci_reset_8390;
371 ei_status.block_input = &ne2k_pci_block_input;
372 ei_status.block_output = &ne2k_pci_block_output;
373 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
374 ei_status.priv = (unsigned long) pdev;
375
376 dev->ethtool_ops = &ne2k_pci_ethtool_ops;
377 NS8390_init(dev, 0);
378
379 memcpy(dev->dev_addr, SA_prom, dev->addr_len);
380
381 i = register_netdev(dev);
382 if (i)
383 goto err_out_free_netdev;
384
385 netdev_info(dev, "%s found at %#lx, IRQ %d, %pM.\n",
386 pci_clone_list[chip_idx].name, ioaddr, dev->irq,
387 dev->dev_addr);
388
389 return 0;
390
391err_out_free_netdev:
392 free_netdev (dev);
393err_out_free_res:
394 release_region (ioaddr, NE_IO_EXTENT);
395err_out:
396 pci_disable_device(pdev);
397 return -ENODEV;
398}
399
400
401
402
403static inline int set_realtek_fdx(struct net_device *dev)
404{
405 long ioaddr = dev->base_addr;
406
407 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD);
408 outb(0xC0, ioaddr + 0x01);
409 outb(0x40, ioaddr + 0x06);
410 outb(0x00, ioaddr + 0x01);
411 outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD);
412 return 0;
413}
414
415static inline int set_holtek_fdx(struct net_device *dev)
416{
417 long ioaddr = dev->base_addr;
418
419 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
420 return 0;
421}
422
423static int ne2k_pci_set_fdx(struct net_device *dev)
424{
425 if (ei_status.ne2k_flags & REALTEK_FDX)
426 return set_realtek_fdx(dev);
427 else if (ei_status.ne2k_flags & HOLTEK_FDX)
428 return set_holtek_fdx(dev);
429
430 return -EOPNOTSUPP;
431}
432
433static int ne2k_pci_open(struct net_device *dev)
434{
435 int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
436 if (ret)
437 return ret;
438
439 if (ei_status.ne2k_flags & FORCE_FDX)
440 ne2k_pci_set_fdx(dev);
441
442 ei_open(dev);
443 return 0;
444}
445
446static int ne2k_pci_close(struct net_device *dev)
447{
448 ei_close(dev);
449 free_irq(dev->irq, dev);
450 return 0;
451}
452
453
454
455static void ne2k_pci_reset_8390(struct net_device *dev)
456{
457 unsigned long reset_start_time = jiffies;
458 struct ei_device *ei_local = netdev_priv(dev);
459
460 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n",
461 jiffies);
462
463 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
464
465 ei_status.txing = 0;
466 ei_status.dmaing = 0;
467
468
469 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
470 if (jiffies - reset_start_time > 2) {
471 netdev_err(dev, "ne2k_pci_reset_8390() did not complete.\n");
472 break;
473 }
474 outb(ENISR_RESET, NE_BASE + EN0_ISR);
475}
476
477
478
479
480
481static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
482{
483
484 long nic_base = dev->base_addr;
485
486
487 if (ei_status.dmaing) {
488 netdev_err(dev, "DMAing conflict in ne2k_pci_get_8390_hdr "
489 "[DMAstat:%d][irqlock:%d].\n",
490 ei_status.dmaing, ei_status.irqlock);
491 return;
492 }
493
494 ei_status.dmaing |= 0x01;
495 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
496 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
497 outb(0, nic_base + EN0_RCNTHI);
498 outb(0, nic_base + EN0_RSARLO);
499 outb(ring_page, nic_base + EN0_RSARHI);
500 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
501
502 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
503 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
504 } else {
505 *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
506 le16_to_cpus(&hdr->count);
507 }
508
509 outb(ENISR_RDC, nic_base + EN0_ISR);
510 ei_status.dmaing &= ~0x01;
511}
512
513
514
515
516
517
518static void ne2k_pci_block_input(struct net_device *dev, int count,
519 struct sk_buff *skb, int ring_offset)
520{
521 long nic_base = dev->base_addr;
522 char *buf = skb->data;
523
524
525 if (ei_status.dmaing) {
526 netdev_err(dev, "DMAing conflict in ne2k_pci_block_input "
527 "[DMAstat:%d][irqlock:%d].\n",
528 ei_status.dmaing, ei_status.irqlock);
529 return;
530 }
531 ei_status.dmaing |= 0x01;
532 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
533 count = (count + 3) & 0xFFFC;
534 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
535 outb(count & 0xff, nic_base + EN0_RCNTLO);
536 outb(count >> 8, nic_base + EN0_RCNTHI);
537 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
538 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
539 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
540
541 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
542 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
543 if (count & 0x01) {
544 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
545 }
546 } else {
547 insl(NE_BASE + NE_DATAPORT, buf, count>>2);
548 if (count & 3) {
549 buf += count & ~3;
550 if (count & 2) {
551 __le16 *b = (__le16 *)buf;
552
553 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
554 buf = (char *)b;
555 }
556 if (count & 1)
557 *buf = inb(NE_BASE + NE_DATAPORT);
558 }
559 }
560
561 outb(ENISR_RDC, nic_base + EN0_ISR);
562 ei_status.dmaing &= ~0x01;
563}
564
565static void ne2k_pci_block_output(struct net_device *dev, int count,
566 const unsigned char *buf, const int start_page)
567{
568 long nic_base = NE_BASE;
569 unsigned long dma_start;
570
571
572
573 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
574 count = (count + 3) & 0xFFFC;
575 else
576 if (count & 0x01)
577 count++;
578
579
580 if (ei_status.dmaing) {
581 netdev_err(dev, "DMAing conflict in ne2k_pci_block_output."
582 "[DMAstat:%d][irqlock:%d]\n",
583 ei_status.dmaing, ei_status.irqlock);
584 return;
585 }
586 ei_status.dmaing |= 0x01;
587
588 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
589
590#ifdef NE8390_RW_BUGFIX
591
592
593
594
595 outb(0x42, nic_base + EN0_RCNTLO);
596 outb(0x00, nic_base + EN0_RCNTHI);
597 outb(0x42, nic_base + EN0_RSARLO);
598 outb(0x00, nic_base + EN0_RSARHI);
599 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
600#endif
601 outb(ENISR_RDC, nic_base + EN0_ISR);
602
603
604 outb(count & 0xff, nic_base + EN0_RCNTLO);
605 outb(count >> 8, nic_base + EN0_RCNTHI);
606 outb(0x00, nic_base + EN0_RSARLO);
607 outb(start_page, nic_base + EN0_RSARHI);
608 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
609 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
610 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
611 } else {
612 outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
613 if (count & 3) {
614 buf += count & ~3;
615 if (count & 2) {
616 __le16 *b = (__le16 *)buf;
617
618 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
619 buf = (char *)b;
620 }
621 }
622 }
623
624 dma_start = jiffies;
625
626 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
627 if (jiffies - dma_start > 2) {
628 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
629 ne2k_pci_reset_8390(dev);
630 NS8390_init(dev,1);
631 break;
632 }
633
634 outb(ENISR_RDC, nic_base + EN0_ISR);
635 ei_status.dmaing &= ~0x01;
636}
637
638static void ne2k_pci_get_drvinfo(struct net_device *dev,
639 struct ethtool_drvinfo *info)
640{
641 struct ei_device *ei = netdev_priv(dev);
642 struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
643
644 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
645 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
646 strlcpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
647}
648
649static u32 ne2k_pci_get_msglevel(struct net_device *dev)
650{
651 struct ei_device *ei_local = netdev_priv(dev);
652
653 return ei_local->msg_enable;
654}
655
656static void ne2k_pci_set_msglevel(struct net_device *dev, u32 v)
657{
658 struct ei_device *ei_local = netdev_priv(dev);
659
660 ei_local->msg_enable = v;
661}
662
663static const struct ethtool_ops ne2k_pci_ethtool_ops = {
664 .get_drvinfo = ne2k_pci_get_drvinfo,
665 .get_msglevel = ne2k_pci_get_msglevel,
666 .set_msglevel = ne2k_pci_set_msglevel,
667};
668
669static void ne2k_pci_remove_one(struct pci_dev *pdev)
670{
671 struct net_device *dev = pci_get_drvdata(pdev);
672
673 BUG_ON(!dev);
674 unregister_netdev(dev);
675 release_region(dev->base_addr, NE_IO_EXTENT);
676 free_netdev(dev);
677 pci_disable_device(pdev);
678}
679
680#ifdef CONFIG_PM
681static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
682{
683 struct net_device *dev = pci_get_drvdata (pdev);
684
685 netif_device_detach(dev);
686 pci_save_state(pdev);
687 pci_disable_device(pdev);
688 pci_set_power_state(pdev, pci_choose_state(pdev, state));
689
690 return 0;
691}
692
693static int ne2k_pci_resume (struct pci_dev *pdev)
694{
695 struct net_device *dev = pci_get_drvdata (pdev);
696 int rc;
697
698 pci_set_power_state(pdev, PCI_D0);
699 pci_restore_state(pdev);
700
701 rc = pci_enable_device(pdev);
702 if (rc)
703 return rc;
704
705 NS8390_init(dev, 1);
706 netif_device_attach(dev);
707
708 return 0;
709}
710
711#endif
712
713
714static struct pci_driver ne2k_driver = {
715 .name = DRV_NAME,
716 .probe = ne2k_pci_init_one,
717 .remove = ne2k_pci_remove_one,
718 .id_table = ne2k_pci_tbl,
719#ifdef CONFIG_PM
720 .suspend = ne2k_pci_suspend,
721 .resume = ne2k_pci_resume,
722#endif
723
724};
725
726
727static int __init ne2k_pci_init(void)
728{
729
730#ifdef MODULE
731 printk(version);
732#endif
733 return pci_register_driver(&ne2k_driver);
734}
735
736
737static void __exit ne2k_pci_cleanup(void)
738{
739 pci_unregister_driver (&ne2k_driver);
740}
741
742module_init(ne2k_pci_init);
743module_exit(ne2k_pci_cleanup);
744