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
38
39
40
41#define DRV_NAME "3c505"
42#define DRV_VERSION "1.10a"
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99#include <linux/module.h>
100#include <linux/kernel.h>
101#include <linux/string.h>
102#include <linux/interrupt.h>
103#include <linux/errno.h>
104#include <linux/in.h>
105#include <linux/slab.h>
106#include <linux/ioport.h>
107#include <linux/spinlock.h>
108#include <linux/ethtool.h>
109#include <linux/delay.h>
110#include <linux/bitops.h>
111
112#include <asm/uaccess.h>
113#include <asm/io.h>
114#include <asm/dma.h>
115
116#include <linux/netdevice.h>
117#include <linux/etherdevice.h>
118#include <linux/skbuff.h>
119#include <linux/init.h>
120
121#include "3c505.h"
122
123
124
125
126
127
128
129#define filename __FILE__
130
131#define timeout_msg "*** timeout at %s:%s (line %d) ***\n"
132#define TIMEOUT_MSG(lineno) \
133 pr_notice(timeout_msg, filename, __func__, (lineno))
134
135#define invalid_pcb_msg "*** invalid pcb length %d at %s:%s (line %d) ***\n"
136#define INVALID_PCB_MSG(len) \
137 pr_notice(invalid_pcb_msg, (len), filename, __func__, __LINE__)
138
139#define search_msg "%s: Looking for 3c505 adapter at address %#x..."
140
141#define stilllooking_msg "still looking..."
142
143#define found_msg "found.\n"
144
145#define notfound_msg "not found (reason = %d)\n"
146
147#define couldnot_msg "%s: 3c505 not found\n"
148
149
150
151
152
153
154
155#ifdef ELP_DEBUG
156static int elp_debug = ELP_DEBUG;
157#else
158static int elp_debug;
159#endif
160#define debug elp_debug
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175static int addr_list[] __initdata = {0x300, 0x280, 0x310, 0};
176
177
178
179static unsigned long dma_mem_alloc(int size)
180{
181 int order = get_order(size);
182 return __get_dma_pages(GFP_KERNEL, order);
183}
184
185
186
187
188
189
190
191
192static inline unsigned char inb_status(unsigned int base_addr)
193{
194 return inb(base_addr + PORT_STATUS);
195}
196
197static inline int inb_command(unsigned int base_addr)
198{
199 return inb(base_addr + PORT_COMMAND);
200}
201
202static inline void outb_control(unsigned char val, struct net_device *dev)
203{
204 outb(val, dev->base_addr + PORT_CONTROL);
205 ((elp_device *)(netdev_priv(dev)))->hcr_val = val;
206}
207
208#define HCR_VAL(x) (((elp_device *)(netdev_priv(x)))->hcr_val)
209
210static inline void outb_command(unsigned char val, unsigned int base_addr)
211{
212 outb(val, base_addr + PORT_COMMAND);
213}
214
215static inline unsigned int backlog_next(unsigned int n)
216{
217 return (n + 1) % BACKLOG_SIZE;
218}
219
220
221
222
223
224
225
226
227
228
229
230
231
232#define GET_ASF(addr) \
233 (get_status(addr)&ASF_PCB_MASK)
234
235static inline int get_status(unsigned int base_addr)
236{
237 unsigned long timeout = jiffies + 10*HZ/100;
238 register int stat1;
239 do {
240 stat1 = inb_status(base_addr);
241 } while (stat1 != inb_status(base_addr) && time_before(jiffies, timeout));
242 if (time_after_eq(jiffies, timeout))
243 TIMEOUT_MSG(__LINE__);
244 return stat1;
245}
246
247static inline void set_hsf(struct net_device *dev, int hsf)
248{
249 elp_device *adapter = netdev_priv(dev);
250 unsigned long flags;
251
252 spin_lock_irqsave(&adapter->lock, flags);
253 outb_control((HCR_VAL(dev) & ~HSF_PCB_MASK) | hsf, dev);
254 spin_unlock_irqrestore(&adapter->lock, flags);
255}
256
257static bool start_receive(struct net_device *, pcb_struct *);
258
259static inline void adapter_reset(struct net_device *dev)
260{
261 unsigned long timeout;
262 elp_device *adapter = netdev_priv(dev);
263 unsigned char orig_hcr = adapter->hcr_val;
264
265 outb_control(0, dev);
266
267 if (inb_status(dev->base_addr) & ACRF) {
268 do {
269 inb_command(dev->base_addr);
270 timeout = jiffies + 2*HZ/100;
271 while (time_before_eq(jiffies, timeout) && !(inb_status(dev->base_addr) & ACRF));
272 } while (inb_status(dev->base_addr) & ACRF);
273 set_hsf(dev, HSF_PCB_NAK);
274 }
275 outb_control(adapter->hcr_val | ATTN | DIR, dev);
276 mdelay(10);
277 outb_control(adapter->hcr_val & ~ATTN, dev);
278 mdelay(10);
279 outb_control(adapter->hcr_val | FLSH, dev);
280 mdelay(10);
281 outb_control(adapter->hcr_val & ~FLSH, dev);
282 mdelay(10);
283
284 outb_control(orig_hcr, dev);
285 if (!start_receive(dev, &adapter->tx_pcb))
286 pr_err("%s: start receive command failed\n", dev->name);
287}
288
289
290
291
292
293static inline void check_3c505_dma(struct net_device *dev)
294{
295 elp_device *adapter = netdev_priv(dev);
296 if (adapter->dmaing && time_after(jiffies, adapter->current_dma.start_time + 10)) {
297 unsigned long flags, f;
298 pr_err("%s: DMA %s timed out, %d bytes left\n", dev->name,
299 adapter->current_dma.direction ? "download" : "upload",
300 get_dma_residue(dev->dma));
301 spin_lock_irqsave(&adapter->lock, flags);
302 adapter->dmaing = 0;
303 adapter->busy = 0;
304
305 f=claim_dma_lock();
306 disable_dma(dev->dma);
307 release_dma_lock(f);
308
309 if (adapter->rx_active)
310 adapter->rx_active--;
311 outb_control(adapter->hcr_val & ~(DMAE | TCEN | DIR), dev);
312 spin_unlock_irqrestore(&adapter->lock, flags);
313 }
314}
315
316
317static inline bool send_pcb_slow(unsigned int base_addr, unsigned char byte)
318{
319 unsigned long timeout;
320 outb_command(byte, base_addr);
321 for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
322 if (inb_status(base_addr) & HCRE)
323 return false;
324 }
325 pr_warning("3c505: send_pcb_slow timed out\n");
326 return true;
327}
328
329static inline bool send_pcb_fast(unsigned int base_addr, unsigned char byte)
330{
331 unsigned int timeout;
332 outb_command(byte, base_addr);
333 for (timeout = 0; timeout < 40000; timeout++) {
334 if (inb_status(base_addr) & HCRE)
335 return false;
336 }
337 pr_warning("3c505: send_pcb_fast timed out\n");
338 return true;
339}
340
341
342static inline void prime_rx(struct net_device *dev)
343{
344 elp_device *adapter = netdev_priv(dev);
345 while (adapter->rx_active < ELP_RX_PCBS && netif_running(dev)) {
346 if (!start_receive(dev, &adapter->itx_pcb))
347 break;
348 }
349}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375static bool send_pcb(struct net_device *dev, pcb_struct * pcb)
376{
377 int i;
378 unsigned long timeout;
379 elp_device *adapter = netdev_priv(dev);
380 unsigned long flags;
381
382 check_3c505_dma(dev);
383
384 if (adapter->dmaing && adapter->current_dma.direction == 0)
385 return false;
386
387
388 if (test_and_set_bit(1, &adapter->send_pcb_semaphore)) {
389 if (elp_debug >= 3) {
390 pr_debug("%s: send_pcb entered while threaded\n", dev->name);
391 }
392 return false;
393 }
394
395
396
397
398
399 set_hsf(dev, 0);
400
401 if (send_pcb_slow(dev->base_addr, pcb->command))
402 goto abort;
403
404 spin_lock_irqsave(&adapter->lock, flags);
405
406 if (send_pcb_fast(dev->base_addr, pcb->length))
407 goto sti_abort;
408
409 for (i = 0; i < pcb->length; i++) {
410 if (send_pcb_fast(dev->base_addr, pcb->data.raw[i]))
411 goto sti_abort;
412 }
413
414 outb_control(adapter->hcr_val | 3, dev);
415 outb_command(2 + pcb->length, dev->base_addr);
416
417
418 spin_unlock_irqrestore(&adapter->lock, flags);
419
420 for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
421 switch (GET_ASF(dev->base_addr)) {
422 case ASF_PCB_ACK:
423 adapter->send_pcb_semaphore = 0;
424 return true;
425
426 case ASF_PCB_NAK:
427#ifdef ELP_DEBUG
428 pr_debug("%s: send_pcb got NAK\n", dev->name);
429#endif
430 goto abort;
431 }
432 }
433
434 if (elp_debug >= 1)
435 pr_debug("%s: timeout waiting for PCB acknowledge (status %02x)\n",
436 dev->name, inb_status(dev->base_addr));
437 goto abort;
438
439 sti_abort:
440 spin_unlock_irqrestore(&adapter->lock, flags);
441 abort:
442 adapter->send_pcb_semaphore = 0;
443 return false;
444}
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460static bool receive_pcb(struct net_device *dev, pcb_struct * pcb)
461{
462 int i, j;
463 int total_length;
464 int stat;
465 unsigned long timeout;
466 unsigned long flags;
467
468 elp_device *adapter = netdev_priv(dev);
469
470 set_hsf(dev, 0);
471
472
473 timeout = jiffies + 2*HZ/100;
474 while (((stat = get_status(dev->base_addr)) & ACRF) == 0 && time_before(jiffies, timeout));
475 if (time_after_eq(jiffies, timeout)) {
476 TIMEOUT_MSG(__LINE__);
477 return false;
478 }
479 pcb->command = inb_command(dev->base_addr);
480
481
482 timeout = jiffies + 3*HZ/100;
483 while (((stat = get_status(dev->base_addr)) & ACRF) == 0 && time_before(jiffies, timeout));
484 if (time_after_eq(jiffies, timeout)) {
485 TIMEOUT_MSG(__LINE__);
486 pr_info("%s: status %02x\n", dev->name, stat);
487 return false;
488 }
489 pcb->length = inb_command(dev->base_addr);
490
491 if (pcb->length > MAX_PCB_DATA) {
492 INVALID_PCB_MSG(pcb->length);
493 adapter_reset(dev);
494 return false;
495 }
496
497 spin_lock_irqsave(&adapter->lock, flags);
498 for (i = 0; i < MAX_PCB_DATA; i++) {
499 for (j = 0; j < 20000; j++) {
500 stat = get_status(dev->base_addr);
501 if (stat & ACRF)
502 break;
503 }
504 pcb->data.raw[i] = inb_command(dev->base_addr);
505 if ((stat & ASF_PCB_MASK) == ASF_PCB_END || j >= 20000)
506 break;
507 }
508 spin_unlock_irqrestore(&adapter->lock, flags);
509 if (i >= MAX_PCB_DATA) {
510 INVALID_PCB_MSG(i);
511 return false;
512 }
513 if (j >= 20000) {
514 TIMEOUT_MSG(__LINE__);
515 return false;
516 }
517
518 total_length = pcb->data.raw[i];
519
520
521 if (total_length != (pcb->length + 2)) {
522 if (elp_debug >= 2)
523 pr_warning("%s: mangled PCB received\n", dev->name);
524 set_hsf(dev, HSF_PCB_NAK);
525 return false;
526 }
527
528 if (pcb->command == CMD_RECEIVE_PACKET_COMPLETE) {
529 if (test_and_set_bit(0, (void *) &adapter->busy)) {
530 if (backlog_next(adapter->rx_backlog.in) == adapter->rx_backlog.out) {
531 set_hsf(dev, HSF_PCB_NAK);
532 pr_warning("%s: PCB rejected, transfer in progress and backlog full\n", dev->name);
533 pcb->command = 0;
534 return true;
535 } else {
536 pcb->command = 0xff;
537 }
538 }
539 }
540 set_hsf(dev, HSF_PCB_ACK);
541 return true;
542}
543
544
545
546
547
548
549
550
551static bool start_receive(struct net_device *dev, pcb_struct * tx_pcb)
552{
553 bool status;
554 elp_device *adapter = netdev_priv(dev);
555
556 if (elp_debug >= 3)
557 pr_debug("%s: restarting receiver\n", dev->name);
558 tx_pcb->command = CMD_RECEIVE_PACKET;
559 tx_pcb->length = sizeof(struct Rcv_pkt);
560 tx_pcb->data.rcv_pkt.buf_seg
561 = tx_pcb->data.rcv_pkt.buf_ofs = 0;
562 tx_pcb->data.rcv_pkt.buf_len = 1600;
563 tx_pcb->data.rcv_pkt.timeout = 0;
564 status = send_pcb(dev, tx_pcb);
565 if (status)
566 adapter->rx_active++;
567 return status;
568}
569
570
571
572
573
574
575
576
577
578
579static void receive_packet(struct net_device *dev, int len)
580{
581 int rlen;
582 elp_device *adapter = netdev_priv(dev);
583 void *target;
584 struct sk_buff *skb;
585 unsigned long flags;
586
587 rlen = (len + 1) & ~1;
588 skb = dev_alloc_skb(rlen + 2);
589
590 if (!skb) {
591 pr_warning("%s: memory squeeze, dropping packet\n", dev->name);
592 target = adapter->dma_buffer;
593 adapter->current_dma.target = NULL;
594
595 return;
596 }
597
598 skb_reserve(skb, 2);
599 target = skb_put(skb, rlen);
600 if ((unsigned long)(target + rlen) >= MAX_DMA_ADDRESS) {
601 adapter->current_dma.target = target;
602 target = adapter->dma_buffer;
603 } else {
604 adapter->current_dma.target = NULL;
605 }
606
607
608 if (test_and_set_bit(0, (void *) &adapter->dmaing))
609 pr_err("%s: rx blocked, DMA in progress, dir %d\n",
610 dev->name, adapter->current_dma.direction);
611
612 adapter->current_dma.direction = 0;
613 adapter->current_dma.length = rlen;
614 adapter->current_dma.skb = skb;
615 adapter->current_dma.start_time = jiffies;
616
617 outb_control(adapter->hcr_val | DIR | TCEN | DMAE, dev);
618
619 flags=claim_dma_lock();
620 disable_dma(dev->dma);
621 clear_dma_ff(dev->dma);
622 set_dma_mode(dev->dma, 0x04);
623 set_dma_addr(dev->dma, isa_virt_to_bus(target));
624 set_dma_count(dev->dma, rlen);
625 enable_dma(dev->dma);
626 release_dma_lock(flags);
627
628 if (elp_debug >= 3) {
629 pr_debug("%s: rx DMA transfer started\n", dev->name);
630 }
631
632 if (adapter->rx_active)
633 adapter->rx_active--;
634
635 if (!adapter->busy)
636 pr_warning("%s: receive_packet called, busy not set.\n", dev->name);
637}
638
639
640
641
642
643
644
645static irqreturn_t elp_interrupt(int irq, void *dev_id)
646{
647 int len;
648 int dlen;
649 int icount = 0;
650 struct net_device *dev = dev_id;
651 elp_device *adapter = netdev_priv(dev);
652 unsigned long timeout;
653
654 spin_lock(&adapter->lock);
655
656 do {
657
658
659
660 if (inb_status(dev->base_addr) & DONE) {
661 if (!adapter->dmaing)
662 pr_warning("%s: phantom DMA completed\n", dev->name);
663
664 if (elp_debug >= 3)
665 pr_debug("%s: %s DMA complete, status %02x\n", dev->name,
666 adapter->current_dma.direction ? "tx" : "rx",
667 inb_status(dev->base_addr));
668
669 outb_control(adapter->hcr_val & ~(DMAE | TCEN | DIR), dev);
670 if (adapter->current_dma.direction) {
671 dev_kfree_skb_irq(adapter->current_dma.skb);
672 } else {
673 struct sk_buff *skb = adapter->current_dma.skb;
674 if (skb) {
675 if (adapter->current_dma.target) {
676
677 memcpy(adapter->current_dma.target, adapter->dma_buffer, adapter->current_dma.length);
678 }
679 skb->protocol = eth_type_trans(skb,dev);
680 dev->stats.rx_bytes += skb->len;
681 netif_rx(skb);
682 }
683 }
684 adapter->dmaing = 0;
685 if (adapter->rx_backlog.in != adapter->rx_backlog.out) {
686 int t = adapter->rx_backlog.length[adapter->rx_backlog.out];
687 adapter->rx_backlog.out = backlog_next(adapter->rx_backlog.out);
688 if (elp_debug >= 2)
689 pr_debug("%s: receiving backlogged packet (%d)\n", dev->name, t);
690 receive_packet(dev, t);
691 } else {
692 adapter->busy = 0;
693 }
694 } else {
695
696 check_3c505_dma(dev);
697 }
698
699
700
701
702 timeout = jiffies + 3*HZ/100;
703 while ((inb_status(dev->base_addr) & ACRF) != 0 && time_before(jiffies, timeout)) {
704 if (receive_pcb(dev, &adapter->irx_pcb)) {
705 switch (adapter->irx_pcb.command)
706 {
707 case 0:
708 break;
709
710
711
712 case 0xff:
713 case CMD_RECEIVE_PACKET_COMPLETE:
714
715 if (!netif_running(dev))
716 break;
717 len = adapter->irx_pcb.data.rcv_resp.pkt_len;
718 dlen = adapter->irx_pcb.data.rcv_resp.buf_len;
719 if (adapter->irx_pcb.data.rcv_resp.timeout != 0) {
720 pr_err("%s: interrupt - packet not received correctly\n", dev->name);
721 } else {
722 if (elp_debug >= 3) {
723 pr_debug("%s: interrupt - packet received of length %i (%i)\n",
724 dev->name, len, dlen);
725 }
726 if (adapter->irx_pcb.command == 0xff) {
727 if (elp_debug >= 2)
728 pr_debug("%s: adding packet to backlog (len = %d)\n",
729 dev->name, dlen);
730 adapter->rx_backlog.length[adapter->rx_backlog.in] = dlen;
731 adapter->rx_backlog.in = backlog_next(adapter->rx_backlog.in);
732 } else {
733 receive_packet(dev, dlen);
734 }
735 if (elp_debug >= 3)
736 pr_debug("%s: packet received\n", dev->name);
737 }
738 break;
739
740
741
742
743 case CMD_CONFIGURE_82586_RESPONSE:
744 adapter->got[CMD_CONFIGURE_82586] = 1;
745 if (elp_debug >= 3)
746 pr_debug("%s: interrupt - configure response received\n", dev->name);
747 break;
748
749
750
751
752 case CMD_CONFIGURE_ADAPTER_RESPONSE:
753 adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 1;
754 if (elp_debug >= 3)
755 pr_debug("%s: Adapter memory configuration %s.\n", dev->name,
756 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
757 break;
758
759
760
761
762 case CMD_LOAD_MULTICAST_RESPONSE:
763 adapter->got[CMD_LOAD_MULTICAST_LIST] = 1;
764 if (elp_debug >= 3)
765 pr_debug("%s: Multicast address list loading %s.\n", dev->name,
766 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
767 break;
768
769
770
771
772 case CMD_SET_ADDRESS_RESPONSE:
773 adapter->got[CMD_SET_STATION_ADDRESS] = 1;
774 if (elp_debug >= 3)
775 pr_debug("%s: Ethernet address setting %s.\n", dev->name,
776 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
777 break;
778
779
780
781
782
783 case CMD_NETWORK_STATISTICS_RESPONSE:
784 dev->stats.rx_packets += adapter->irx_pcb.data.netstat.tot_recv;
785 dev->stats.tx_packets += adapter->irx_pcb.data.netstat.tot_xmit;
786 dev->stats.rx_crc_errors += adapter->irx_pcb.data.netstat.err_CRC;
787 dev->stats.rx_frame_errors += adapter->irx_pcb.data.netstat.err_align;
788 dev->stats.rx_fifo_errors += adapter->irx_pcb.data.netstat.err_ovrrun;
789 dev->stats.rx_over_errors += adapter->irx_pcb.data.netstat.err_res;
790 adapter->got[CMD_NETWORK_STATISTICS] = 1;
791 if (elp_debug >= 3)
792 pr_debug("%s: interrupt - statistics response received\n", dev->name);
793 break;
794
795
796
797
798 case CMD_TRANSMIT_PACKET_COMPLETE:
799 if (elp_debug >= 3)
800 pr_debug("%s: interrupt - packet sent\n", dev->name);
801 if (!netif_running(dev))
802 break;
803 switch (adapter->irx_pcb.data.xmit_resp.c_stat) {
804 case 0xffff:
805 dev->stats.tx_aborted_errors++;
806 pr_info("%s: transmit timed out, network cable problem?\n", dev->name);
807 break;
808 case 0xfffe:
809 dev->stats.tx_fifo_errors++;
810 pr_info("%s: transmit timed out, FIFO underrun\n", dev->name);
811 break;
812 }
813 netif_wake_queue(dev);
814 break;
815
816
817
818
819 default:
820 pr_debug("%s: unknown PCB received - %2.2x\n",
821 dev->name, adapter->irx_pcb.command);
822 break;
823 }
824 } else {
825 pr_warning("%s: failed to read PCB on interrupt\n", dev->name);
826 adapter_reset(dev);
827 }
828 }
829
830 } while (icount++ < 5 && (inb_status(dev->base_addr) & (ACRF | DONE)));
831
832 prime_rx(dev);
833
834
835
836
837 spin_unlock(&adapter->lock);
838 return IRQ_HANDLED;
839}
840
841
842
843
844
845
846
847
848static int elp_open(struct net_device *dev)
849{
850 elp_device *adapter = netdev_priv(dev);
851 int retval;
852
853 if (elp_debug >= 3)
854 pr_debug("%s: request to open device\n", dev->name);
855
856
857
858
859 if (adapter == NULL) {
860 pr_err("%s: Opening a non-existent physical device\n", dev->name);
861 return -EAGAIN;
862 }
863
864
865
866 outb_control(0, dev);
867
868
869
870
871 inb_command(dev->base_addr);
872 adapter_reset(dev);
873
874
875
876
877 adapter->rx_active = 0;
878
879 adapter->busy = 0;
880 adapter->send_pcb_semaphore = 0;
881 adapter->rx_backlog.in = 0;
882 adapter->rx_backlog.out = 0;
883
884 spin_lock_init(&adapter->lock);
885
886
887
888
889 if ((retval = request_irq(dev->irq, &elp_interrupt, 0, dev->name, dev))) {
890 pr_err("%s: could not allocate IRQ%d\n", dev->name, dev->irq);
891 return retval;
892 }
893 if ((retval = request_dma(dev->dma, dev->name))) {
894 free_irq(dev->irq, dev);
895 pr_err("%s: could not allocate DMA%d channel\n", dev->name, dev->dma);
896 return retval;
897 }
898 adapter->dma_buffer = (void *) dma_mem_alloc(DMA_BUFFER_SIZE);
899 if (!adapter->dma_buffer) {
900 pr_err("%s: could not allocate DMA buffer\n", dev->name);
901 free_dma(dev->dma);
902 free_irq(dev->irq, dev);
903 return -ENOMEM;
904 }
905 adapter->dmaing = 0;
906
907
908
909
910 outb_control(CMDE, dev);
911
912
913
914
915 if (elp_debug >= 3)
916 pr_debug("%s: sending 3c505 memory configuration command\n", dev->name);
917 adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
918 adapter->tx_pcb.data.memconf.cmd_q = 10;
919 adapter->tx_pcb.data.memconf.rcv_q = 20;
920 adapter->tx_pcb.data.memconf.mcast = 10;
921 adapter->tx_pcb.data.memconf.frame = 20;
922 adapter->tx_pcb.data.memconf.rcv_b = 20;
923 adapter->tx_pcb.data.memconf.progs = 0;
924 adapter->tx_pcb.length = sizeof(struct Memconf);
925 adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 0;
926 if (!send_pcb(dev, &adapter->tx_pcb))
927 pr_err("%s: couldn't send memory configuration command\n", dev->name);
928 else {
929 unsigned long timeout = jiffies + TIMEOUT;
930 while (adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] == 0 && time_before(jiffies, timeout));
931 if (time_after_eq(jiffies, timeout))
932 TIMEOUT_MSG(__LINE__);
933 }
934
935
936
937
938
939 if (elp_debug >= 3)
940 pr_debug("%s: sending 82586 configure command\n", dev->name);
941 adapter->tx_pcb.command = CMD_CONFIGURE_82586;
942 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
943 adapter->tx_pcb.length = 2;
944 adapter->got[CMD_CONFIGURE_82586] = 0;
945 if (!send_pcb(dev, &adapter->tx_pcb))
946 pr_err("%s: couldn't send 82586 configure command\n", dev->name);
947 else {
948 unsigned long timeout = jiffies + TIMEOUT;
949 while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
950 if (time_after_eq(jiffies, timeout))
951 TIMEOUT_MSG(__LINE__);
952 }
953
954
955
956
957
958
959
960 prime_rx(dev);
961 if (elp_debug >= 3)
962 pr_debug("%s: %d receive PCBs active\n", dev->name, adapter->rx_active);
963
964
965
966
967
968 netif_start_queue(dev);
969 return 0;
970}
971
972
973
974
975
976
977
978
979static netdev_tx_t send_packet(struct net_device *dev, struct sk_buff *skb)
980{
981 elp_device *adapter = netdev_priv(dev);
982 unsigned long target;
983 unsigned long flags;
984
985
986
987
988 unsigned int nlen = (((skb->len < 60) ? 60 : skb->len) + 1) & (~1);
989
990 if (test_and_set_bit(0, (void *) &adapter->busy)) {
991 if (elp_debug >= 2)
992 pr_debug("%s: transmit blocked\n", dev->name);
993 return false;
994 }
995
996 dev->stats.tx_bytes += nlen;
997
998
999
1000
1001
1002 adapter->tx_pcb.command = CMD_TRANSMIT_PACKET;
1003 adapter->tx_pcb.length = sizeof(struct Xmit_pkt);
1004 adapter->tx_pcb.data.xmit_pkt.buf_ofs
1005 = adapter->tx_pcb.data.xmit_pkt.buf_seg = 0;
1006 adapter->tx_pcb.data.xmit_pkt.pkt_len = nlen;
1007
1008 if (!send_pcb(dev, &adapter->tx_pcb)) {
1009 adapter->busy = 0;
1010 return false;
1011 }
1012
1013 if (test_and_set_bit(0, (void *) &adapter->dmaing))
1014 pr_debug("%s: tx: DMA %d in progress\n", dev->name, adapter->current_dma.direction);
1015
1016 adapter->current_dma.direction = 1;
1017 adapter->current_dma.start_time = jiffies;
1018
1019 if ((unsigned long)(skb->data + nlen) >= MAX_DMA_ADDRESS || nlen != skb->len) {
1020 skb_copy_from_linear_data(skb, adapter->dma_buffer, nlen);
1021 memset(adapter->dma_buffer+skb->len, 0, nlen-skb->len);
1022 target = isa_virt_to_bus(adapter->dma_buffer);
1023 }
1024 else {
1025 target = isa_virt_to_bus(skb->data);
1026 }
1027 adapter->current_dma.skb = skb;
1028
1029 flags=claim_dma_lock();
1030 disable_dma(dev->dma);
1031 clear_dma_ff(dev->dma);
1032 set_dma_mode(dev->dma, 0x48);
1033 set_dma_addr(dev->dma, target);
1034 set_dma_count(dev->dma, nlen);
1035 outb_control(adapter->hcr_val | DMAE | TCEN, dev);
1036 enable_dma(dev->dma);
1037 release_dma_lock(flags);
1038
1039 if (elp_debug >= 3)
1040 pr_debug("%s: DMA transfer started\n", dev->name);
1041
1042 return true;
1043}
1044
1045
1046
1047
1048
1049static void elp_timeout(struct net_device *dev)
1050{
1051 int stat;
1052
1053 stat = inb_status(dev->base_addr);
1054 pr_warning("%s: transmit timed out, lost %s?\n", dev->name,
1055 (stat & ACRF) ? "interrupt" : "command");
1056 if (elp_debug >= 1)
1057 pr_debug("%s: status %#02x\n", dev->name, stat);
1058 dev->trans_start = jiffies;
1059 dev->stats.tx_dropped++;
1060 netif_wake_queue(dev);
1061}
1062
1063
1064
1065
1066
1067
1068
1069
1070static netdev_tx_t elp_start_xmit(struct sk_buff *skb, struct net_device *dev)
1071{
1072 unsigned long flags;
1073 elp_device *adapter = netdev_priv(dev);
1074
1075 spin_lock_irqsave(&adapter->lock, flags);
1076 check_3c505_dma(dev);
1077
1078 if (elp_debug >= 3)
1079 pr_debug("%s: request to send packet of length %d\n", dev->name, (int) skb->len);
1080
1081 netif_stop_queue(dev);
1082
1083
1084
1085
1086 if (!send_packet(dev, skb)) {
1087 if (elp_debug >= 2) {
1088 pr_debug("%s: failed to transmit packet\n", dev->name);
1089 }
1090 spin_unlock_irqrestore(&adapter->lock, flags);
1091 return NETDEV_TX_BUSY;
1092 }
1093 if (elp_debug >= 3)
1094 pr_debug("%s: packet of length %d sent\n", dev->name, (int) skb->len);
1095
1096
1097
1098
1099 dev->trans_start = jiffies;
1100
1101 prime_rx(dev);
1102 spin_unlock_irqrestore(&adapter->lock, flags);
1103 netif_start_queue(dev);
1104 return NETDEV_TX_OK;
1105}
1106
1107
1108
1109
1110
1111
1112
1113static struct net_device_stats *elp_get_stats(struct net_device *dev)
1114{
1115 elp_device *adapter = netdev_priv(dev);
1116
1117 if (elp_debug >= 3)
1118 pr_debug("%s: request for stats\n", dev->name);
1119
1120
1121
1122 if (!netif_running(dev))
1123 return &dev->stats;
1124
1125
1126 adapter->tx_pcb.command = CMD_NETWORK_STATISTICS;
1127 adapter->tx_pcb.length = 0;
1128 adapter->got[CMD_NETWORK_STATISTICS] = 0;
1129 if (!send_pcb(dev, &adapter->tx_pcb))
1130 pr_err("%s: couldn't send get statistics command\n", dev->name);
1131 else {
1132 unsigned long timeout = jiffies + TIMEOUT;
1133 while (adapter->got[CMD_NETWORK_STATISTICS] == 0 && time_before(jiffies, timeout));
1134 if (time_after_eq(jiffies, timeout)) {
1135 TIMEOUT_MSG(__LINE__);
1136 return &dev->stats;
1137 }
1138 }
1139
1140
1141 return &dev->stats;
1142}
1143
1144
1145static void netdev_get_drvinfo(struct net_device *dev,
1146 struct ethtool_drvinfo *info)
1147{
1148 strcpy(info->driver, DRV_NAME);
1149 strcpy(info->version, DRV_VERSION);
1150 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1151}
1152
1153static u32 netdev_get_msglevel(struct net_device *dev)
1154{
1155 return debug;
1156}
1157
1158static void netdev_set_msglevel(struct net_device *dev, u32 level)
1159{
1160 debug = level;
1161}
1162
1163static const struct ethtool_ops netdev_ethtool_ops = {
1164 .get_drvinfo = netdev_get_drvinfo,
1165 .get_msglevel = netdev_get_msglevel,
1166 .set_msglevel = netdev_set_msglevel,
1167};
1168
1169
1170
1171
1172
1173
1174
1175static int elp_close(struct net_device *dev)
1176{
1177 elp_device *adapter = netdev_priv(dev);
1178
1179 if (elp_debug >= 3)
1180 pr_debug("%s: request to close device\n", dev->name);
1181
1182 netif_stop_queue(dev);
1183
1184
1185
1186
1187
1188 (void) elp_get_stats(dev);
1189
1190
1191
1192
1193 outb_control(0, dev);
1194
1195
1196
1197
1198 free_irq(dev->irq, dev);
1199
1200 free_dma(dev->dma);
1201 free_pages((unsigned long) adapter->dma_buffer, get_order(DMA_BUFFER_SIZE));
1202
1203 return 0;
1204}
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216static void elp_set_mc_list(struct net_device *dev)
1217{
1218 elp_device *adapter = netdev_priv(dev);
1219 struct dev_mc_list *dmi = dev->mc_list;
1220 int i;
1221 unsigned long flags;
1222
1223 if (elp_debug >= 3)
1224 pr_debug("%s: request to set multicast list\n", dev->name);
1225
1226 spin_lock_irqsave(&adapter->lock, flags);
1227
1228 if (!(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1229
1230
1231 adapter->tx_pcb.command = CMD_LOAD_MULTICAST_LIST;
1232 adapter->tx_pcb.length = 6 * dev->mc_count;
1233 for (i = 0; i < dev->mc_count; i++) {
1234 memcpy(adapter->tx_pcb.data.multicast[i], dmi->dmi_addr, 6);
1235 dmi = dmi->next;
1236 }
1237 adapter->got[CMD_LOAD_MULTICAST_LIST] = 0;
1238 if (!send_pcb(dev, &adapter->tx_pcb))
1239 pr_err("%s: couldn't send set_multicast command\n", dev->name);
1240 else {
1241 unsigned long timeout = jiffies + TIMEOUT;
1242 while (adapter->got[CMD_LOAD_MULTICAST_LIST] == 0 && time_before(jiffies, timeout));
1243 if (time_after_eq(jiffies, timeout)) {
1244 TIMEOUT_MSG(__LINE__);
1245 }
1246 }
1247 if (dev->mc_count)
1248 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD | RECV_MULTI;
1249 else
1250 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
1251 } else
1252 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_PROMISC;
1253
1254
1255
1256
1257 if (elp_debug >= 3)
1258 pr_debug("%s: sending 82586 configure command\n", dev->name);
1259 adapter->tx_pcb.command = CMD_CONFIGURE_82586;
1260 adapter->tx_pcb.length = 2;
1261 adapter->got[CMD_CONFIGURE_82586] = 0;
1262 if (!send_pcb(dev, &adapter->tx_pcb))
1263 {
1264 spin_unlock_irqrestore(&adapter->lock, flags);
1265 pr_err("%s: couldn't send 82586 configure command\n", dev->name);
1266 }
1267 else {
1268 unsigned long timeout = jiffies + TIMEOUT;
1269 spin_unlock_irqrestore(&adapter->lock, flags);
1270 while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
1271 if (time_after_eq(jiffies, timeout))
1272 TIMEOUT_MSG(__LINE__);
1273 }
1274}
1275
1276
1277
1278
1279
1280
1281
1282static int __init elp_sense(struct net_device *dev)
1283{
1284 int addr = dev->base_addr;
1285 const char *name = dev->name;
1286 byte orig_HSR;
1287
1288 if (!request_region(addr, ELP_IO_EXTENT, "3c505"))
1289 return -ENODEV;
1290
1291 orig_HSR = inb_status(addr);
1292
1293 if (elp_debug > 0)
1294 pr_debug(search_msg, name, addr);
1295
1296 if (orig_HSR == 0xff) {
1297 if (elp_debug > 0)
1298 pr_cont(notfound_msg, 1);
1299 goto out;
1300 }
1301
1302
1303 if (elp_debug > 0)
1304 pr_cont(stilllooking_msg);
1305
1306 if (orig_HSR & DIR) {
1307
1308 outb(0, dev->base_addr + PORT_CONTROL);
1309 msleep(300);
1310 if (inb_status(addr) & DIR) {
1311 if (elp_debug > 0)
1312 pr_cont(notfound_msg, 2);
1313 goto out;
1314 }
1315 } else {
1316
1317 outb(DIR, dev->base_addr + PORT_CONTROL);
1318 msleep(300);
1319 if (!(inb_status(addr) & DIR)) {
1320 if (elp_debug > 0)
1321 pr_cont(notfound_msg, 3);
1322 goto out;
1323 }
1324 }
1325
1326
1327
1328 if (elp_debug > 0)
1329 pr_cont(found_msg);
1330
1331 return 0;
1332out:
1333 release_region(addr, ELP_IO_EXTENT);
1334 return -ENODEV;
1335}
1336
1337
1338
1339
1340
1341
1342
1343static int __init elp_autodetect(struct net_device *dev)
1344{
1345 int idx = 0;
1346
1347
1348
1349 if (dev->base_addr != 0) {
1350 if (elp_sense(dev) == 0)
1351 return dev->base_addr;
1352 } else
1353 while ((dev->base_addr = addr_list[idx++])) {
1354 if (elp_sense(dev) == 0)
1355 return dev->base_addr;
1356 }
1357
1358
1359 if (elp_debug > 0)
1360 pr_debug(couldnot_msg, dev->name);
1361
1362 return 0;
1363}
1364
1365static const struct net_device_ops elp_netdev_ops = {
1366 .ndo_open = elp_open,
1367 .ndo_stop = elp_close,
1368 .ndo_get_stats = elp_get_stats,
1369 .ndo_start_xmit = elp_start_xmit,
1370 .ndo_tx_timeout = elp_timeout,
1371 .ndo_set_multicast_list = elp_set_mc_list,
1372 .ndo_change_mtu = eth_change_mtu,
1373 .ndo_set_mac_address = eth_mac_addr,
1374 .ndo_validate_addr = eth_validate_addr,
1375};
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398static int __init elplus_setup(struct net_device *dev)
1399{
1400 elp_device *adapter = netdev_priv(dev);
1401 int i, tries, tries1, okay;
1402 unsigned long timeout;
1403 unsigned long cookie = 0;
1404 int err = -ENODEV;
1405
1406
1407
1408
1409
1410 dev->base_addr = elp_autodetect(dev);
1411 if (!dev->base_addr)
1412 return -ENODEV;
1413
1414 adapter->send_pcb_semaphore = 0;
1415
1416 for (tries1 = 0; tries1 < 3; tries1++) {
1417 outb_control((adapter->hcr_val | CMDE) & ~DIR, dev);
1418
1419
1420
1421 timeout = jiffies + 5*HZ/100;
1422 okay = 0;
1423 while (time_before(jiffies, timeout) && !(inb_status(dev->base_addr) & HCRE));
1424 if ((inb_status(dev->base_addr) & HCRE)) {
1425 outb_command(0, dev->base_addr);
1426 timeout = jiffies + 5*HZ/100;
1427 while (time_before(jiffies, timeout) && !(inb_status(dev->base_addr) & HCRE));
1428 if (inb_status(dev->base_addr) & HCRE)
1429 okay = 1;
1430 }
1431 if (!okay) {
1432
1433
1434
1435 pr_err("%s: command register wouldn't drain, ", dev->name);
1436 if ((inb_status(dev->base_addr) & 7) == 3) {
1437
1438
1439
1440 pr_cont("assuming 3c505 still starting\n");
1441 timeout = jiffies + 10*HZ;
1442 while (time_before(jiffies, timeout) && (inb_status(dev->base_addr) & 7));
1443 if (inb_status(dev->base_addr) & 7) {
1444 pr_err("%s: 3c505 failed to start\n", dev->name);
1445 } else {
1446 okay = 1;
1447 }
1448 } else {
1449
1450
1451
1452 pr_cont("3c505 is sulking\n");
1453 }
1454 }
1455 for (tries = 0; tries < 5 && okay; tries++) {
1456
1457
1458
1459
1460
1461 adapter->tx_pcb.command = CMD_STATION_ADDRESS;
1462 adapter->tx_pcb.length = 0;
1463 cookie = probe_irq_on();
1464 if (!send_pcb(dev, &adapter->tx_pcb)) {
1465 pr_err("%s: could not send first PCB\n", dev->name);
1466 probe_irq_off(cookie);
1467 continue;
1468 }
1469 if (!receive_pcb(dev, &adapter->rx_pcb)) {
1470 pr_err("%s: could not read first PCB\n", dev->name);
1471 probe_irq_off(cookie);
1472 continue;
1473 }
1474 if ((adapter->rx_pcb.command != CMD_ADDRESS_RESPONSE) ||
1475 (adapter->rx_pcb.length != 6)) {
1476 pr_err("%s: first PCB wrong (%d, %d)\n", dev->name,
1477 adapter->rx_pcb.command, adapter->rx_pcb.length);
1478 probe_irq_off(cookie);
1479 continue;
1480 }
1481 goto okay;
1482 }
1483
1484
1485
1486 pr_info("%s: resetting adapter\n", dev->name);
1487 outb_control(adapter->hcr_val | FLSH | ATTN, dev);
1488 outb_control(adapter->hcr_val & ~(FLSH | ATTN), dev);
1489 }
1490 pr_err("%s: failed to initialise 3c505\n", dev->name);
1491 goto out;
1492
1493 okay:
1494 if (dev->irq) {
1495 int rpt = probe_irq_off(cookie);
1496 if (dev->irq != rpt) {
1497 pr_warning("%s: warning, irq %d configured but %d detected\n", dev->name, dev->irq, rpt);
1498 }
1499
1500 } else
1501 dev->irq = probe_irq_off(cookie);
1502 switch (dev->irq) {
1503 case 0:
1504 pr_err("%s: IRQ probe failed: check 3c505 jumpers.\n",
1505 dev->name);
1506 goto out;
1507 case 1:
1508 case 6:
1509 case 8:
1510 case 13:
1511 pr_err("%s: Impossible IRQ %d reported by probe_irq_off().\n",
1512 dev->name, dev->irq);
1513 goto out;
1514 }
1515
1516
1517
1518
1519 outb_control(adapter->hcr_val & ~CMDE, dev);
1520
1521
1522
1523
1524 for (i = 0; i < 6; i++)
1525 dev->dev_addr[i] = adapter->rx_pcb.data.eth_addr[i];
1526
1527
1528 if (!dev->dma) {
1529 if (dev->mem_start) {
1530 dev->dma = dev->mem_start & 7;
1531 }
1532 else {
1533 pr_warning("%s: warning, DMA channel not specified, using default\n", dev->name);
1534 dev->dma = ELP_DMA;
1535 }
1536 }
1537
1538
1539
1540
1541 pr_info("%s: 3c505 at %#lx, irq %d, dma %d, addr %pM, ",
1542 dev->name, dev->base_addr, dev->irq, dev->dma, dev->dev_addr);
1543
1544
1545
1546
1547 adapter->tx_pcb.command = CMD_ADAPTER_INFO;
1548 adapter->tx_pcb.length = 0;
1549 if (!send_pcb(dev, &adapter->tx_pcb) ||
1550 !receive_pcb(dev, &adapter->rx_pcb) ||
1551 (adapter->rx_pcb.command != CMD_ADAPTER_INFO_RESPONSE) ||
1552 (adapter->rx_pcb.length != 10)) {
1553 pr_cont("not responding to second PCB\n");
1554 }
1555 pr_cont("rev %d.%d, %dk\n", adapter->rx_pcb.data.info.major_vers,
1556 adapter->rx_pcb.data.info.minor_vers, adapter->rx_pcb.data.info.RAM_sz);
1557
1558
1559
1560
1561 adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
1562 adapter->tx_pcb.length = 12;
1563 adapter->tx_pcb.data.memconf.cmd_q = 8;
1564 adapter->tx_pcb.data.memconf.rcv_q = 8;
1565 adapter->tx_pcb.data.memconf.mcast = 10;
1566 adapter->tx_pcb.data.memconf.frame = 10;
1567 adapter->tx_pcb.data.memconf.rcv_b = 10;
1568 adapter->tx_pcb.data.memconf.progs = 0;
1569 if (!send_pcb(dev, &adapter->tx_pcb) ||
1570 !receive_pcb(dev, &adapter->rx_pcb) ||
1571 (adapter->rx_pcb.command != CMD_CONFIGURE_ADAPTER_RESPONSE) ||
1572 (adapter->rx_pcb.length != 2)) {
1573 pr_err("%s: could not configure adapter memory\n", dev->name);
1574 }
1575 if (adapter->rx_pcb.data.configure) {
1576 pr_err("%s: adapter configuration failed\n", dev->name);
1577 }
1578
1579 dev->netdev_ops = &elp_netdev_ops;
1580 dev->watchdog_timeo = 10*HZ;
1581 dev->ethtool_ops = &netdev_ethtool_ops;
1582
1583 dev->mem_start = dev->mem_end = 0;
1584
1585 err = register_netdev(dev);
1586 if (err)
1587 goto out;
1588
1589 return 0;
1590out:
1591 release_region(dev->base_addr, ELP_IO_EXTENT);
1592 return err;
1593}
1594
1595#ifndef MODULE
1596struct net_device * __init elplus_probe(int unit)
1597{
1598 struct net_device *dev = alloc_etherdev(sizeof(elp_device));
1599 int err;
1600 if (!dev)
1601 return ERR_PTR(-ENOMEM);
1602
1603 sprintf(dev->name, "eth%d", unit);
1604 netdev_boot_setup_check(dev);
1605
1606 err = elplus_setup(dev);
1607 if (err) {
1608 free_netdev(dev);
1609 return ERR_PTR(err);
1610 }
1611 return dev;
1612}
1613
1614#else
1615static struct net_device *dev_3c505[ELP_MAX_CARDS];
1616static int io[ELP_MAX_CARDS];
1617static int irq[ELP_MAX_CARDS];
1618static int dma[ELP_MAX_CARDS];
1619module_param_array(io, int, NULL, 0);
1620module_param_array(irq, int, NULL, 0);
1621module_param_array(dma, int, NULL, 0);
1622MODULE_PARM_DESC(io, "EtherLink Plus I/O base address(es)");
1623MODULE_PARM_DESC(irq, "EtherLink Plus IRQ number(s) (assigned)");
1624MODULE_PARM_DESC(dma, "EtherLink Plus DMA channel(s)");
1625
1626int __init init_module(void)
1627{
1628 int this_dev, found = 0;
1629
1630 for (this_dev = 0; this_dev < ELP_MAX_CARDS; this_dev++) {
1631 struct net_device *dev = alloc_etherdev(sizeof(elp_device));
1632 if (!dev)
1633 break;
1634
1635 dev->irq = irq[this_dev];
1636 dev->base_addr = io[this_dev];
1637 if (dma[this_dev]) {
1638 dev->dma = dma[this_dev];
1639 } else {
1640 dev->dma = ELP_DMA;
1641 pr_warning("3c505.c: warning, using default DMA channel,\n");
1642 }
1643 if (io[this_dev] == 0) {
1644 if (this_dev) {
1645 free_netdev(dev);
1646 break;
1647 }
1648 pr_notice("3c505.c: module autoprobe not recommended, give io=xx.\n");
1649 }
1650 if (elplus_setup(dev) != 0) {
1651 pr_warning("3c505.c: Failed to register card at 0x%x.\n", io[this_dev]);
1652 free_netdev(dev);
1653 break;
1654 }
1655 dev_3c505[this_dev] = dev;
1656 found++;
1657 }
1658 if (!found)
1659 return -ENODEV;
1660 return 0;
1661}
1662
1663void __exit cleanup_module(void)
1664{
1665 int this_dev;
1666
1667 for (this_dev = 0; this_dev < ELP_MAX_CARDS; this_dev++) {
1668 struct net_device *dev = dev_3c505[this_dev];
1669 if (dev) {
1670 unregister_netdev(dev);
1671 release_region(dev->base_addr, ELP_IO_EXTENT);
1672 free_netdev(dev);
1673 }
1674 }
1675}
1676
1677#endif
1678MODULE_LICENSE("GPL");
1679