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
36static int debug = 1;
37
38#define MAX_UNITS 8
39
40static int full_duplex[MAX_UNITS];
41static int options[MAX_UNITS];
42
43
44
45
46
47#include <linux/module.h>
48#include <linux/kernel.h>
49#include <linux/errno.h>
50#include <linux/pci.h>
51#include <linux/init.h>
52#include <linux/interrupt.h>
53#include <linux/ethtool.h>
54#include <linux/netdevice.h>
55#include <linux/etherdevice.h>
56
57#include <asm/io.h>
58#include <asm/irq.h>
59#include <asm/uaccess.h>
60
61#include "8390.h"
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(debug, int, 0);
80module_param_array(options, int, NULL, 0);
81module_param_array(full_duplex, int, NULL, 0);
82MODULE_PARM_DESC(debug, "debug level (1-2)");
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 DEFINE_PCI_DEVICE_TABLE(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
230
231#ifndef MODULE
232 static int printed_version;
233 if (!printed_version++)
234 printk(version);
235#endif
236
237 fnd_cnt++;
238
239 i = pci_enable_device (pdev);
240 if (i)
241 return i;
242
243 ioaddr = pci_resource_start (pdev, 0);
244 irq = pdev->irq;
245
246 if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
247 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
248 return -ENODEV;
249 }
250
251 if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
252 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
253 NE_IO_EXTENT, ioaddr);
254 return -EBUSY;
255 }
256
257 reg0 = inb(ioaddr);
258 if (reg0 == 0xFF)
259 goto err_out_free_res;
260
261
262 {
263 int regd;
264 outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
265 regd = inb(ioaddr + 0x0d);
266 outb(0xff, ioaddr + 0x0d);
267 outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
268 inb(ioaddr + EN0_COUNTER0);
269 if (inb(ioaddr + EN0_COUNTER0) != 0) {
270 outb(reg0, ioaddr);
271 outb(regd, ioaddr + 0x0d);
272 goto err_out_free_res;
273 }
274 }
275
276
277 dev = alloc_ei_netdev();
278 if (!dev) {
279 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
280 goto err_out_free_res;
281 }
282 dev->netdev_ops = &ne2k_netdev_ops;
283
284 SET_NETDEV_DEV(dev, &pdev->dev);
285
286
287 {
288 unsigned long reset_start_time = jiffies;
289
290 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
291
292
293
294
295 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
296
297 if (jiffies - reset_start_time > 2) {
298 dev_err(&pdev->dev,
299 "Card failure (no reset ack).\n");
300 goto err_out_free_netdev;
301 }
302
303 outb(0xff, ioaddr + EN0_ISR);
304 }
305
306
307
308
309
310 {
311 struct {unsigned char value, offset; } program_seq[] = {
312 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD},
313 {0x49, EN0_DCFG},
314 {0x00, EN0_RCNTLO},
315 {0x00, EN0_RCNTHI},
316 {0x00, EN0_IMR},
317 {0xFF, EN0_ISR},
318 {E8390_RXOFF, EN0_RXCR},
319 {E8390_TXOFF, EN0_TXCR},
320 {32, EN0_RCNTLO},
321 {0x00, EN0_RCNTHI},
322 {0x00, EN0_RSARLO},
323 {0x00, EN0_RSARHI},
324 {E8390_RREAD+E8390_START, E8390_CMD},
325 };
326 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
327 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
328
329 }
330
331
332
333 if (flags & ONLY_32BIT_IO) {
334 for (i = 0; i < 4 ; i++)
335 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
336 } else
337 for(i = 0; i < 32 ; i++)
338 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
339
340
341 outb(0x49, ioaddr + EN0_DCFG);
342 start_page = NESM_START_PG;
343
344 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
345
346
347 dev->irq = irq;
348 dev->base_addr = ioaddr;
349 pci_set_drvdata(pdev, dev);
350
351 ei_status.name = pci_clone_list[chip_idx].name;
352 ei_status.tx_start_page = start_page;
353 ei_status.stop_page = stop_page;
354 ei_status.word16 = 1;
355 ei_status.ne2k_flags = flags;
356 if (fnd_cnt < MAX_UNITS) {
357 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
358 ei_status.ne2k_flags |= FORCE_FDX;
359 }
360
361 ei_status.rx_start_page = start_page + TX_PAGES;
362#ifdef PACKETBUF_MEMSIZE
363
364 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
365#endif
366
367 ei_status.reset_8390 = &ne2k_pci_reset_8390;
368 ei_status.block_input = &ne2k_pci_block_input;
369 ei_status.block_output = &ne2k_pci_block_output;
370 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
371 ei_status.priv = (unsigned long) pdev;
372
373 dev->ethtool_ops = &ne2k_pci_ethtool_ops;
374 NS8390_init(dev, 0);
375
376 memcpy(dev->dev_addr, SA_prom, dev->addr_len);
377
378 i = register_netdev(dev);
379 if (i)
380 goto err_out_free_netdev;
381
382 printk("%s: %s found at %#lx, IRQ %d, %pM.\n",
383 dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq,
384 dev->dev_addr);
385
386 return 0;
387
388err_out_free_netdev:
389 free_netdev (dev);
390err_out_free_res:
391 release_region (ioaddr, NE_IO_EXTENT);
392 pci_set_drvdata (pdev, NULL);
393 return -ENODEV;
394
395}
396
397
398
399
400static inline int set_realtek_fdx(struct net_device *dev)
401{
402 long ioaddr = dev->base_addr;
403
404 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD);
405 outb(0xC0, ioaddr + 0x01);
406 outb(0x40, ioaddr + 0x06);
407 outb(0x00, ioaddr + 0x01);
408 outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD);
409 return 0;
410}
411
412static inline int set_holtek_fdx(struct net_device *dev)
413{
414 long ioaddr = dev->base_addr;
415
416 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
417 return 0;
418}
419
420static int ne2k_pci_set_fdx(struct net_device *dev)
421{
422 if (ei_status.ne2k_flags & REALTEK_FDX)
423 return set_realtek_fdx(dev);
424 else if (ei_status.ne2k_flags & HOLTEK_FDX)
425 return set_holtek_fdx(dev);
426
427 return -EOPNOTSUPP;
428}
429
430static int ne2k_pci_open(struct net_device *dev)
431{
432 int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
433 if (ret)
434 return ret;
435
436 if (ei_status.ne2k_flags & FORCE_FDX)
437 ne2k_pci_set_fdx(dev);
438
439 ei_open(dev);
440 return 0;
441}
442
443static int ne2k_pci_close(struct net_device *dev)
444{
445 ei_close(dev);
446 free_irq(dev->irq, dev);
447 return 0;
448}
449
450
451
452static void ne2k_pci_reset_8390(struct net_device *dev)
453{
454 unsigned long reset_start_time = jiffies;
455
456 if (debug > 1) printk("%s: Resetting the 8390 t=%ld...",
457 dev->name, jiffies);
458
459 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
460
461 ei_status.txing = 0;
462 ei_status.dmaing = 0;
463
464
465 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
466 if (jiffies - reset_start_time > 2) {
467 printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev->name);
468 break;
469 }
470 outb(ENISR_RESET, NE_BASE + EN0_ISR);
471}
472
473
474
475
476
477static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
478{
479
480 long nic_base = dev->base_addr;
481
482
483 if (ei_status.dmaing) {
484 printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
485 "[DMAstat:%d][irqlock:%d].\n",
486 dev->name, ei_status.dmaing, ei_status.irqlock);
487 return;
488 }
489
490 ei_status.dmaing |= 0x01;
491 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
492 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
493 outb(0, nic_base + EN0_RCNTHI);
494 outb(0, nic_base + EN0_RSARLO);
495 outb(ring_page, nic_base + EN0_RSARHI);
496 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
497
498 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
499 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
500 } else {
501 *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
502 le16_to_cpus(&hdr->count);
503 }
504
505 outb(ENISR_RDC, nic_base + EN0_ISR);
506 ei_status.dmaing &= ~0x01;
507}
508
509
510
511
512
513
514static void ne2k_pci_block_input(struct net_device *dev, int count,
515 struct sk_buff *skb, int ring_offset)
516{
517 long nic_base = dev->base_addr;
518 char *buf = skb->data;
519
520
521 if (ei_status.dmaing) {
522 printk("%s: DMAing conflict in ne2k_pci_block_input "
523 "[DMAstat:%d][irqlock:%d].\n",
524 dev->name, ei_status.dmaing, ei_status.irqlock);
525 return;
526 }
527 ei_status.dmaing |= 0x01;
528 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
529 count = (count + 3) & 0xFFFC;
530 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
531 outb(count & 0xff, nic_base + EN0_RCNTLO);
532 outb(count >> 8, nic_base + EN0_RCNTHI);
533 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
534 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
535 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
536
537 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
538 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
539 if (count & 0x01) {
540 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
541 }
542 } else {
543 insl(NE_BASE + NE_DATAPORT, buf, count>>2);
544 if (count & 3) {
545 buf += count & ~3;
546 if (count & 2) {
547 __le16 *b = (__le16 *)buf;
548
549 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
550 buf = (char *)b;
551 }
552 if (count & 1)
553 *buf = inb(NE_BASE + NE_DATAPORT);
554 }
555 }
556
557 outb(ENISR_RDC, nic_base + EN0_ISR);
558 ei_status.dmaing &= ~0x01;
559}
560
561static void ne2k_pci_block_output(struct net_device *dev, int count,
562 const unsigned char *buf, const int start_page)
563{
564 long nic_base = NE_BASE;
565 unsigned long dma_start;
566
567
568
569 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
570 count = (count + 3) & 0xFFFC;
571 else
572 if (count & 0x01)
573 count++;
574
575
576 if (ei_status.dmaing) {
577 printk("%s: DMAing conflict in ne2k_pci_block_output."
578 "[DMAstat:%d][irqlock:%d]\n",
579 dev->name, ei_status.dmaing, ei_status.irqlock);
580 return;
581 }
582 ei_status.dmaing |= 0x01;
583
584 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
585
586#ifdef NE8390_RW_BUGFIX
587
588
589
590
591 outb(0x42, nic_base + EN0_RCNTLO);
592 outb(0x00, nic_base + EN0_RCNTHI);
593 outb(0x42, nic_base + EN0_RSARLO);
594 outb(0x00, nic_base + EN0_RSARHI);
595 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
596#endif
597 outb(ENISR_RDC, nic_base + EN0_ISR);
598
599
600 outb(count & 0xff, nic_base + EN0_RCNTLO);
601 outb(count >> 8, nic_base + EN0_RCNTHI);
602 outb(0x00, nic_base + EN0_RSARLO);
603 outb(start_page, nic_base + EN0_RSARHI);
604 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
605 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
606 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
607 } else {
608 outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
609 if (count & 3) {
610 buf += count & ~3;
611 if (count & 2) {
612 __le16 *b = (__le16 *)buf;
613
614 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
615 buf = (char *)b;
616 }
617 }
618 }
619
620 dma_start = jiffies;
621
622 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
623 if (jiffies - dma_start > 2) {
624 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
625 ne2k_pci_reset_8390(dev);
626 NS8390_init(dev,1);
627 break;
628 }
629
630 outb(ENISR_RDC, nic_base + EN0_ISR);
631 ei_status.dmaing &= ~0x01;
632}
633
634static void ne2k_pci_get_drvinfo(struct net_device *dev,
635 struct ethtool_drvinfo *info)
636{
637 struct ei_device *ei = netdev_priv(dev);
638 struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
639
640 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
641 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
642 strlcpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
643}
644
645static const struct ethtool_ops ne2k_pci_ethtool_ops = {
646 .get_drvinfo = ne2k_pci_get_drvinfo,
647};
648
649static void ne2k_pci_remove_one(struct pci_dev *pdev)
650{
651 struct net_device *dev = pci_get_drvdata(pdev);
652
653 BUG_ON(!dev);
654 unregister_netdev(dev);
655 release_region(dev->base_addr, NE_IO_EXTENT);
656 free_netdev(dev);
657 pci_disable_device(pdev);
658 pci_set_drvdata(pdev, NULL);
659}
660
661#ifdef CONFIG_PM
662static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
663{
664 struct net_device *dev = pci_get_drvdata (pdev);
665
666 netif_device_detach(dev);
667 pci_save_state(pdev);
668 pci_disable_device(pdev);
669 pci_set_power_state(pdev, pci_choose_state(pdev, state));
670
671 return 0;
672}
673
674static int ne2k_pci_resume (struct pci_dev *pdev)
675{
676 struct net_device *dev = pci_get_drvdata (pdev);
677 int rc;
678
679 pci_set_power_state(pdev, PCI_D0);
680 pci_restore_state(pdev);
681
682 rc = pci_enable_device(pdev);
683 if (rc)
684 return rc;
685
686 NS8390_init(dev, 1);
687 netif_device_attach(dev);
688
689 return 0;
690}
691
692#endif
693
694
695static struct pci_driver ne2k_driver = {
696 .name = DRV_NAME,
697 .probe = ne2k_pci_init_one,
698 .remove = ne2k_pci_remove_one,
699 .id_table = ne2k_pci_tbl,
700#ifdef CONFIG_PM
701 .suspend = ne2k_pci_suspend,
702 .resume = ne2k_pci_resume,
703#endif
704
705};
706
707
708static int __init ne2k_pci_init(void)
709{
710
711#ifdef MODULE
712 printk(version);
713#endif
714 return pci_register_driver(&ne2k_driver);
715}
716
717
718static void __exit ne2k_pci_cleanup(void)
719{
720 pci_unregister_driver (&ne2k_driver);
721}
722
723module_init(ne2k_pci_init);
724module_exit(ne2k_pci_cleanup);
725