1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#define DRV_NAME "3c507"
29#define DRV_VERSION "1.10a"
30#define DRV_RELDATE "11/17/2001"
31
32static const char version[] =
33 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
34
35
36
37
38
39
40
41
42
43
44
45
46#include <linux/module.h>
47#include <linux/kernel.h>
48#include <linux/types.h>
49#include <linux/fcntl.h>
50#include <linux/interrupt.h>
51#include <linux/ioport.h>
52#include <linux/in.h>
53#include <linux/string.h>
54#include <linux/spinlock.h>
55#include <linux/ethtool.h>
56#include <linux/errno.h>
57#include <linux/netdevice.h>
58#include <linux/etherdevice.h>
59#include <linux/skbuff.h>
60#include <linux/slab.h>
61#include <linux/init.h>
62#include <linux/bitops.h>
63
64#include <asm/dma.h>
65#include <asm/io.h>
66#include <asm/system.h>
67#include <asm/uaccess.h>
68
69
70#ifndef NET_DEBUG
71#define NET_DEBUG 1
72#endif
73static unsigned int net_debug = NET_DEBUG;
74#define debug net_debug
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92#define CUC_START 0x0100
93#define CUC_RESUME 0x0200
94#define CUC_SUSPEND 0x0300
95#define RX_START 0x0010
96#define RX_RESUME 0x0020
97#define RX_SUSPEND 0x0030
98
99
100
101
102
103
104
105
106
107
108
109
110
111#define CMD_EOL 0x8000
112#define CMD_SUSP 0x4000
113#define CMD_INTR 0x2000
114
115enum commands {
116 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
117 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
118
119
120struct net_local {
121 int last_restart;
122 ushort rx_head;
123 ushort rx_tail;
124 ushort tx_head;
125 ushort tx_cmd_link;
126 ushort tx_reap;
127 ushort tx_pkts_in_ring;
128 spinlock_t lock;
129 void __iomem *base;
130};
131
132
133
134
135
136
137
138
139
140#define SA_DATA 0
141#define MISC_CTRL 6
142#define RESET_IRQ 10
143#define SIGNAL_CA 11
144#define ROM_CONFIG 13
145#define MEM_CONFIG 14
146#define IRQ_CONFIG 15
147#define EL16_IO_EXTENT 16
148
149
150#define ID_PORT 0x100
151
152
153#define iSCB_STATUS 0x8
154#define iSCB_CMD 0xA
155#define iSCB_CBL 0xC
156#define iSCB_RFA 0xE
157
158
159
160
161
162
163
164
165
166
167#define SCB_BASE ((unsigned)64*1024 - (dev->mem_end - dev->mem_start))
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185#define CONFIG_CMD 0x0018
186#define SET_SA_CMD 0x0024
187#define SA_OFFSET 0x002A
188#define IDLELOOP 0x30
189#define TDR_CMD 0x38
190#define TDR_TIME 0x3C
191#define DUMP_CMD 0x40
192#define DIAG_CMD 0x48
193#define SET_MC_CMD 0x4E
194#define DUMP_DATA 0x56
195
196#define TX_BUF_START 0x0100
197#define NUM_TX_BUFS 5
198#define TX_BUF_SIZE (1518+14+20+16)
199
200#define RX_BUF_START 0x2000
201#define RX_BUF_SIZE (1518+14+18)
202#define RX_BUF_END (dev->mem_end - dev->mem_start)
203
204#define TX_TIMEOUT 5
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239static unsigned short init_words[] = {
240
241 0x0000,
242 0,0,
243 0x0000,0x0000,
244
245
246 0x0001,
247 0x0008,0,0,
248
249
250 0,0xf000|RX_START|CUC_START,
251 CONFIG_CMD,
252 RX_BUF_START,
253 0,0,0,0,
254
255
256 0, CmdConfigure,
257 SET_SA_CMD,
258 0x0804,
259 0x2e40,
260 0,
261
262
263 0, CmdSASetup,
264 SET_MC_CMD,
265 0xaa00,0xb000,0x0bad,
266
267
268 0, CmdNOp, IDLELOOP, 0 ,
269
270
271 0, CmdTDR, IDLELOOP, 0,
272
273
274 0, CmdDump, IDLELOOP, DUMP_DATA,
275
276
277 0, CmdDiagnose, IDLELOOP,
278
279
280 0, CmdMulticastList, IDLELOOP, 0,
281};
282
283
284
285static int el16_probe1(struct net_device *dev, int ioaddr);
286static int el16_open(struct net_device *dev);
287static netdev_tx_t el16_send_packet(struct sk_buff *skb,
288 struct net_device *dev);
289static irqreturn_t el16_interrupt(int irq, void *dev_id);
290static void el16_rx(struct net_device *dev);
291static int el16_close(struct net_device *dev);
292static void el16_tx_timeout (struct net_device *dev);
293
294static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad);
295static void init_82586_mem(struct net_device *dev);
296static const struct ethtool_ops netdev_ethtool_ops;
297static void init_rx_bufs(struct net_device *);
298
299static int io = 0x300;
300static int irq;
301static int mem_start;
302
303
304
305
306
307
308
309
310
311struct net_device * __init el16_probe(int unit)
312{
313 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
314 static unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0};
315 unsigned *port;
316 int err = -ENODEV;
317
318 if (!dev)
319 return ERR_PTR(-ENODEV);
320
321 if (unit >= 0) {
322 sprintf(dev->name, "eth%d", unit);
323 netdev_boot_setup_check(dev);
324 io = dev->base_addr;
325 irq = dev->irq;
326 mem_start = dev->mem_start & 15;
327 }
328
329 if (io > 0x1ff)
330 err = el16_probe1(dev, io);
331 else if (io != 0)
332 err = -ENXIO;
333 else {
334 for (port = ports; *port; port++) {
335 err = el16_probe1(dev, *port);
336 if (!err)
337 break;
338 }
339 }
340
341 if (err)
342 goto out;
343 err = register_netdev(dev);
344 if (err)
345 goto out1;
346 return dev;
347out1:
348 free_irq(dev->irq, dev);
349 iounmap(((struct net_local *)netdev_priv(dev))->base);
350 release_region(dev->base_addr, EL16_IO_EXTENT);
351out:
352 free_netdev(dev);
353 return ERR_PTR(err);
354}
355
356static const struct net_device_ops netdev_ops = {
357 .ndo_open = el16_open,
358 .ndo_stop = el16_close,
359 .ndo_start_xmit = el16_send_packet,
360 .ndo_tx_timeout = el16_tx_timeout,
361 .ndo_change_mtu = eth_change_mtu,
362 .ndo_set_mac_address = eth_mac_addr,
363 .ndo_validate_addr = eth_validate_addr,
364};
365
366static int __init el16_probe1(struct net_device *dev, int ioaddr)
367{
368 static unsigned char init_ID_done;
369 int i, irq, irqval, retval;
370 struct net_local *lp;
371
372 if (init_ID_done == 0) {
373 ushort lrs_state = 0xff;
374
375 outb(0x00, ID_PORT);
376 for(i = 0; i < 255; i++) {
377 outb(lrs_state, ID_PORT);
378 lrs_state <<= 1;
379 if (lrs_state & 0x100)
380 lrs_state ^= 0xe7;
381 }
382 outb(0x00, ID_PORT);
383 init_ID_done = 1;
384 }
385
386 if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
387 return -ENODEV;
388
389 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
390 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
391 retval = -ENODEV;
392 goto out;
393 }
394
395 pr_info("%s: 3c507 at %#x,", dev->name, ioaddr);
396
397
398
399
400 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
401
402 irqval = request_irq(irq, &el16_interrupt, 0, DRV_NAME, dev);
403 if (irqval) {
404 pr_cont("\n");
405 pr_err("3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
406 retval = -EAGAIN;
407 goto out;
408 }
409
410
411 dev->base_addr = ioaddr;
412
413 outb(0x01, ioaddr + MISC_CTRL);
414 for (i = 0; i < 6; i++)
415 dev->dev_addr[i] = inb(ioaddr + i);
416 pr_cont(" %pM", dev->dev_addr);
417
418 if (mem_start)
419 net_debug = mem_start & 7;
420
421#ifdef MEM_BASE
422 dev->mem_start = MEM_BASE;
423 dev->mem_end = dev->mem_start + 0x10000;
424#else
425 {
426 int base;
427 int size;
428 char mem_config = inb(ioaddr + MEM_CONFIG);
429 if (mem_config & 0x20) {
430 size = 64*1024;
431 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
432 : ((mem_config & 3) << 17));
433 } else {
434 size = ((mem_config & 3) + 1) << 14;
435 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
436 }
437 dev->mem_start = base;
438 dev->mem_end = base + size;
439 }
440#endif
441
442 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
443 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
444
445 pr_cont(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
446 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
447
448 if (net_debug)
449 pr_debug("%s", version);
450
451 lp = netdev_priv(dev);
452 memset(lp, 0, sizeof(*lp));
453 spin_lock_init(&lp->lock);
454 lp->base = ioremap(dev->mem_start, RX_BUF_END);
455 if (!lp->base) {
456 pr_err("3c507: unable to remap memory\n");
457 retval = -EAGAIN;
458 goto out1;
459 }
460
461 dev->netdev_ops = &netdev_ops;
462 dev->watchdog_timeo = TX_TIMEOUT;
463 dev->ethtool_ops = &netdev_ethtool_ops;
464 dev->flags &= ~IFF_MULTICAST;
465 return 0;
466out1:
467 free_irq(dev->irq, dev);
468out:
469 release_region(ioaddr, EL16_IO_EXTENT);
470 return retval;
471}
472
473static int el16_open(struct net_device *dev)
474{
475
476 init_82586_mem(dev);
477
478 netif_start_queue(dev);
479 return 0;
480}
481
482
483static void el16_tx_timeout (struct net_device *dev)
484{
485 struct net_local *lp = netdev_priv(dev);
486 int ioaddr = dev->base_addr;
487 void __iomem *shmem = lp->base;
488
489 if (net_debug > 1)
490 pr_debug("%s: transmit timed out, %s? ", dev->name,
491 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
492 "network cable problem");
493
494 if (lp->last_restart == dev->stats.tx_packets) {
495 if (net_debug > 1)
496 pr_cont("Resetting board.\n");
497
498 init_82586_mem (dev);
499 lp->tx_pkts_in_ring = 0;
500 } else {
501
502 if (net_debug > 1)
503 pr_cont("Kicking board.\n");
504 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
505 outb (0, ioaddr + SIGNAL_CA);
506 lp->last_restart = dev->stats.tx_packets;
507 }
508 dev->trans_start = jiffies;
509 netif_wake_queue (dev);
510}
511
512
513static netdev_tx_t el16_send_packet (struct sk_buff *skb,
514 struct net_device *dev)
515{
516 struct net_local *lp = netdev_priv(dev);
517 int ioaddr = dev->base_addr;
518 unsigned long flags;
519 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
520 unsigned char *buf = skb->data;
521
522 netif_stop_queue (dev);
523
524 spin_lock_irqsave (&lp->lock, flags);
525
526 dev->stats.tx_bytes += length;
527
528 outb (0x80, ioaddr + MISC_CTRL);
529
530 hardware_send_packet (dev, buf, skb->len, length - skb->len);
531
532 dev->trans_start = jiffies;
533
534 outb (0x84, ioaddr + MISC_CTRL);
535
536 spin_unlock_irqrestore (&lp->lock, flags);
537
538 dev_kfree_skb (skb);
539
540
541
542 return NETDEV_TX_OK;
543}
544
545
546
547static irqreturn_t el16_interrupt(int irq, void *dev_id)
548{
549 struct net_device *dev = dev_id;
550 struct net_local *lp;
551 int ioaddr, status, boguscount = 0;
552 ushort ack_cmd = 0;
553 void __iomem *shmem;
554
555 if (dev == NULL) {
556 pr_err("%s: net_interrupt(): irq %d for unknown device.\n",
557 dev->name, irq);
558 return IRQ_NONE;
559 }
560
561 ioaddr = dev->base_addr;
562 lp = netdev_priv(dev);
563 shmem = lp->base;
564
565 spin_lock(&lp->lock);
566
567 status = readw(shmem+iSCB_STATUS);
568
569 if (net_debug > 4) {
570 pr_debug("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
571 }
572
573
574 outb(0x80, ioaddr + MISC_CTRL);
575
576
577 while (lp->tx_pkts_in_ring) {
578 unsigned short tx_status = readw(shmem+lp->tx_reap);
579 if (!(tx_status & 0x8000)) {
580 if (net_debug > 5)
581 pr_debug("Tx command incomplete (%#x).\n", lp->tx_reap);
582 break;
583 }
584
585 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
586 dev->stats.tx_errors++;
587 if (tx_status & 0x0600) dev->stats.tx_carrier_errors++;
588 if (tx_status & 0x0100) dev->stats.tx_fifo_errors++;
589 if (!(tx_status & 0x0040)) dev->stats.tx_heartbeat_errors++;
590 if (tx_status & 0x0020) dev->stats.tx_aborted_errors++;
591 dev->stats.collisions += tx_status & 0xf;
592 }
593 dev->stats.tx_packets++;
594 if (net_debug > 5)
595 pr_debug("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
596 lp->tx_reap += TX_BUF_SIZE;
597 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
598 lp->tx_reap = TX_BUF_START;
599
600 lp->tx_pkts_in_ring--;
601
602 netif_wake_queue(dev);
603
604 if (++boguscount > 10)
605 break;
606 }
607
608 if (status & 0x4000) {
609 if (net_debug > 5)
610 pr_debug("Received packet, rx_head %04x.\n", lp->rx_head);
611 el16_rx(dev);
612 }
613
614
615 ack_cmd = status & 0xf000;
616
617 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
618 if (net_debug)
619 pr_debug("%s: Command unit stopped, status %04x, restarting.\n",
620 dev->name, status);
621
622
623
624 ack_cmd |= CUC_RESUME;
625 }
626
627 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
628
629
630 if (net_debug)
631 pr_debug("%s: Rx unit stopped, status %04x, restarting.\n",
632 dev->name, status);
633 init_rx_bufs(dev);
634 writew(RX_BUF_START,shmem+iSCB_RFA);
635 ack_cmd |= RX_START;
636 }
637
638 writew(ack_cmd,shmem+iSCB_CMD);
639 outb(0, ioaddr + SIGNAL_CA);
640
641
642 outb(0, ioaddr + RESET_IRQ);
643
644
645 outb(0x84, ioaddr + MISC_CTRL);
646 spin_unlock(&lp->lock);
647 return IRQ_HANDLED;
648}
649
650static int el16_close(struct net_device *dev)
651{
652 struct net_local *lp = netdev_priv(dev);
653 int ioaddr = dev->base_addr;
654 void __iomem *shmem = lp->base;
655
656 netif_stop_queue(dev);
657
658
659 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
660 outb(0, ioaddr + SIGNAL_CA);
661
662
663 outb(0x80, ioaddr + MISC_CTRL);
664
665
666
667
668
669 return 0;
670}
671
672
673static void init_rx_bufs(struct net_device *dev)
674{
675 struct net_local *lp = netdev_priv(dev);
676 void __iomem *write_ptr;
677 unsigned short SCB_base = SCB_BASE;
678
679 int cur_rxbuf = lp->rx_head = RX_BUF_START;
680
681
682 do {
683
684 write_ptr = lp->base + cur_rxbuf;
685
686 writew(0x0000,write_ptr);
687 writew(0x0000,write_ptr+=2);
688 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2);
689 writew(cur_rxbuf + 22,write_ptr+=2);
690 writew(0x0000,write_ptr+=2);
691 writew(0x0000,write_ptr+=2);
692 writew(0x0000,write_ptr+=2);
693 writew(0x0000,write_ptr+=2);
694 writew(0x0000,write_ptr+=2);
695 writew(0x0000,write_ptr+=2);
696 writew(0x0000,write_ptr+=2);
697
698 writew(0x0000,write_ptr+=2);
699 writew(-1,write_ptr+=2);
700 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);
701 writew(0x0000,write_ptr+=2);
702
703 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
704
705 lp->rx_tail = cur_rxbuf;
706 cur_rxbuf += RX_BUF_SIZE;
707 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
708
709
710
711 write_ptr = lp->base + lp->rx_tail + 2;
712 writew(0xC000,write_ptr);
713 writew(lp->rx_head,write_ptr+2);
714}
715
716static void init_82586_mem(struct net_device *dev)
717{
718 struct net_local *lp = netdev_priv(dev);
719 short ioaddr = dev->base_addr;
720 void __iomem *shmem = lp->base;
721
722
723
724 outb(0x20, ioaddr + MISC_CTRL);
725
726
727 init_words[3] = SCB_BASE;
728 init_words[7] = SCB_BASE;
729
730
731 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
732
733
734 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
735
736
737 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
738 sizeof(dev->dev_addr));
739
740
741 lp->tx_cmd_link = IDLELOOP + 4;
742 lp->tx_head = lp->tx_reap = TX_BUF_START;
743
744 init_rx_bufs(dev);
745
746
747 outb(0xA0, ioaddr + MISC_CTRL);
748
749
750
751 outb(0, ioaddr + SIGNAL_CA);
752
753 {
754 int boguscnt = 50;
755 while (readw(shmem+iSCB_STATUS) == 0)
756 if (--boguscnt == 0) {
757 pr_warning("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
758 dev->name, readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
759 break;
760 }
761
762 outb(0, ioaddr + SIGNAL_CA);
763 }
764
765
766 outb(0x84, ioaddr + MISC_CTRL);
767 if (net_debug > 4)
768 pr_debug("%s: Initialized 82586, status %04x.\n", dev->name,
769 readw(shmem+iSCB_STATUS));
770 return;
771}
772
773static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
774{
775 struct net_local *lp = netdev_priv(dev);
776 short ioaddr = dev->base_addr;
777 ushort tx_block = lp->tx_head;
778 void __iomem *write_ptr = lp->base + tx_block;
779 static char padding[ETH_ZLEN];
780
781
782 writew(0x0000,write_ptr);
783 writew(CMD_INTR|CmdTx,write_ptr+=2);
784 writew(tx_block+16,write_ptr+=2);
785 writew(tx_block+8,write_ptr+=2);
786
787
788 writew((pad + length) | 0x8000,write_ptr+=2);
789 writew(-1,write_ptr+=2);
790 writew(tx_block+22+SCB_BASE,write_ptr+=2);
791 writew(0x0000,write_ptr+=2);
792
793
794 writew(0x0000,write_ptr+=2);
795 writew(CmdNOp,write_ptr+=2);
796 writew(tx_block+16,write_ptr+=2);
797
798
799 memcpy_toio(write_ptr+2, buf, length);
800 if (pad)
801 memcpy_toio(write_ptr+length+2, padding, pad);
802
803
804 writew(tx_block,lp->base + lp->tx_cmd_link);
805 lp->tx_cmd_link = tx_block + 20;
806
807
808 lp->tx_head = tx_block + TX_BUF_SIZE;
809 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
810 lp->tx_head = TX_BUF_START;
811
812 if (net_debug > 4) {
813 pr_debug("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
814 dev->name, ioaddr, length, tx_block, lp->tx_head);
815 }
816
817
818 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
819 netif_wake_queue(dev);
820}
821
822static void el16_rx(struct net_device *dev)
823{
824 struct net_local *lp = netdev_priv(dev);
825 void __iomem *shmem = lp->base;
826 ushort rx_head = lp->rx_head;
827 ushort rx_tail = lp->rx_tail;
828 ushort boguscount = 10;
829 short frame_status;
830
831 while ((frame_status = readw(shmem+rx_head)) < 0) {
832 void __iomem *read_frame = lp->base + rx_head;
833 ushort rfd_cmd = readw(read_frame+2);
834 ushort next_rx_frame = readw(read_frame+4);
835 ushort data_buffer_addr = readw(read_frame+6);
836 void __iomem *data_frame = lp->base + data_buffer_addr;
837 ushort pkt_len = readw(data_frame);
838
839 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
840 || (pkt_len & 0xC000) != 0xC000) {
841 pr_err("%s: Rx frame at %#x corrupted, "
842 "status %04x cmd %04x next %04x "
843 "data-buf @%04x %04x.\n",
844 dev->name, rx_head, frame_status, rfd_cmd,
845 next_rx_frame, data_buffer_addr, pkt_len);
846 } else if ((frame_status & 0x2000) == 0) {
847
848 dev->stats.rx_errors++;
849 if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
850 if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
851 if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
852 if (frame_status & 0x0100) dev->stats.rx_over_errors++;
853 if (frame_status & 0x0080) dev->stats.rx_length_errors++;
854 } else {
855
856 struct sk_buff *skb;
857
858 pkt_len &= 0x3fff;
859 skb = dev_alloc_skb(pkt_len+2);
860 if (skb == NULL) {
861 pr_err("%s: Memory squeeze, dropping packet.\n",
862 dev->name);
863 dev->stats.rx_dropped++;
864 break;
865 }
866
867 skb_reserve(skb,2);
868
869
870 memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
871
872 skb->protocol=eth_type_trans(skb,dev);
873 netif_rx(skb);
874 dev->stats.rx_packets++;
875 dev->stats.rx_bytes += pkt_len;
876 }
877
878
879 writew(0,read_frame);
880 writew(0xC000,read_frame+2);
881
882 writew(0x0000,lp->base + rx_tail + 2);
883
884 rx_tail = rx_head;
885 rx_head = next_rx_frame;
886 if (--boguscount == 0)
887 break;
888 }
889
890 lp->rx_head = rx_head;
891 lp->rx_tail = rx_tail;
892}
893
894static void netdev_get_drvinfo(struct net_device *dev,
895 struct ethtool_drvinfo *info)
896{
897 strcpy(info->driver, DRV_NAME);
898 strcpy(info->version, DRV_VERSION);
899 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
900}
901
902static u32 netdev_get_msglevel(struct net_device *dev)
903{
904 return debug;
905}
906
907static void netdev_set_msglevel(struct net_device *dev, u32 level)
908{
909 debug = level;
910}
911
912static const struct ethtool_ops netdev_ethtool_ops = {
913 .get_drvinfo = netdev_get_drvinfo,
914 .get_msglevel = netdev_get_msglevel,
915 .set_msglevel = netdev_set_msglevel,
916};
917
918#ifdef MODULE
919static struct net_device *dev_3c507;
920module_param(io, int, 0);
921module_param(irq, int, 0);
922MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
923MODULE_PARM_DESC(irq, "(ignored)");
924
925int __init init_module(void)
926{
927 if (io == 0)
928 pr_notice("3c507: You should not use auto-probing with insmod!\n");
929 dev_3c507 = el16_probe(-1);
930 return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
931}
932
933void __exit
934cleanup_module(void)
935{
936 struct net_device *dev = dev_3c507;
937 unregister_netdev(dev);
938 free_irq(dev->irq, dev);
939 iounmap(((struct net_local *)netdev_priv(dev))->base);
940 release_region(dev->base_addr, EL16_IO_EXTENT);
941 free_netdev(dev);
942}
943#endif
944MODULE_LICENSE("GPL");
945