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
29
30
31
32
33
34
35
36
37
38static const char version1[] =
39"ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n";
40static const char version2[] =
41"Last modified Nov 1, 2000 by Paul Gortmaker\n";
42
43
44#include <linux/module.h>
45#include <linux/kernel.h>
46#include <linux/errno.h>
47#include <linux/isapnp.h>
48#include <linux/init.h>
49#include <linux/interrupt.h>
50#include <linux/delay.h>
51#include <linux/netdevice.h>
52#include <linux/etherdevice.h>
53#include <linux/jiffies.h>
54#include <linux/platform_device.h>
55
56#include <asm/system.h>
57#include <asm/io.h>
58
59#include "8390.h"
60
61#define DRV_NAME "ne"
62
63
64
65
66#define SUPPORT_NE_BAD_CLONES
67
68#define BAD 0xbad
69
70#define MAX_NE_CARDS 4
71static struct platform_device *pdev_ne[MAX_NE_CARDS];
72static int io[MAX_NE_CARDS];
73static int irq[MAX_NE_CARDS];
74static int bad[MAX_NE_CARDS];
75
76#ifdef MODULE
77module_param_array(io, int, NULL, 0);
78module_param_array(irq, int, NULL, 0);
79module_param_array(bad, int, NULL, 0);
80MODULE_PARM_DESC(io, "I/O base address(es),required");
81MODULE_PARM_DESC(irq, "IRQ number(s)");
82MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
83MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
84MODULE_LICENSE("GPL");
85#endif
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100#if !defined(MODULE) && (defined(CONFIG_ISA) || defined(CONFIG_M32R))
101
102#define NEEDS_PORTLIST
103#endif
104
105
106#ifdef NEEDS_PORTLIST
107static unsigned int netcard_portlist[] __initdata = {
108 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
109};
110#endif
111
112static struct isapnp_device_id isapnp_clone_list[] __initdata = {
113 { ISAPNP_CARD_ID('A','X','E',0x2011),
114 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
115 (long) "NetGear EA201" },
116 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
117 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
118 (long) "NN NE2000" },
119 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
120 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
121 (long) "Generic PNP" },
122 { }
123};
124
125MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
126
127#ifdef SUPPORT_NE_BAD_CLONES
128
129static struct { const char *name8, *name16; unsigned char SAprefix[4];}
130bad_clone_list[] __initdata = {
131 {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
132 {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
133 {"DFI1000", "DFI2000", {'D', 'F', 'I',}},
134 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
135 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}},
136 {"NN1000", "NN2000", {0x08, 0x03, 0x08}},
137 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}},
138 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}},
139 {"ET-100","ET-200", {0x00, 0x45, 0x54}},
140 {"COMPEX","COMPEX16",{0x00,0x80,0x48}},
141 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}},
142 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}},
143 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}},
144#ifdef CONFIG_MACH_TX49XX
145 {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}},
146#endif
147 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}},
148 {NULL,}
149};
150#endif
151
152
153
154#define NE_BASE (dev->base_addr)
155#define NE_CMD 0x00
156#define NE_DATAPORT 0x10
157#define NE_RESET 0x1f
158#define NE_IO_EXTENT 0x20
159
160#define NE1SM_START_PG 0x20
161#define NE1SM_STOP_PG 0x40
162#define NESM_START_PG 0x40
163#define NESM_STOP_PG 0x80
164
165#if defined(CONFIG_PLAT_MAPPI)
166# define DCR_VAL 0x4b
167#elif defined(CONFIG_PLAT_OAKS32R) || \
168 defined(CONFIG_MACH_TX49XX)
169# define DCR_VAL 0x48
170#else
171# define DCR_VAL 0x49
172#endif
173
174static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
175static int ne_probe_isapnp(struct net_device *dev);
176
177static void ne_reset_8390(struct net_device *dev);
178static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
179 int ring_page);
180static void ne_block_input(struct net_device *dev, int count,
181 struct sk_buff *skb, int ring_offset);
182static void ne_block_output(struct net_device *dev, const int count,
183 const unsigned char *buf, const int start_page);
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207static int __init do_ne_probe(struct net_device *dev)
208{
209 unsigned long base_addr = dev->base_addr;
210#ifdef NEEDS_PORTLIST
211 int orig_irq = dev->irq;
212#endif
213
214
215 if (base_addr > 0x1ff) {
216 int ret = ne_probe1(dev, base_addr);
217 if (ret)
218 printk(KERN_WARNING "ne.c: No NE*000 card found at "
219 "i/o = %#lx\n", base_addr);
220 return ret;
221 }
222 else if (base_addr != 0)
223 return -ENXIO;
224
225
226 if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
227 return 0;
228
229#ifdef NEEDS_PORTLIST
230
231 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
232 int ioaddr = netcard_portlist[base_addr];
233 dev->irq = orig_irq;
234 if (ne_probe1(dev, ioaddr) == 0)
235 return 0;
236 }
237#endif
238
239 return -ENODEV;
240}
241
242static int __init ne_probe_isapnp(struct net_device *dev)
243{
244 int i;
245
246 for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
247 struct pnp_dev *idev = NULL;
248
249 while ((idev = pnp_find_dev(NULL,
250 isapnp_clone_list[i].vendor,
251 isapnp_clone_list[i].function,
252 idev))) {
253
254 if (pnp_device_attach(idev) < 0)
255 continue;
256 if (pnp_activate_dev(idev) < 0) {
257 pnp_device_detach(idev);
258 continue;
259 }
260
261 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
262 pnp_device_detach(idev);
263 continue;
264 }
265
266 dev->base_addr = pnp_port_start(idev, 0);
267 dev->irq = pnp_irq(idev, 0);
268 printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
269 (char *) isapnp_clone_list[i].driver_data,
270 dev->base_addr, dev->irq);
271 if (ne_probe1(dev, dev->base_addr) != 0) {
272 printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
273 pnp_device_detach(idev);
274 return -ENXIO;
275 }
276 ei_status.priv = (unsigned long)idev;
277 break;
278 }
279 if (!idev)
280 continue;
281 return 0;
282 }
283
284 return -ENODEV;
285}
286
287static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
288{
289 int i;
290 unsigned char SA_prom[32];
291 int wordlength = 2;
292 const char *name = NULL;
293 int start_page, stop_page;
294 int neX000, ctron, copam, bad_card;
295 int reg0, ret;
296 static unsigned version_printed;
297
298 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
299 return -EBUSY;
300
301 reg0 = inb_p(ioaddr);
302 if (reg0 == 0xFF) {
303 ret = -ENODEV;
304 goto err_out;
305 }
306
307
308 {
309 int regd;
310 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
311 regd = inb_p(ioaddr + 0x0d);
312 outb_p(0xff, ioaddr + 0x0d);
313 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
314 inb_p(ioaddr + EN0_COUNTER0);
315 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
316 outb_p(reg0, ioaddr);
317 outb_p(regd, ioaddr + 0x0d);
318 ret = -ENODEV;
319 goto err_out;
320 }
321 }
322
323 if (ei_debug && version_printed++ == 0)
324 printk(KERN_INFO "%s%s", version1, version2);
325
326 printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
327
328
329
330
331
332
333
334 bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
335
336
337
338 {
339 unsigned long reset_start_time = jiffies;
340
341
342 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
343
344 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
345 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
346 if (bad_card) {
347 printk(" (warning: no reset ack)");
348 break;
349 } else {
350 printk(" not found (no reset ack).\n");
351 ret = -ENODEV;
352 goto err_out;
353 }
354 }
355
356 outb_p(0xff, ioaddr + EN0_ISR);
357 }
358
359
360
361
362
363 {
364 struct {unsigned char value, offset; } program_seq[] =
365 {
366 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD},
367 {0x48, EN0_DCFG},
368 {0x00, EN0_RCNTLO},
369 {0x00, EN0_RCNTHI},
370 {0x00, EN0_IMR},
371 {0xFF, EN0_ISR},
372 {E8390_RXOFF, EN0_RXCR},
373 {E8390_TXOFF, EN0_TXCR},
374 {32, EN0_RCNTLO},
375 {0x00, EN0_RCNTHI},
376 {0x00, EN0_RSARLO},
377 {0x00, EN0_RSARHI},
378 {E8390_RREAD+E8390_START, E8390_CMD},
379 };
380
381 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
382 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
383
384 }
385 for(i = 0; i < 32 ; i+=2) {
386 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
387 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
388 if (SA_prom[i] != SA_prom[i+1])
389 wordlength = 1;
390 }
391
392 if (wordlength == 2)
393 {
394 for (i = 0; i < 16; i++)
395 SA_prom[i] = SA_prom[i+i];
396
397 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
398 start_page = NESM_START_PG;
399
400
401
402
403
404
405
406 if ((DCR_VAL & 0x01) == 0 &&
407 inb(ioaddr + EN0_RCNTLO) == 0x50 &&
408 inb(ioaddr + EN0_RCNTHI) == 0x70)
409 stop_page = 0x60;
410 else
411 stop_page = NESM_STOP_PG;
412 } else {
413 start_page = NE1SM_START_PG;
414 stop_page = NE1SM_STOP_PG;
415 }
416
417#if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
418 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57)
419 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
420#else
421 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
422#endif
423 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
424 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
425
426
427 if (neX000 || bad_card || copam) {
428 name = (wordlength == 2) ? "NE2000" : "NE1000";
429 }
430 else if (ctron)
431 {
432 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
433 start_page = 0x01;
434 stop_page = (wordlength == 2) ? 0x40 : 0x20;
435 }
436 else
437 {
438#ifdef SUPPORT_NE_BAD_CLONES
439
440
441 for (i = 0; bad_clone_list[i].name8; i++)
442 {
443 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
444 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
445 SA_prom[2] == bad_clone_list[i].SAprefix[2])
446 {
447 if (wordlength == 2)
448 {
449 name = bad_clone_list[i].name16;
450 } else {
451 name = bad_clone_list[i].name8;
452 }
453 break;
454 }
455 }
456 if (bad_clone_list[i].name8 == NULL)
457 {
458 printk(" not found (invalid signature %2.2x %2.2x).\n",
459 SA_prom[14], SA_prom[15]);
460 ret = -ENXIO;
461 goto err_out;
462 }
463#else
464 printk(" not found.\n");
465 ret = -ENXIO;
466 goto err_out;
467#endif
468 }
469
470 if (dev->irq < 2)
471 {
472 unsigned long cookie = probe_irq_on();
473 outb_p(0x50, ioaddr + EN0_IMR);
474 outb_p(0x00, ioaddr + EN0_RCNTLO);
475 outb_p(0x00, ioaddr + EN0_RCNTHI);
476 outb_p(E8390_RREAD+E8390_START, ioaddr);
477 mdelay(10);
478 outb_p(0x00, ioaddr + EN0_IMR);
479 dev->irq = probe_irq_off(cookie);
480 if (ei_debug > 2)
481 printk(" autoirq is %d\n", dev->irq);
482 } else if (dev->irq == 2)
483
484
485 dev->irq = 9;
486
487 if (! dev->irq) {
488 printk(" failed to detect IRQ line.\n");
489 ret = -EAGAIN;
490 goto err_out;
491 }
492
493
494
495 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev);
496 if (ret) {
497 printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
498 goto err_out;
499 }
500
501 dev->base_addr = ioaddr;
502
503#ifdef CONFIG_PLAT_MAPPI
504 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
505 ioaddr + E8390_CMD);
506 for (i = 0 ; i < ETHER_ADDR_LEN ; i++) {
507 dev->dev_addr[i] = SA_prom[i]
508 = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
509 }
510#else
511 for(i = 0; i < ETHER_ADDR_LEN; i++) {
512 dev->dev_addr[i] = SA_prom[i];
513 }
514#endif
515
516 printk("%pM\n", dev->dev_addr);
517
518 ei_status.name = name;
519 ei_status.tx_start_page = start_page;
520 ei_status.stop_page = stop_page;
521
522
523 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
524
525 ei_status.rx_start_page = start_page + TX_PAGES;
526#ifdef PACKETBUF_MEMSIZE
527
528 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
529#endif
530
531 ei_status.reset_8390 = &ne_reset_8390;
532 ei_status.block_input = &ne_block_input;
533 ei_status.block_output = &ne_block_output;
534 ei_status.get_8390_hdr = &ne_get_8390_hdr;
535 ei_status.priv = 0;
536
537 dev->netdev_ops = &eip_netdev_ops;
538 NS8390p_init(dev, 0);
539
540 ret = register_netdev(dev);
541 if (ret)
542 goto out_irq;
543 printk(KERN_INFO "%s: %s found at %#lx, using IRQ %d.\n",
544 dev->name, name, ioaddr, dev->irq);
545 return 0;
546
547out_irq:
548 free_irq(dev->irq, dev);
549err_out:
550 release_region(ioaddr, NE_IO_EXTENT);
551 return ret;
552}
553
554
555
556
557static void ne_reset_8390(struct net_device *dev)
558{
559 unsigned long reset_start_time = jiffies;
560
561 if (ei_debug > 1)
562 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
563
564
565 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
566
567 ei_status.txing = 0;
568 ei_status.dmaing = 0;
569
570
571 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
572 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
573 printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
574 break;
575 }
576 outb_p(ENISR_RESET, NE_BASE + EN0_ISR);
577}
578
579
580
581
582
583static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
584{
585 int nic_base = dev->base_addr;
586
587
588
589 if (ei_status.dmaing)
590 {
591 printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
592 "[DMAstat:%d][irqlock:%d].\n",
593 dev->name, ei_status.dmaing, ei_status.irqlock);
594 return;
595 }
596
597 ei_status.dmaing |= 0x01;
598 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
599 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
600 outb_p(0, nic_base + EN0_RCNTHI);
601 outb_p(0, nic_base + EN0_RSARLO);
602 outb_p(ring_page, nic_base + EN0_RSARHI);
603 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
604
605 if (ei_status.word16)
606 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
607 else
608 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
609
610 outb_p(ENISR_RDC, nic_base + EN0_ISR);
611 ei_status.dmaing &= ~0x01;
612
613 le16_to_cpus(&hdr->count);
614}
615
616
617
618
619
620
621static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
622{
623#ifdef NE_SANITY_CHECK
624 int xfer_count = count;
625#endif
626 int nic_base = dev->base_addr;
627 char *buf = skb->data;
628
629
630 if (ei_status.dmaing)
631 {
632 printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
633 "[DMAstat:%d][irqlock:%d].\n",
634 dev->name, ei_status.dmaing, ei_status.irqlock);
635 return;
636 }
637 ei_status.dmaing |= 0x01;
638 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
639 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
640 outb_p(count >> 8, nic_base + EN0_RCNTHI);
641 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
642 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
643 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
644 if (ei_status.word16)
645 {
646 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
647 if (count & 0x01)
648 {
649 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
650#ifdef NE_SANITY_CHECK
651 xfer_count++;
652#endif
653 }
654 } else {
655 insb(NE_BASE + NE_DATAPORT, buf, count);
656 }
657
658#ifdef NE_SANITY_CHECK
659
660
661
662
663
664 if (ei_debug > 1)
665 {
666
667 int addr, tries = 20;
668 do {
669
670
671 int high = inb_p(nic_base + EN0_RSARHI);
672 int low = inb_p(nic_base + EN0_RSARLO);
673 addr = (high << 8) + low;
674 if (((ring_offset + xfer_count) & 0xff) == low)
675 break;
676 } while (--tries > 0);
677 if (tries <= 0)
678 printk(KERN_WARNING "%s: RX transfer address mismatch,"
679 "%#4.4x (expected) vs. %#4.4x (actual).\n",
680 dev->name, ring_offset + xfer_count, addr);
681 }
682#endif
683 outb_p(ENISR_RDC, nic_base + EN0_ISR);
684 ei_status.dmaing &= ~0x01;
685}
686
687static void ne_block_output(struct net_device *dev, int count,
688 const unsigned char *buf, const int start_page)
689{
690 int nic_base = NE_BASE;
691 unsigned long dma_start;
692#ifdef NE_SANITY_CHECK
693 int retries = 0;
694#endif
695
696
697
698
699
700 if (ei_status.word16 && (count & 0x01))
701 count++;
702
703
704 if (ei_status.dmaing)
705 {
706 printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
707 "[DMAstat:%d][irqlock:%d]\n",
708 dev->name, ei_status.dmaing, ei_status.irqlock);
709 return;
710 }
711 ei_status.dmaing |= 0x01;
712
713 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
714
715#ifdef NE_SANITY_CHECK
716retry:
717#endif
718
719#ifdef NE8390_RW_BUGFIX
720
721
722
723
724
725 outb_p(0x42, nic_base + EN0_RCNTLO);
726 outb_p(0x00, nic_base + EN0_RCNTHI);
727 outb_p(0x42, nic_base + EN0_RSARLO);
728 outb_p(0x00, nic_base + EN0_RSARHI);
729 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
730
731 udelay(6);
732#endif
733
734 outb_p(ENISR_RDC, nic_base + EN0_ISR);
735
736
737 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
738 outb_p(count >> 8, nic_base + EN0_RCNTHI);
739 outb_p(0x00, nic_base + EN0_RSARLO);
740 outb_p(start_page, nic_base + EN0_RSARHI);
741
742 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
743 if (ei_status.word16) {
744 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
745 } else {
746 outsb(NE_BASE + NE_DATAPORT, buf, count);
747 }
748
749 dma_start = jiffies;
750
751#ifdef NE_SANITY_CHECK
752
753
754
755 if (ei_debug > 1)
756 {
757
758 int addr, tries = 20;
759 do {
760 int high = inb_p(nic_base + EN0_RSARHI);
761 int low = inb_p(nic_base + EN0_RSARLO);
762 addr = (high << 8) + low;
763 if ((start_page << 8) + count == addr)
764 break;
765 } while (--tries > 0);
766
767 if (tries <= 0)
768 {
769 printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
770 "%#4.4x (expected) vs. %#4.4x (actual).\n",
771 dev->name, (start_page << 8) + count, addr);
772 if (retries++ == 0)
773 goto retry;
774 }
775 }
776#endif
777
778 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
779 if (time_after(jiffies, dma_start + 2*HZ/100)) {
780 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
781 ne_reset_8390(dev);
782 NS8390p_init(dev, 1);
783 break;
784 }
785
786 outb_p(ENISR_RDC, nic_base + EN0_ISR);
787 ei_status.dmaing &= ~0x01;
788 return;
789}
790
791static int __init ne_drv_probe(struct platform_device *pdev)
792{
793 struct net_device *dev;
794 int err, this_dev = pdev->id;
795 struct resource *res;
796
797 dev = alloc_eip_netdev();
798 if (!dev)
799 return -ENOMEM;
800
801
802
803
804
805 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
806 if (res) {
807 dev->base_addr = res->start;
808 dev->irq = platform_get_irq(pdev, 0);
809 } else {
810 if (this_dev < 0 || this_dev >= MAX_NE_CARDS)
811 return -EINVAL;
812 dev->base_addr = io[this_dev];
813 dev->irq = irq[this_dev];
814 dev->mem_end = bad[this_dev];
815 }
816 err = do_ne_probe(dev);
817 if (err) {
818 free_netdev(dev);
819 return err;
820 }
821 platform_set_drvdata(pdev, dev);
822
823
824
825
826 if (!res) {
827 io[this_dev] = dev->base_addr;
828 irq[this_dev] = dev->irq;
829 }
830 return 0;
831}
832
833static int ne_drv_remove(struct platform_device *pdev)
834{
835 struct net_device *dev = platform_get_drvdata(pdev);
836
837 if (dev) {
838 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
839 netif_device_detach(dev);
840 unregister_netdev(dev);
841 if (idev)
842 pnp_device_detach(idev);
843
844
845
846
847 ei_status.priv = 0;
848 free_irq(dev->irq, dev);
849 release_region(dev->base_addr, NE_IO_EXTENT);
850 free_netdev(dev);
851 platform_set_drvdata(pdev, NULL);
852 }
853 return 0;
854}
855
856
857static void ne_loop_rm_unreg(int all)
858{
859 int this_dev;
860 struct platform_device *pdev;
861 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
862 pdev = pdev_ne[this_dev];
863
864 if (pdev && (!platform_get_drvdata(pdev) || all)) {
865 ne_drv_remove(pdev);
866 platform_device_unregister(pdev);
867 pdev_ne[this_dev] = NULL;
868 }
869 }
870}
871
872#ifdef CONFIG_PM
873static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
874{
875 struct net_device *dev = platform_get_drvdata(pdev);
876
877 if (netif_running(dev)) {
878 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
879 netif_device_detach(dev);
880 if (idev)
881 pnp_stop_dev(idev);
882 }
883 return 0;
884}
885
886static int ne_drv_resume(struct platform_device *pdev)
887{
888 struct net_device *dev = platform_get_drvdata(pdev);
889
890 if (netif_running(dev)) {
891 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
892 if (idev)
893 pnp_start_dev(idev);
894 ne_reset_8390(dev);
895 NS8390p_init(dev, 1);
896 netif_device_attach(dev);
897 }
898 return 0;
899}
900#else
901#define ne_drv_suspend NULL
902#define ne_drv_resume NULL
903#endif
904
905static struct platform_driver ne_driver = {
906 .remove = ne_drv_remove,
907 .suspend = ne_drv_suspend,
908 .resume = ne_drv_resume,
909 .driver = {
910 .name = DRV_NAME,
911 .owner = THIS_MODULE,
912 },
913};
914
915static void __init ne_add_devices(void)
916{
917 int this_dev;
918 struct platform_device *pdev;
919
920 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
921 if (pdev_ne[this_dev])
922 continue;
923 pdev = platform_device_register_simple(
924 DRV_NAME, this_dev, NULL, 0);
925 if (IS_ERR(pdev))
926 continue;
927 pdev_ne[this_dev] = pdev;
928 }
929}
930
931#ifdef MODULE
932int __init init_module(void)
933{
934 int retval;
935 ne_add_devices();
936 retval = platform_driver_probe(&ne_driver, ne_drv_probe);
937 if (retval) {
938 if (io[0] == 0)
939 printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\""
940 " value(s) for ISA cards.\n");
941 ne_loop_rm_unreg(1);
942 return retval;
943 }
944
945
946 ne_loop_rm_unreg(0);
947 return retval;
948}
949#else
950static int __init ne_init(void)
951{
952 int retval = platform_driver_probe(&ne_driver, ne_drv_probe);
953
954
955 ne_loop_rm_unreg(0);
956 return retval;
957}
958module_init(ne_init);
959
960struct net_device * __init ne_probe(int unit)
961{
962 int this_dev;
963 struct net_device *dev;
964
965
966 this_dev = 0;
967 while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
968 io[this_dev]) {
969 if (++this_dev == MAX_NE_CARDS)
970 return ERR_PTR(-ENOMEM);
971 }
972
973
974 dev = alloc_eip_netdev();
975 if (!dev)
976 return ERR_PTR(-ENOMEM);
977
978 sprintf(dev->name, "eth%d", unit);
979 netdev_boot_setup_check(dev);
980
981 io[this_dev] = dev->base_addr;
982 irq[this_dev] = dev->irq;
983 bad[this_dev] = dev->mem_end;
984
985 free_netdev(dev);
986
987 ne_add_devices();
988
989
990 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
991 if (pdev_ne[this_dev]) {
992 dev = platform_get_drvdata(pdev_ne[this_dev]);
993 if (dev)
994 return dev;
995 }
996 }
997
998 return ERR_PTR(-ENODEV);
999}
1000#endif
1001
1002static void __exit ne_exit(void)
1003{
1004 platform_driver_unregister(&ne_driver);
1005 ne_loop_rm_unreg(1);
1006}
1007module_exit(ne_exit);
1008