![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 8390.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net|
Return to 8390.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 root 1: /* 8390.c: A general NS8390 ethernet driver core for linux. */
2: /*
3: Written 1992-94 by Donald Becker.
4:
5: Copyright 1993 United States Government as represented by the
6: Director, National Security Agency.
7:
8: This software may be used and distributed according to the terms
9: of the GNU Public License, incorporated herein by reference.
10:
11: The author may be reached as [email protected], or C/O
12: Center of Excellence in Space Data and Information Sciences
13: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
14:
15: This is the chip-specific code for many 8390-based ethernet adaptors.
16: This is not a complete driver, it must be combined with board-specific
17: code such as ne.c, wd.c, 3c503.c, etc.
18:
19: Changelog:
20:
21: Paul Gortmaker : remove set_bit lock, other cleanups.
22: Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
23: ei_block_input() for eth_io_copy_and_sum().
24:
25: */
26:
27: static const char *version =
28: "8390.c:v1.10 9/23/94 Donald Becker ([email protected])\n";
29:
30: /*
31: Braindamage remaining:
32: Much of this code should have been cleaned up, but every attempt
33: has broken some clone part.
34:
35: Sources:
36: The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
37: */
38:
39: #include <linux/module.h>
40:
41: #include <linux/kernel.h>
42: #include <linux/sched.h>
43: #include <linux/fs.h>
44: #include <linux/types.h>
45: #include <linux/ptrace.h>
46: #include <linux/string.h>
47: #include <asm/system.h>
48: #include <asm/segment.h>
49: #include <asm/bitops.h>
50: #include <asm/io.h>
51: #include <linux/errno.h>
52: #include <linux/fcntl.h>
53: #include <linux/in.h>
54: #include <linux/interrupt.h>
55:
56: #include <linux/netdevice.h>
57: #include <linux/etherdevice.h>
58:
59: #include "8390.h"
60:
61: /* These are the operational function interfaces to board-specific
62: routines.
63: void reset_8390(struct device *dev)
64: Resets the board associated with DEV, including a hardware reset of
65: the 8390. This is only called when there is a transmit timeout, and
66: it is always followed by 8390_init().
67: void block_output(struct device *dev, int count, const unsigned char *buf,
68: int start_page)
69: Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
70: "page" value uses the 8390's 256-byte pages.
71: void get_8390_hdr(struct device *dev, struct e8390_hdr *hdr, int ring_page)
72: Read the 4 byte, page aligned 8390 header. *If* there is a
73: subsequent read, it will be of the rest of the packet.
74: void block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
75: Read COUNT bytes from the packet buffer into the skb data area. Start
76: reading from RING_OFFSET, the address as the 8390 sees it. This will always
77: follow the read of the 8390 header.
78: */
79: #define ei_reset_8390 (ei_local->reset_8390)
80: #define ei_block_output (ei_local->block_output)
81: #define ei_block_input (ei_local->block_input)
82: #define ei_get_8390_hdr (ei_local->get_8390_hdr)
83:
84: /* use 0 for production, 1 for verification, >2 for debug */
85: #ifdef EI_DEBUG
86: int ei_debug = EI_DEBUG;
87: #else
88: int ei_debug = 0;
89: #endif
90: #ifdef EI_PINGPONG
91: static int ei_pingpong = 1;
92: #else
93: static int ei_pingpong = 0;
94: #endif
95:
96: /* Max number of packets received at one Intr.
97: Currently this may only be examined by a kernel debugger. */
98: static int high_water_mark = 0;
99:
100: /* Index to functions. */
101: static void ei_tx_intr(struct device *dev);
102: static void ei_receive(struct device *dev);
103: static void ei_rx_overrun(struct device *dev);
104:
105: /* Routines generic to NS8390-based boards. */
106: static void NS8390_trigger_send(struct device *dev, unsigned int length,
107: int start_page);
108: static void set_multicast_list(struct device *dev);
109:
110:
111: /* Open/initialize the board. This routine goes all-out, setting everything
112: up anew at each open, even though many of these registers should only
113: need to be set once at boot.
114: */
115: int ei_open(struct device *dev)
116: {
117: struct ei_device *ei_local = (struct ei_device *) dev->priv;
118:
119: /* This can't happen unless somebody forgot to call ethdev_init(). */
120: if (ei_local == NULL) {
121: printk(KERN_EMERG "%s: ei_open passed a non-existent device!\n", dev->name);
122: return -ENXIO;
123: }
124:
125: irq2dev_map[dev->irq] = dev;
126: NS8390_init(dev, 1);
127: dev->start = 1;
128: ei_local->irqlock = 0;
129: return 0;
130: }
131:
132: /* Opposite of above. Only used when "ifconfig <devname> down" is done. */
133: int ei_close(struct device *dev)
134: {
135: NS8390_init(dev, 0);
136: dev->start = 0;
137: return 0;
138: }
139:
140: static int ei_start_xmit(struct sk_buff *skb, struct device *dev)
141: {
142: int e8390_base = dev->base_addr;
143: struct ei_device *ei_local = (struct ei_device *) dev->priv;
144: int length, send_length;
145:
146: /*
147: * We normally shouldn't be called if dev->tbusy is set, but the
148: * existing code does anyway. If it has been too long since the
149: * last Tx, we assume the board has died and kick it.
150: */
151:
152: if (dev->tbusy) { /* Do timeouts, just like the 8003 driver. */
153: int txsr = inb(e8390_base+EN0_TSR), isr;
154: int tickssofar = jiffies - dev->trans_start;
155: if (tickssofar < TX_TIMEOUT || (tickssofar < (TX_TIMEOUT+5) && ! (txsr & ENTSR_PTX))) {
156: return 1;
157: }
158: isr = inb(e8390_base+EN0_ISR);
159: if (dev->start == 0) {
160: printk("%s: xmit on stopped card\n", dev->name);
161: return 1;
162: }
163:
164: printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
165: dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
166: (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
167:
168: if (!isr && !ei_local->stat.tx_packets) {
169: /* The 8390 probably hasn't gotten on the cable yet. */
170: ei_local->interface_num ^= 1; /* Try a different xcvr. */
171: }
172:
173: /* Try to restart the card. Perhaps the user has fixed something. */
174: ei_reset_8390(dev);
175: NS8390_init(dev, 1);
176: dev->trans_start = jiffies;
177: }
178:
179: /* Sending a NULL skb means some higher layer thinks we've missed an
180: tx-done interrupt. Caution: dev_tint() handles the cli()/sti()
181: itself. */
182: if (skb == NULL) {
183: dev_tint(dev);
184: return 0;
185: }
186:
187: length = skb->len;
188: if (skb->len <= 0)
189: return 0;
190:
191: /* Mask interrupts from the ethercard. */
192: outb_p(0x00, e8390_base + EN0_IMR);
193: if (dev->interrupt) {
194: printk("%s: Tx request while isr active.\n",dev->name);
195: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
196: return 1;
197: }
198: ei_local->irqlock = 1;
199:
200: send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
201:
202: if (ei_local->pingpong) {
203: int output_page;
204: if (ei_local->tx1 == 0) {
205: output_page = ei_local->tx_start_page;
206: ei_local->tx1 = send_length;
207: if (ei_debug && ei_local->tx2 > 0)
208: printk("%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
209: dev->name, ei_local->tx2, ei_local->lasttx,
210: ei_local->txing);
211: } else if (ei_local->tx2 == 0) {
212: output_page = ei_local->tx_start_page + 6;
213: ei_local->tx2 = send_length;
214: if (ei_debug && ei_local->tx1 > 0)
215: printk("%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
216: dev->name, ei_local->tx1, ei_local->lasttx,
217: ei_local->txing);
218: } else { /* We should never get here. */
219: if (ei_debug)
220: printk("%s: No Tx buffers free. irq=%d tx1=%d tx2=%d last=%d\n",
221: dev->name, dev->interrupt, ei_local->tx1,
222: ei_local->tx2, ei_local->lasttx);
223: ei_local->irqlock = 0;
224: dev->tbusy = 1;
225: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
226: return 1;
227: }
228: ei_block_output(dev, length, skb->data, output_page);
229: if (! ei_local->txing) {
230: ei_local->txing = 1;
231: NS8390_trigger_send(dev, send_length, output_page);
232: dev->trans_start = jiffies;
233: if (output_page == ei_local->tx_start_page)
234: ei_local->tx1 = -1, ei_local->lasttx = -1;
235: else
236: ei_local->tx2 = -1, ei_local->lasttx = -2;
237: } else
238: ei_local->txqueue++;
239:
240: dev->tbusy = (ei_local->tx1 && ei_local->tx2);
241: } else { /* No pingpong, just a single Tx buffer. */
242: ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
243: ei_local->txing = 1;
244: NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
245: dev->trans_start = jiffies;
246: dev->tbusy = 1;
247: }
248:
249: /* Turn 8390 interrupts back on. */
250: ei_local->irqlock = 0;
251: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
252:
253: dev_kfree_skb (skb, FREE_WRITE);
254:
255: return 0;
256: }
257:
258: /* The typical workload of the driver:
259: Handle the ether interface interrupts. */
260: void ei_interrupt(int irq, struct pt_regs * regs)
261: {
262: struct device *dev = (struct device *)(irq2dev_map[irq]);
263: int e8390_base;
264: int interrupts, nr_serviced = 0;
265: struct ei_device *ei_local;
266:
267: if (dev == NULL) {
268: printk ("net_interrupt(): irq %d for unknown device.\n", irq);
269: return;
270: }
271: e8390_base = dev->base_addr;
272: ei_local = (struct ei_device *) dev->priv;
273: if (dev->interrupt || ei_local->irqlock) {
274: /* The "irqlock" check is only for testing. */
275: printk(ei_local->irqlock
276: ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
277: : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
278: dev->name, inb_p(e8390_base + EN0_ISR),
279: inb_p(e8390_base + EN0_IMR));
280: return;
281: }
282:
283: dev->interrupt = 1;
284:
285: /* Change to page 0 and read the intr status reg. */
286: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
287: if (ei_debug > 3)
288: printk("%s: interrupt(isr=%#2.2x).\n", dev->name,
289: inb_p(e8390_base + EN0_ISR));
290:
291: /* !!Assumption!! -- we stay in page 0. Don't break this. */
292: while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
293: && ++nr_serviced < MAX_SERVICE) {
294: if (dev->start == 0) {
295: printk("%s: interrupt from stopped card\n", dev->name);
296: interrupts = 0;
297: break;
298: }
299: if (interrupts & ENISR_OVER) {
300: ei_rx_overrun(dev);
301: } else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
302: /* Got a good (?) packet. */
303: ei_receive(dev);
304: }
305: /* Push the next to-transmit packet through. */
306: if (interrupts & ENISR_TX) {
307: ei_tx_intr(dev);
308: } else if (interrupts & ENISR_COUNTERS) {
309: ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
310: ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
311: ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
312: outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
313: }
314:
315: /* Ignore the transmit errs and reset intr for now. */
316: if (interrupts & ENISR_TX_ERR) {
317: outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
318: }
319:
320: /* Ignore any RDC interrupts that make it back to here. */
321: if (interrupts & ENISR_RDC) {
322: outb_p(ENISR_RDC, e8390_base + EN0_ISR);
323: }
324:
325: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
326: }
327:
328: if (interrupts && ei_debug) {
329: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
330: if (nr_serviced >= MAX_SERVICE) {
331: printk("%s: Too much work at interrupt, status %#2.2x\n",
332: dev->name, interrupts);
333: outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
334: } else {
335: printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
336: outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
337: }
338: }
339: dev->interrupt = 0;
340: return;
341: }
342:
343: /* We have finished a transmit: check for errors and then trigger the next
344: packet to be sent. */
345: static void ei_tx_intr(struct device *dev)
346: {
347: int e8390_base = dev->base_addr;
348: int status = inb(e8390_base + EN0_TSR);
349: struct ei_device *ei_local = (struct ei_device *) dev->priv;
350:
351: outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
352:
353: if (ei_local->pingpong) {
354: ei_local->txqueue--;
355: if (ei_local->tx1 < 0) {
356: if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
357: printk("%s: bogus last_tx_buffer %d, tx1=%d.\n",
358: ei_local->name, ei_local->lasttx, ei_local->tx1);
359: ei_local->tx1 = 0;
360: dev->tbusy = 0;
361: if (ei_local->tx2 > 0) {
362: ei_local->txing = 1;
363: NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
364: dev->trans_start = jiffies;
365: ei_local->tx2 = -1,
366: ei_local->lasttx = 2;
367: } else
368: ei_local->lasttx = 20, ei_local->txing = 0;
369: } else if (ei_local->tx2 < 0) {
370: if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
371: printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
372: ei_local->name, ei_local->lasttx, ei_local->tx2);
373: ei_local->tx2 = 0;
374: dev->tbusy = 0;
375: if (ei_local->tx1 > 0) {
376: ei_local->txing = 1;
377: NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
378: dev->trans_start = jiffies;
379: ei_local->tx1 = -1;
380: ei_local->lasttx = 1;
381: } else
382: ei_local->lasttx = 10, ei_local->txing = 0;
383: } else
384: printk("%s: unexpected TX-done interrupt, lasttx=%d.\n",
385: dev->name, ei_local->lasttx);
386: } else {
387: ei_local->txing = 0;
388: dev->tbusy = 0;
389: }
390:
391: /* Minimize Tx latency: update the statistics after we restart TXing. */
392: if (status & ENTSR_COL) ei_local->stat.collisions++;
393: if (status & ENTSR_PTX)
394: ei_local->stat.tx_packets++;
395: else {
396: ei_local->stat.tx_errors++;
397: if (status & ENTSR_ABT) ei_local->stat.tx_aborted_errors++;
398: if (status & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
399: if (status & ENTSR_FU) ei_local->stat.tx_fifo_errors++;
400: if (status & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
401: if (status & ENTSR_OWC) ei_local->stat.tx_window_errors++;
402: }
403:
404: mark_bh (NET_BH);
405: }
406:
407: /* We have a good packet(s), get it/them out of the buffers. */
408:
409: static void ei_receive(struct device *dev)
410: {
411: int e8390_base = dev->base_addr;
412: struct ei_device *ei_local = (struct ei_device *) dev->priv;
413: int rxing_page, this_frame, next_frame, current_offset;
414: int rx_pkt_count = 0;
415: struct e8390_pkt_hdr rx_frame;
416: int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
417:
418: while (++rx_pkt_count < 10) {
419: int pkt_len;
420:
421: /* Get the rx page (incoming packet pointer). */
422: outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
423: rxing_page = inb_p(e8390_base + EN1_CURPAG);
424: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
425:
426: /* Remove one frame from the ring. Boundary is always a page behind. */
427: this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
428: if (this_frame >= ei_local->stop_page)
429: this_frame = ei_local->rx_start_page;
430:
431: /* Someday we'll omit the previous, iff we never get this message.
432: (There is at least one clone claimed to have a problem.) */
433: if (ei_debug > 0 && this_frame != ei_local->current_page)
434: printk("%s: mismatched read page pointers %2x vs %2x.\n",
435: dev->name, this_frame, ei_local->current_page);
436:
437: if (this_frame == rxing_page) /* Read all the frames? */
438: break; /* Done for now */
439:
440: current_offset = this_frame << 8;
441: ei_get_8390_hdr(dev, &rx_frame, this_frame);
442:
443: pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
444:
445: next_frame = this_frame + 1 + ((pkt_len+4)>>8);
446:
447: /* Check for bogosity warned by 3c503 book: the status byte is never
448: written. This happened a lot during testing! This code should be
449: cleaned up someday. */
450: if (rx_frame.next != next_frame
451: && rx_frame.next != next_frame + 1
452: && rx_frame.next != next_frame - num_rx_pages
453: && rx_frame.next != next_frame + 1 - num_rx_pages) {
454: ei_local->current_page = rxing_page;
455: outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
456: ei_local->stat.rx_errors++;
457: continue;
458: }
459:
460: if (pkt_len < 60 || pkt_len > 1518) {
461: if (ei_debug)
462: printk("%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
463: dev->name, rx_frame.count, rx_frame.status,
464: rx_frame.next);
465: ei_local->stat.rx_errors++;
466: } else if ((rx_frame.status & 0x0F) == ENRSR_RXOK) {
467: struct sk_buff *skb;
468:
469: skb = dev_alloc_skb(pkt_len+2);
470: if (skb == NULL) {
471: if (ei_debug > 1)
472: printk("%s: Couldn't allocate a sk_buff of size %d.\n",
473: dev->name, pkt_len);
474: ei_local->stat.rx_dropped++;
475: break;
476: } else {
477: skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
478: skb->dev = dev;
479: skb_put(skb, pkt_len); /* Make room */
480: ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
481: skb->protocol=eth_type_trans(skb,dev);
482: netif_rx(skb);
483: ei_local->stat.rx_packets++;
484: }
485: } else {
486: int errs = rx_frame.status;
487: if (ei_debug)
488: printk("%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
489: dev->name, rx_frame.status, rx_frame.next,
490: rx_frame.count);
491: if (errs & ENRSR_FO)
492: ei_local->stat.rx_fifo_errors++;
493: }
494: next_frame = rx_frame.next;
495:
496: /* This _should_ never happen: it's here for avoiding bad clones. */
497: if (next_frame >= ei_local->stop_page) {
498: printk("%s: next frame inconsistency, %#2x\n", dev->name,
499: next_frame);
500: next_frame = ei_local->rx_start_page;
501: }
502: ei_local->current_page = next_frame;
503: outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
504: }
505: /* If any worth-while packets have been received, netif_rx()
506: has done a mark_bh(NET_BH) for us and will work on them
507: when we get to the bottom-half routine. */
508:
509: /* Record the maximum Rx packet queue. */
510: if (rx_pkt_count > high_water_mark)
511: high_water_mark = rx_pkt_count;
512:
513: /* We used to also ack ENISR_OVER here, but that would sometimes mask
514: a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
515: outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
516: return;
517: }
518:
519: /* We have a receiver overrun: we have to kick the 8390 to get it started
520: again.*/
521: static void ei_rx_overrun(struct device *dev)
522: {
523: int e8390_base = dev->base_addr;
524: int reset_start_time = jiffies;
525: struct ei_device *ei_local = (struct ei_device *) dev->priv;
526:
527: /* We should already be stopped and in page0. Remove after testing. */
528: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
529:
530: if (ei_debug > 1)
531: printk("%s: Receiver overrun.\n", dev->name);
532: ei_local->stat.rx_over_errors++;
533:
534: /* The old Biro driver does dummy = inb_p( RBCR[01] ); at this point.
535: It might mean something -- magic to speed up a reset? A 8390 bug?*/
536:
537: /* Wait for the reset to complete. This should happen almost instantly,
538: but could take up to 1.5msec in certain rare instances. There is no
539: easy way of timing something in that range, so we use 'jiffies' as
540: a sanity check. */
541: while ((inb_p(e8390_base+EN0_ISR) & ENISR_RESET) == 0)
542: if (jiffies - reset_start_time > 2*HZ/100) {
543: printk("%s: reset did not complete at ei_rx_overrun.\n",
544: dev->name);
545: NS8390_init(dev, 1);
546: return;
547: }
548:
549: /* Remove packets right away. */
550: ei_receive(dev);
551:
552: outb_p(ENISR_OVER, e8390_base+EN0_ISR);
553: /* Generic 8390 insns to start up again, same as in open_8390(). */
554: outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
555: outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
556: }
557:
558: static struct enet_statistics *get_stats(struct device *dev)
559: {
560: short ioaddr = dev->base_addr;
561: struct ei_device *ei_local = (struct ei_device *) dev->priv;
562:
563: /* If the card is stopped, just return the present stats. */
564: if (dev->start == 0) return &ei_local->stat;
565:
566: /* Read the counter registers, assuming we are in page 0. */
567: ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
568: ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
569: ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
570:
571: return &ei_local->stat;
572: }
573:
574: /*
575: * Set or clear the multicast filter for this adaptor.
576: */
577:
578: static void set_multicast_list(struct device *dev)
579: {
580: short ioaddr = dev->base_addr;
581:
582: if(dev->flags&IFF_PROMISC)
583: {
584: outb_p(E8390_RXCONFIG | 0x18, ioaddr + EN0_RXCR);
585: }
586: else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
587: {
588: /* The multicast-accept list is initialized to accept-all, and we
589: rely on higher-level filtering for now. */
590: outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
591: }
592: else
593: outb_p(E8390_RXCONFIG, ioaddr + EN0_RXCR);
594: }
595:
596: /* Initialize the rest of the 8390 device structure. */
597: int ethdev_init(struct device *dev)
598: {
599: if (ei_debug > 1)
600: printk(version);
601:
602: if (dev->priv == NULL) {
603: struct ei_device *ei_local;
604:
605: dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
606: if (dev->priv == NULL)
607: return -ENOMEM;
608: memset(dev->priv, 0, sizeof(struct ei_device));
609: ei_local = (struct ei_device *)dev->priv;
610: ei_local->pingpong = ei_pingpong;
611: }
612:
613: dev->hard_start_xmit = &ei_start_xmit;
614: dev->get_stats = get_stats;
615: dev->set_multicast_list = &set_multicast_list;
616:
617: ether_setup(dev);
618:
619: return 0;
620: }
621:
622:
623: /* This page of functions should be 8390 generic */
624: /* Follow National Semi's recommendations for initializing the "NIC". */
625: void NS8390_init(struct device *dev, int startp)
626: {
627: int e8390_base = dev->base_addr;
628: struct ei_device *ei_local = (struct ei_device *) dev->priv;
629: int i;
630: int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
631: unsigned long flags;
632:
633: /* Follow National Semi's recommendations for initing the DP83902. */
634: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base); /* 0x21 */
635: outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
636: /* Clear the remote byte count registers. */
637: outb_p(0x00, e8390_base + EN0_RCNTLO);
638: outb_p(0x00, e8390_base + EN0_RCNTHI);
639: /* Set to monitor and loopback mode -- this is vital!. */
640: outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
641: outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
642: /* Set the transmit page and receive ring. */
643: outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
644: ei_local->tx1 = ei_local->tx2 = 0;
645: outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
646: outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
647: ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
648: outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
649: /* Clear the pending interrupts and mask. */
650: outb_p(0xFF, e8390_base + EN0_ISR);
651: outb_p(0x00, e8390_base + EN0_IMR);
652:
653: /* Copy the station address into the DS8390 registers,
654: and set the multicast hash bitmap to receive all multicasts. */
655: save_flags(flags);
656: cli();
657: outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base); /* 0x61 */
658: for(i = 0; i < 6; i++) {
659: outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
660: }
661: /* Initialize the multicast list to accept-all. If we enable multicast
662: the higher levels can do the filtering. */
663: for(i = 0; i < 8; i++)
664: outb_p(0xff, e8390_base + EN1_MULT + i);
665:
666: outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
667: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
668: restore_flags(flags);
669: dev->tbusy = 0;
670: dev->interrupt = 0;
671: ei_local->tx1 = ei_local->tx2 = 0;
672: ei_local->txing = 0;
673: if (startp) {
674: outb_p(0xff, e8390_base + EN0_ISR);
675: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
676: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base);
677: outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
678: /* 3c503 TechMan says rxconfig only after the NIC is started. */
679: outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
680: dev->set_multicast_list(dev); /* Get the multicast status right if this
681: was a reset. */
682: }
683: return;
684: }
685:
686: /* Trigger a transmit start, assuming the length is valid. */
687: static void NS8390_trigger_send(struct device *dev, unsigned int length,
688: int start_page)
689: {
690: int e8390_base = dev->base_addr;
691:
692: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base);
693:
694: if (inb_p(e8390_base) & E8390_TRANS) {
695: printk("%s: trigger_send() called with the transmitter busy.\n",
696: dev->name);
697: return;
698: }
699: outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
700: outb_p(length >> 8, e8390_base + EN0_TCNTHI);
701: outb_p(start_page, e8390_base + EN0_TPSR);
702: outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base);
703: return;
704: }
705:
706: #ifdef MODULE
707:
708: int init_module(void)
709: {
710: return 0;
711: }
712:
713: void
714: cleanup_module(void)
715: {
716: }
717: #endif /* MODULE */
718:
719: /*
720: * Local variables:
721: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
722: * version-control: t
723: * kept-new-versions: 5
724: * c-indent-level: 4
725: * tab-width: 4
726: * End:
727: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.