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