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