This source file includes following definitions.
- lance_init
- lance_probe1
- lance_open
- lance_init_ring
- lance_start_xmit
- lance_interrupt
- lance_rx
- lance_close
- lance_get_stats
- set_multicast_list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 static char *version = "lance.c:v1.01 8/31/94 becker@cesdis.gsfc.nasa.gov\n";
19
20 #include <linux/config.h>
21 #include <linux/kernel.h>
22 #include <linux/sched.h>
23 #include <linux/string.h>
24 #include <linux/ptrace.h>
25 #include <linux/errno.h>
26 #include <linux/ioport.h>
27 #include <linux/malloc.h>
28 #include <linux/interrupt.h>
29 #include <asm/bitops.h>
30 #include <asm/io.h>
31 #include <asm/dma.h>
32
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/skbuff.h>
36
37 struct device *init_etherdev(struct device *dev, int sizeof_private,
38 unsigned long *mem_startp);
39 static unsigned int lance_portlist[] = {0x300, 0x320, 0x340, 0x360, 0};
40 unsigned long lance_probe1(short ioaddr, unsigned long mem_start);
41
42 #ifdef HAVE_DEVLIST
43 struct netdev_entry lance_drv =
44 {"lance", lance_probe1, LANCE_TOTAL_SIZE, lance_portlist};
45 #endif
46
47 #ifdef LANCE_DEBUG
48 int lance_debug = LANCE_DEBUG;
49 #else
50 int lance_debug = 1;
51 #endif
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143 #ifndef LANCE_LOG_TX_BUFFERS
144 #define LANCE_LOG_TX_BUFFERS 4
145 #define LANCE_LOG_RX_BUFFERS 4
146 #endif
147
148 #define TX_RING_SIZE (1 << (LANCE_LOG_TX_BUFFERS))
149 #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
150 #define TX_RING_LEN_BITS ((LANCE_LOG_TX_BUFFERS) << 29)
151
152 #define RX_RING_SIZE (1 << (LANCE_LOG_RX_BUFFERS))
153 #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
154 #define RX_RING_LEN_BITS ((LANCE_LOG_RX_BUFFERS) << 29)
155
156 #define PKT_BUF_SZ 1544
157
158
159 #define LANCE_DATA 0x10
160 #define LANCE_ADDR 0x12
161 #define LANCE_RESET 0x14
162 #define LANCE_BUS_IF 0x16
163 #define LANCE_TOTAL_SIZE 0x18
164
165
166 struct lance_rx_head {
167 int base;
168 short buf_length;
169 short msg_length;
170 };
171
172 struct lance_tx_head {
173 int base;
174 short length;
175 short misc;
176 };
177
178
179 struct lance_init_block {
180 unsigned short mode;
181 unsigned char phys_addr[6];
182 unsigned filter[2];
183
184 unsigned rx_ring;
185 unsigned tx_ring;
186 };
187
188 struct lance_private {
189 char devname[8];
190
191 struct lance_rx_head rx_ring[RX_RING_SIZE];
192 struct lance_tx_head tx_ring[TX_RING_SIZE];
193 struct lance_init_block init_block;
194
195 struct sk_buff* tx_skbuff[TX_RING_SIZE];
196 long rx_buffs;
197
198 char (*tx_bounce_buffs)[PKT_BUF_SZ];
199 int cur_rx, cur_tx;
200 int dirty_rx, dirty_tx;
201 int dma;
202 struct enet_statistics stats;
203 char chip_version;
204 char tx_full;
205 char lock;
206 int pad0, pad1;
207 };
208
209
210 static struct lance_chip_type {
211 int id_number;
212 char *name;
213 int flags;
214 } chip_table[] = {
215 {0x0000, "LANCE 7990", 0},
216 {0x0003, "PCnet/ISA 79C960", 0},
217 {0x2260, "PCnet/ISA+ 79C961", 0},
218 {0x2420, "PCnet/PCI 79C970", 0},
219 {0x2430, "PCnet/VLB 79C965", 0},
220 {0x0, "PCnet (unknown)", 0},
221 };
222
223 enum {OLD_LANCE = 0, PCNET_ISA=1, PCNET_ISAP=2, PCNET_PCI=3, PCNET_VLB=4, LANCE_UNKNOWN=5};
224
225 static int lance_open(struct device *dev);
226 static void lance_init_ring(struct device *dev);
227 static int lance_start_xmit(struct sk_buff *skb, struct device *dev);
228 static int lance_rx(struct device *dev);
229 static void lance_interrupt(int reg_ptr);
230 static int lance_close(struct device *dev);
231 static struct enet_statistics *lance_get_stats(struct device *dev);
232 #ifdef HAVE_MULTICAST
233 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
234 #endif
235
236
237
238
239
240
241
242 unsigned long lance_init(unsigned long mem_start, unsigned long mem_end)
243 {
244 int *port;
245
246 for (port = lance_portlist; *port; port++) {
247 int ioaddr = *port;
248
249 if ( check_region(ioaddr, LANCE_TOTAL_SIZE) == 0
250 && inb(ioaddr + 14) == 0x57
251 && inb(ioaddr + 15) == 0x57) {
252 mem_start = lance_probe1(ioaddr, mem_start);
253 }
254 }
255
256 return mem_start;
257 }
258
259 unsigned long lance_probe1(short ioaddr, unsigned long mem_start)
260 {
261 struct device *dev;
262 struct lance_private *lp;
263 int i, reset_val, lance_version;
264
265 unsigned char hpJ2405A = 0;
266 int hp_builtin = 0;
267 static int did_version = 0;
268
269
270
271
272
273 if ( *((unsigned short *) 0x000f0102) == 0x5048) {
274 short ioaddr_table[] = { 0x300, 0x320, 0x340, 0x360};
275
276 int hp_port = ( *((unsigned char *) 0x000f00f1) & 1) ? 0x499 : 0x99;
277
278 if ((inb(hp_port) & 0xc0) == 0x80
279 && ioaddr_table[inb(hp_port) & 3] == ioaddr)
280 hp_builtin = hp_port;
281 }
282
283 hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
284 && inb(ioaddr+2) == 0x09);
285
286
287 reset_val = inw(ioaddr+LANCE_RESET);
288
289
290
291 if (!hpJ2405A)
292 outw(reset_val, ioaddr+LANCE_RESET);
293
294 outw(0x0000, ioaddr+LANCE_ADDR);
295 if (inw(ioaddr+LANCE_DATA) != 0x0004)
296 return mem_start;
297
298
299 outw(88, ioaddr+LANCE_ADDR);
300 if (inw(ioaddr+LANCE_ADDR) != 88) {
301 lance_version = 0;
302 } else {
303 int chip_version = inw(ioaddr+LANCE_DATA);
304 outw(89, ioaddr+LANCE_ADDR);
305 chip_version |= inw(ioaddr+LANCE_DATA) << 16;
306 if (lance_debug > 2)
307 printk(" LANCE chip version is %#x.\n", chip_version);
308 if ((chip_version & 0xfff) != 0x003)
309 return mem_start;
310 chip_version = (chip_version >> 12) & 0xffff;
311 for (lance_version = 1; chip_table[lance_version].id_number; lance_version++) {
312 if (chip_table[lance_version].id_number == chip_version)
313 break;
314 }
315 }
316
317 dev = init_etherdev(0, sizeof(struct lance_private)
318 + PKT_BUF_SZ*(RX_RING_SIZE + TX_RING_SIZE),
319 &mem_start);
320
321 printk("%s: %s at %#3x,", dev->name, chip_table[lance_version].name, ioaddr);
322
323
324
325 for (i = 0; i < 6; i++)
326 printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
327
328 dev->base_addr = ioaddr;
329 snarf_region(ioaddr, LANCE_TOTAL_SIZE);
330
331
332 dev->priv = (void *)(((int)dev->priv + 7) & ~7);
333 lp = (struct lance_private *)dev->priv;
334 lp->rx_buffs = (long)dev->priv + sizeof(struct lance_private);
335 lp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
336 (lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
337
338 #ifndef final_version
339
340 if ((int)(lp->rx_ring) & 0x07) {
341 printk(" **ERROR** LANCE Rx and Tx rings not on even boundary.\n");
342 return mem_start;
343 }
344 #endif
345
346 lp->chip_version = lance_version;
347
348 lp->init_block.mode = 0x0003;
349 for (i = 0; i < 6; i++)
350 lp->init_block.phys_addr[i] = dev->dev_addr[i];
351 lp->init_block.filter[0] = 0x00000000;
352 lp->init_block.filter[1] = 0x00000000;
353 lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
354 lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
355
356 outw(0x0001, ioaddr+LANCE_ADDR);
357 inw(ioaddr+LANCE_ADDR);
358 outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
359 outw(0x0002, ioaddr+LANCE_ADDR);
360 inw(ioaddr+LANCE_ADDR);
361 outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
362 outw(0x0000, ioaddr+LANCE_ADDR);
363 inw(ioaddr+LANCE_ADDR);
364
365 if (hp_builtin) {
366 char dma_tbl[4] = {3, 5, 6, 0};
367 char irq_tbl[8] = {3, 4, 5, 9};
368 unsigned char port_val = inb(hp_builtin);
369 dev->dma = dma_tbl[(port_val >> 4) & 3];
370 dev->irq = irq_tbl[(port_val >> 2) & 3];
371 printk(" HP Vectra IRQ %d DMA %d.\n", dev->irq, dev->dma);
372 } else if (hpJ2405A) {
373 char dma_tbl[4] = {3, 5, 6, 7};
374 char irq_tbl[8] = {3, 4, 5, 9, 10, 11, 12, 15};
375 short reset_val = inw(ioaddr+LANCE_RESET);
376 dev->dma = dma_tbl[(reset_val >> 2) & 3];
377 dev->irq = irq_tbl[(reset_val >> 4) & 7];
378 printk(" HP J2405A IRQ %d DMA %d.\n", dev->irq, dev->dma);
379 } else if (lance_version == PCNET_ISAP) {
380 short bus_info;
381 outw(8, ioaddr+LANCE_ADDR);
382 bus_info = inw(ioaddr+LANCE_BUS_IF);
383 dev->dma = bus_info & 0x07;
384 dev->irq = (bus_info >> 4) & 0x0F;
385 } else {
386
387 if (dev->mem_start & 0x07)
388 dev->dma = dev->mem_start & 0x07;
389 }
390
391 if (dev->irq >= 2)
392 printk(" assigned IRQ %d", dev->irq);
393 else {
394
395
396
397 autoirq_setup(0);
398
399
400 outw(0x0041, ioaddr+LANCE_DATA);
401
402 dev->irq = autoirq_report(1);
403 if (dev->irq)
404 printk(", probed IRQ %d", dev->irq);
405 else {
406 printk(", failed to detect IRQ line.\n");
407 return mem_start;
408 }
409
410
411
412 if (inw(ioaddr+LANCE_DATA) & 0x0100)
413 dev->dma = 4;
414 }
415
416 if (dev->dma == 4) {
417 printk(", no DMA needed.\n");
418 } else if (dev->dma) {
419 if (request_dma(dev->dma, "lance")) {
420 printk("DMA %d allocation failed.\n", dev->dma);
421 return mem_start;
422 } else
423 printk(", assigned DMA %d.\n", dev->dma);
424 } else {
425 int dmas[] = {5, 6, 7, 3}, boguscnt;
426 for (i = 0; i < 4; i++) {
427 int dma = dmas[i];
428
429 outw(0x7f04, ioaddr+LANCE_DATA);
430 if (request_dma(dma, "lance"))
431 continue;
432 enable_dma(dma);
433 set_dma_mode(dma, DMA_MODE_CASCADE);
434
435
436 outw(0x0001, ioaddr+LANCE_DATA);
437 for (boguscnt = 100; boguscnt > 0; --boguscnt)
438 if (inw(ioaddr+LANCE_DATA) & 0x0900)
439 break;
440 if (inw(ioaddr+LANCE_DATA) & 0x0100) {
441 dev->dma = dma;
442 printk(", DMA %d.\n", dev->dma);
443 break;
444 } else {
445 disable_dma(dma);
446 free_dma(dma);
447 }
448 }
449 if (i == 4) {
450 printk("DMA detection failed.\n");
451 return mem_start;
452 }
453 }
454
455 if (lp->chip_version != OLD_LANCE) {
456
457
458 outw(0x0002, ioaddr+LANCE_ADDR);
459 outw(0x0002, ioaddr+LANCE_BUS_IF);
460 }
461
462 if (lance_debug > 0 && did_version++ == 0)
463 printk(version);
464
465
466 dev->open = &lance_open;
467 dev->hard_start_xmit = &lance_start_xmit;
468 dev->stop = &lance_close;
469 dev->get_stats = &lance_get_stats;
470 dev->set_multicast_list = &set_multicast_list;
471
472 return mem_start;
473 }
474
475
476 static int
477 lance_open(struct device *dev)
478 {
479 struct lance_private *lp = (struct lance_private *)dev->priv;
480 int ioaddr = dev->base_addr;
481 int i;
482
483 if (request_irq(dev->irq, &lance_interrupt, 0, "lance")) {
484 return -EAGAIN;
485 }
486
487
488
489
490 irq2dev_map[dev->irq] = dev;
491
492
493 inw(ioaddr+LANCE_RESET);
494
495
496 enable_dma(dev->dma);
497 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
498
499
500 if (lp->chip_version == OLD_LANCE)
501 outw(0, ioaddr+LANCE_RESET);
502
503 if (lp->chip_version != OLD_LANCE) {
504
505 outw(0x0002, ioaddr+LANCE_ADDR);
506 outw(0x0002, ioaddr+LANCE_BUS_IF);
507 }
508
509 if (lance_debug > 1)
510 printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
511 dev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
512 (int) &lp->init_block);
513
514 lance_init_ring(dev);
515
516 outw(0x0001, ioaddr+LANCE_ADDR);
517 outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
518 outw(0x0002, ioaddr+LANCE_ADDR);
519 outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
520
521 outw(0x0004, ioaddr+LANCE_ADDR);
522 outw(0x0d15, ioaddr+LANCE_DATA);
523
524 outw(0x0000, ioaddr+LANCE_ADDR);
525 outw(0x0001, ioaddr+LANCE_DATA);
526
527 dev->tbusy = 0;
528 dev->interrupt = 0;
529 dev->start = 1;
530 i = 0;
531 while (i++ < 100)
532 if (inw(ioaddr+LANCE_DATA) & 0x0100)
533 break;
534 outw(0x0142, ioaddr+LANCE_DATA);
535
536 if (lance_debug > 2)
537 printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
538 dev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
539
540 return 0;
541 }
542
543
544 static void
545 lance_init_ring(struct device *dev)
546 {
547 struct lance_private *lp = (struct lance_private *)dev->priv;
548 int i;
549
550 lp->lock = 0, lp->tx_full = 0;
551 lp->cur_rx = lp->cur_tx = 0;
552 lp->dirty_rx = lp->dirty_tx = 0;
553
554 for (i = 0; i < RX_RING_SIZE; i++) {
555 lp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
556 lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
557 }
558
559
560 for (i = 0; i < TX_RING_SIZE; i++) {
561 lp->tx_ring[i].base = 0;
562 }
563
564 lp->init_block.mode = 0x0000;
565 for (i = 0; i < 6; i++)
566 lp->init_block.phys_addr[i] = dev->dev_addr[i];
567 lp->init_block.filter[0] = 0x00000000;
568 lp->init_block.filter[1] = 0x00000000;
569 lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
570 lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
571 }
572
573 static int
574 lance_start_xmit(struct sk_buff *skb, struct device *dev)
575 {
576 struct lance_private *lp = (struct lance_private *)dev->priv;
577 int ioaddr = dev->base_addr;
578 int entry;
579
580
581 if (dev->tbusy) {
582 int tickssofar = jiffies - dev->trans_start;
583 if (tickssofar < 10)
584 return 1;
585 outw(0, ioaddr+LANCE_ADDR);
586 printk("%s: transmit timed out, status %4.4x, resetting.\n",
587 dev->name, inw(ioaddr+LANCE_DATA));
588 outw(0x0001, ioaddr+LANCE_DATA);
589 lp->stats.tx_errors++;
590 #ifndef final_version
591 {
592 int i;
593 printk(" Ring data dump: dirty_tx %d cur_tx %d cur_rx %d.",
594 lp->dirty_tx, lp->cur_tx, lp->cur_rx);
595 for (i = 0 ; i < RX_RING_SIZE; i++)
596 printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
597 lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
598 lp->rx_ring[i].msg_length);
599 for (i = 0 ; i < TX_RING_SIZE; i++)
600 printk(" %s%08x %04x %04x", i & 0x3 ? "" : "\n ",
601 lp->tx_ring[i].base, -lp->tx_ring[i].length,
602 lp->tx_ring[i].misc);
603 printk("\n");
604 }
605 #endif
606 lance_init_ring(dev);
607 outw(0x0043, ioaddr+LANCE_DATA);
608
609 dev->tbusy=0;
610 dev->trans_start = jiffies;
611
612 return 0;
613 }
614
615 if (skb == NULL) {
616 dev_tint(dev);
617 return 0;
618 }
619
620 if (skb->len <= 0)
621 return 0;
622
623 if (lance_debug > 3) {
624 outw(0x0000, ioaddr+LANCE_ADDR);
625 printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
626 inw(ioaddr+LANCE_DATA));
627 outw(0x0000, ioaddr+LANCE_DATA);
628 }
629
630
631
632 if (set_bit(0, (void*)&dev->tbusy) != 0) {
633 printk("%s: Transmitter access conflict.\n", dev->name);
634 return 1;
635 }
636
637 if (set_bit(0, (void*)&lp->lock) != 0) {
638 if (lance_debug > 2)
639 printk("%s: tx queue lock!.\n", dev->name);
640
641 return 1;
642 }
643
644
645
646
647 entry = lp->cur_tx & TX_RING_MOD_MASK;
648
649
650
651
652
653 if (lp->chip_version == OLD_LANCE) {
654 lp->tx_ring[entry].length =
655 -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
656 } else
657 lp->tx_ring[entry].length = -skb->len;
658
659 lp->tx_ring[entry].misc = 0x0000;
660
661
662
663 if ((int)(skb->data) + skb->len > 0x01000000) {
664 if (lance_debug > 5)
665 printk("%s: bouncing a high-memory packet (%#x).\n",
666 dev->name, (int)(skb->data));
667 memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
668 lp->tx_ring[entry].base =
669 (int)(lp->tx_bounce_buffs + entry) | 0x83000000;
670 dev_kfree_skb (skb, FREE_WRITE);
671 } else {
672 lp->tx_skbuff[entry] = skb;
673 lp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
674 }
675 lp->cur_tx++;
676
677
678 outw(0x0000, ioaddr+LANCE_ADDR);
679 outw(0x0048, ioaddr+LANCE_DATA);
680
681 dev->trans_start = jiffies;
682
683 cli();
684 lp->lock = 0;
685 if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
686 dev->tbusy=0;
687 else
688 lp->tx_full = 1;
689 sti();
690
691 return 0;
692 }
693
694
695 static void
696 lance_interrupt(int reg_ptr)
697 {
698 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
699 struct device *dev = (struct device *)(irq2dev_map[irq]);
700 struct lance_private *lp;
701 int csr0, ioaddr;
702
703 if (dev == NULL) {
704 printk ("lance_interrupt(): irq %d for unknown device.\n", irq);
705 return;
706 }
707
708 ioaddr = dev->base_addr;
709 lp = (struct lance_private *)dev->priv;
710 if (dev->interrupt)
711 printk("%s: Re-entering the interrupt handler.\n", dev->name);
712
713 dev->interrupt = 1;
714
715 outw(0x00, dev->base_addr + LANCE_ADDR);
716 csr0 = inw(dev->base_addr + LANCE_DATA);
717
718
719 outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
720
721 if (lance_debug > 5)
722 printk("%s: interrupt csr0=%#2.2x new csr=%#2.2x.\n",
723 dev->name, csr0, inw(dev->base_addr + LANCE_DATA));
724
725 if (csr0 & 0x0400)
726 lance_rx(dev);
727
728 if (csr0 & 0x0200) {
729 int dirty_tx = lp->dirty_tx;
730
731 while (dirty_tx < lp->cur_tx) {
732 int entry = dirty_tx & TX_RING_MOD_MASK;
733 int status = lp->tx_ring[entry].base;
734
735 if (status < 0)
736 break;
737
738 lp->tx_ring[entry].base = 0;
739
740 if (status & 0x40000000) {
741 int err_status = lp->tx_ring[entry].misc;
742 lp->stats.tx_errors++;
743 if (err_status & 0x0400) lp->stats.tx_aborted_errors++;
744 if (err_status & 0x0800) lp->stats.tx_carrier_errors++;
745 if (err_status & 0x1000) lp->stats.tx_window_errors++;
746 if (err_status & 0x4000) lp->stats.tx_fifo_errors++;
747
748 } else {
749 if (status & 0x18000000)
750 lp->stats.collisions++;
751 lp->stats.tx_packets++;
752 }
753
754
755
756 if (lp->tx_skbuff[entry]) {
757 dev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
758 lp->tx_skbuff[entry] = 0;
759 }
760 dirty_tx++;
761 }
762
763 #ifndef final_version
764 if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
765 printk("out-of-sync dirty pointer, %d vs. %d.\n",
766 dirty_tx, lp->cur_tx);
767 dirty_tx += TX_RING_SIZE;
768 }
769 #endif
770
771 if (lp->tx_full && dev->tbusy && dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
772
773 lp->tx_full = 0;
774 dev->tbusy = 0;
775 mark_bh(NET_BH);
776 }
777
778 lp->dirty_tx = dirty_tx;
779 }
780
781 if (csr0 & 0x8000) {
782 if (csr0 & 0x4000) lp->stats.tx_errors++;
783 if (csr0 & 0x1000) lp->stats.rx_errors++;
784 }
785
786
787 outw(0x0000, dev->base_addr + LANCE_ADDR);
788 outw(0x7f40, dev->base_addr + LANCE_DATA);
789
790 if (lance_debug > 4)
791 printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
792 dev->name, inw(ioaddr + LANCE_ADDR),
793 inw(dev->base_addr + LANCE_DATA));
794
795 dev->interrupt = 0;
796 return;
797 }
798
799 static int
800 lance_rx(struct device *dev)
801 {
802 struct lance_private *lp = (struct lance_private *)dev->priv;
803 int entry = lp->cur_rx & RX_RING_MOD_MASK;
804 int i;
805
806
807 while (lp->rx_ring[entry].base >= 0) {
808 int status = lp->rx_ring[entry].base >> 24;
809
810 if (status != 0x03) {
811
812
813
814
815 if (status & 0x01)
816 lp->stats.rx_errors++;
817 if (status & 0x20) lp->stats.rx_frame_errors++;
818 if (status & 0x10) lp->stats.rx_over_errors++;
819 if (status & 0x08) lp->stats.rx_crc_errors++;
820 if (status & 0x04) lp->stats.rx_fifo_errors++;
821 lp->rx_ring[entry].base &= 0x03ffffff;
822 } else {
823
824 short pkt_len = lp->rx_ring[entry].msg_length;
825 struct sk_buff *skb;
826
827 skb = alloc_skb(pkt_len, GFP_ATOMIC);
828 if (skb == NULL) {
829 printk("%s: Memory squeeze, deferring packet.\n", dev->name);
830 for (i=0; i < RX_RING_SIZE; i++)
831 if (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
832 break;
833
834 if (i > RX_RING_SIZE -2) {
835 lp->stats.rx_dropped++;
836 lp->rx_ring[entry].base |= 0x80000000;
837 lp->cur_rx++;
838 }
839 break;
840 }
841 skb->len = pkt_len;
842 skb->dev = dev;
843 memcpy(skb->data,
844 (unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
845 pkt_len);
846 netif_rx(skb);
847 lp->stats.rx_packets++;
848 }
849
850 lp->rx_ring[entry].base |= 0x80000000;
851
852
853 lp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
854 entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
855 }
856
857
858
859
860 return 0;
861 }
862
863 static int
864 lance_close(struct device *dev)
865 {
866 int ioaddr = dev->base_addr;
867 struct lance_private *lp = (struct lance_private *)dev->priv;
868
869 dev->start = 0;
870 dev->tbusy = 1;
871
872 outw(112, ioaddr+LANCE_ADDR);
873 lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
874
875 outw(0, ioaddr+LANCE_ADDR);
876
877 if (lance_debug > 1)
878 printk("%s: Shutting down ethercard, status was %2.2x.\n",
879 dev->name, inw(ioaddr+LANCE_DATA));
880
881
882
883 outw(0x0004, ioaddr+LANCE_DATA);
884
885 disable_dma(dev->dma);
886
887 free_irq(dev->irq);
888
889 irq2dev_map[dev->irq] = 0;
890
891 return 0;
892 }
893
894 static struct enet_statistics *
895 lance_get_stats(struct device *dev)
896 {
897 struct lance_private *lp = (struct lance_private *)dev->priv;
898 short ioaddr = dev->base_addr;
899 short saved_addr;
900
901 cli();
902 saved_addr = inw(ioaddr+LANCE_ADDR);
903 outw(112, ioaddr+LANCE_ADDR);
904 lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
905 outw(saved_addr, ioaddr+LANCE_ADDR);
906 sti();
907
908 return &lp->stats;
909 }
910
911
912
913
914
915
916
917 static void
918 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
919 {
920 short ioaddr = dev->base_addr;
921
922
923 outw(0, ioaddr+LANCE_ADDR);
924 outw(0x0004, ioaddr+LANCE_DATA);
925
926 outw(15, ioaddr+LANCE_ADDR);
927 if (num_addrs >= 0) {
928 short multicast_table[4];
929 int i;
930
931 memset(multicast_table, (num_addrs == 0) ? 0 : -1, sizeof(multicast_table));
932 for (i = 0; i < 4; i++) {
933 outw(8 + i, ioaddr+LANCE_ADDR);
934 outw(multicast_table[i], ioaddr+LANCE_DATA);
935 }
936 outw(0x0000, ioaddr+LANCE_DATA);
937 } else {
938 outw(0x8000, ioaddr+LANCE_DATA);
939 }
940
941 outw(0, ioaddr+LANCE_ADDR);
942 outw(0x0142, ioaddr+LANCE_DATA);
943 }
944
945
946
947
948
949
950
951
952