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