![[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 / linux / src / drivers / net|
Return to 8390.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / 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: Seeing how at least eight drivers use this code, (not counting the
20: PCMCIA ones either) it is easy to break some card by what seems like
21: a simple innocent change. Please contact me or Donald if you think
22: you have found something that needs changing. -- PG
23:
24:
25: Changelog:
26:
27: Paul Gortmaker : remove set_bit lock, other cleanups.
28: Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
29: ei_block_input() for eth_io_copy_and_sum().
30: Paul Gortmaker : exchange static int ei_pingpong for a #define,
31: also add better Tx error handling.
32: Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
33:
34:
35: Sources:
36: The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
37:
38: */
39:
40: static const char *version =
41: "8390.c:v1.10 9/23/94 Donald Becker ([email protected])\n";
42:
43: #include <linux/module.h>
44: #include <linux/kernel.h>
45: #include <linux/sched.h>
46: #include <linux/fs.h>
47: #include <linux/types.h>
48: #include <linux/ptrace.h>
49: #include <linux/string.h>
50: #include <asm/system.h>
51: #include <asm/segment.h>
52: #include <asm/bitops.h>
53: #include <asm/io.h>
54: #include <linux/errno.h>
55: #include <linux/fcntl.h>
56: #include <linux/in.h>
57: #include <linux/interrupt.h>
58:
59: #include <linux/netdevice.h>
60: #include <linux/etherdevice.h>
61:
62: #include "8390.h"
63:
64: /* These are the operational function interfaces to board-specific
65: routines.
66: void reset_8390(struct device *dev)
67: Resets the board associated with DEV, including a hardware reset of
68: the 8390. This is only called when there is a transmit timeout, and
69: it is always followed by 8390_init().
70: void block_output(struct device *dev, int count, const unsigned char *buf,
71: int start_page)
72: Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
73: "page" value uses the 8390's 256-byte pages.
74: void get_8390_hdr(struct device *dev, struct e8390_hdr *hdr, int ring_page)
75: Read the 4 byte, page aligned 8390 header. *If* there is a
76: subsequent read, it will be of the rest of the packet.
77: void block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
78: Read COUNT bytes from the packet buffer into the skb data area. Start
79: reading from RING_OFFSET, the address as the 8390 sees it. This will always
80: follow the read of the 8390 header.
81: */
82: #define ei_reset_8390 (ei_local->reset_8390)
83: #define ei_block_output (ei_local->block_output)
84: #define ei_block_input (ei_local->block_input)
85: #define ei_get_8390_hdr (ei_local->get_8390_hdr)
86:
87: /* use 0 for production, 1 for verification, >2 for debug */
88: #ifdef EI_DEBUG
89: int ei_debug = EI_DEBUG;
90: #else
91: int ei_debug = 1;
92: #endif
93:
94: /* Index to functions. */
95: static void ei_tx_intr(struct device *dev);
96: static void ei_tx_err(struct device *dev);
97: static void ei_receive(struct device *dev);
98: static void ei_rx_overrun(struct device *dev);
99:
100: /* Routines generic to NS8390-based boards. */
101: static void NS8390_trigger_send(struct device *dev, unsigned int length,
102: int start_page);
103: static void set_multicast_list(struct device *dev);
104:
105:
106: /* Open/initialize the board. This routine goes all-out, setting everything
107: up anew at each open, even though many of these registers should only
108: need to be set once at boot.
109: */
110: int ei_open(struct device *dev)
111: {
112: struct ei_device *ei_local = (struct ei_device *) dev->priv;
113:
114: /* This can't happen unless somebody forgot to call ethdev_init(). */
115: if (ei_local == NULL) {
116: printk(KERN_EMERG "%s: ei_open passed a non-existent device!\n", dev->name);
117: return -ENXIO;
118: }
119:
120: irq2dev_map[dev->irq] = dev;
121: NS8390_init(dev, 1);
122: dev->start = 1;
123: ei_local->irqlock = 0;
124: return 0;
125: }
126:
127: /* Opposite of above. Only used when "ifconfig <devname> down" is done. */
128: int ei_close(struct device *dev)
129: {
130: NS8390_init(dev, 0);
131: dev->start = 0;
132: return 0;
133: }
134:
135: static int ei_start_xmit(struct sk_buff *skb, struct device *dev)
136: {
137: int e8390_base = dev->base_addr;
138: struct ei_device *ei_local = (struct ei_device *) dev->priv;
139: int length, send_length, output_page;
140:
141: /*
142: * We normally shouldn't be called if dev->tbusy is set, but the
143: * existing code does anyway. If it has been too long since the
144: * last Tx, we assume the board has died and kick it.
145: */
146:
147: if (dev->tbusy) { /* Do timeouts, just like the 8003 driver. */
148: int txsr = inb(e8390_base+EN0_TSR), isr;
149: int tickssofar = jiffies - dev->trans_start;
150: if (tickssofar < TX_TIMEOUT || (tickssofar < (TX_TIMEOUT+5) && ! (txsr & ENTSR_PTX))) {
151: return 1;
152: }
153: isr = inb(e8390_base+EN0_ISR);
154: if (dev->start == 0) {
155: printk("%s: xmit on stopped card\n", dev->name);
156: return 1;
157: }
158:
159: /*
160: * Note that if the Tx posted a TX_ERR interrupt, then the
161: * error will have been handled from the interrupt handler.
162: * and not here.
163: */
164:
165: printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
166: dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
167: (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
168:
169: if (!isr && !ei_local->stat.tx_packets) {
170: /* The 8390 probably hasn't gotten on the cable yet. */
171: ei_local->interface_num ^= 1; /* Try a different xcvr. */
172: }
173:
174: /* Try to restart the card. Perhaps the user has fixed something. */
175: ei_reset_8390(dev);
176: NS8390_init(dev, 1);
177: dev->trans_start = jiffies;
178: }
179:
180: /* Sending a NULL skb means some higher layer thinks we've missed an
181: tx-done interrupt. Caution: dev_tint() handles the cli()/sti()
182: itself. */
183: if (skb == NULL) {
184: dev_tint(dev);
185: return 0;
186: }
187:
188: length = skb->len;
189: if (skb->len <= 0)
190: return 0;
191:
192: /* Mask interrupts from the ethercard. */
193: outb_p(0x00, e8390_base + EN0_IMR);
194: if (dev->interrupt) {
195: printk("%s: Tx request while isr active.\n",dev->name);
196: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
197: return 1;
198: }
199: ei_local->irqlock = 1;
200:
201: send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
202:
203: #ifdef EI_PINGPONG
204:
205: /*
206: * We have two Tx slots available for use. Find the first free
207: * slot, and then perform some sanity checks. With two Tx bufs,
208: * you get very close to transmitting back-to-back packets. With
209: * only one Tx buf, the transmitter sits idle while you reload the
210: * card, leaving a substantial gap between each transmitted packet.
211: */
212:
213: if (ei_local->tx1 == 0) {
214: output_page = ei_local->tx_start_page;
215: ei_local->tx1 = send_length;
216: if (ei_debug && ei_local->tx2 > 0)
217: printk("%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
218: dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
219: } else if (ei_local->tx2 == 0) {
220: output_page = ei_local->tx_start_page + TX_1X_PAGES;
221: ei_local->tx2 = send_length;
222: if (ei_debug && ei_local->tx1 > 0)
223: printk("%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
224: dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
225: } else { /* We should never get here. */
226: if (ei_debug)
227: printk("%s: No Tx buffers free! irq=%d tx1=%d tx2=%d last=%d\n",
228: dev->name, dev->interrupt, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
229: ei_local->irqlock = 0;
230: dev->tbusy = 1;
231: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
232: return 1;
233: }
234:
235: /*
236: * Okay, now upload the packet and trigger a send if the transmitter
237: * isn't already sending. If it is busy, the interrupt handler will
238: * trigger the send later, upon receiving a Tx done interrupt.
239: */
240:
241: ei_block_output(dev, length, skb->data, output_page);
242: if (! ei_local->txing) {
243: ei_local->txing = 1;
244: NS8390_trigger_send(dev, send_length, output_page);
245: dev->trans_start = jiffies;
246: if (output_page == ei_local->tx_start_page) {
247: ei_local->tx1 = -1;
248: ei_local->lasttx = -1;
249: } else {
250: ei_local->tx2 = -1;
251: ei_local->lasttx = -2;
252: }
253: } else
254: ei_local->txqueue++;
255:
256: dev->tbusy = (ei_local->tx1 && ei_local->tx2);
257:
258: #else /* EI_PINGPONG */
259:
260: /*
261: * Only one Tx buffer in use. You need two Tx bufs to come close to
262: * back-to-back transmits. Expect a 20 -> 25% performance hit on
263: * reasonable hardware if you only use one Tx buffer.
264: */
265:
266: ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
267: ei_local->txing = 1;
268: NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
269: dev->trans_start = jiffies;
270: dev->tbusy = 1;
271:
272: #endif /* EI_PINGPONG */
273:
274: /* Turn 8390 interrupts back on. */
275: ei_local->irqlock = 0;
276: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
277:
278: dev_kfree_skb (skb, FREE_WRITE);
279:
280: return 0;
281: }
282:
283: /* The typical workload of the driver:
284: Handle the ether interface interrupts. */
285: void ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
286: {
287: struct device *dev = (struct device *)(irq2dev_map[irq]);
288: int e8390_base;
289: int interrupts, nr_serviced = 0;
290: struct ei_device *ei_local;
291:
292: if (dev == NULL) {
293: printk ("net_interrupt(): irq %d for unknown device.\n", irq);
294: return;
295: }
296: e8390_base = dev->base_addr;
297: ei_local = (struct ei_device *) dev->priv;
298: if (dev->interrupt || ei_local->irqlock) {
299: /* The "irqlock" check is only for testing. */
300: printk(ei_local->irqlock
301: ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
302: : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
303: dev->name, inb_p(e8390_base + EN0_ISR),
304: inb_p(e8390_base + EN0_IMR));
305: return;
306: }
307:
308: dev->interrupt = 1;
309:
310: /* Change to page 0 and read the intr status reg. */
311: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
312: if (ei_debug > 3)
313: printk("%s: interrupt(isr=%#2.2x).\n", dev->name,
314: inb_p(e8390_base + EN0_ISR));
315:
316: /* !!Assumption!! -- we stay in page 0. Don't break this. */
317: while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
318: && ++nr_serviced < MAX_SERVICE) {
319: if (dev->start == 0) {
320: printk("%s: interrupt from stopped card\n", dev->name);
321: interrupts = 0;
322: break;
323: }
324: if (interrupts & ENISR_OVER) {
325: ei_rx_overrun(dev);
326: } else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
327: /* Got a good (?) packet. */
328: ei_receive(dev);
329: }
330: /* Push the next to-transmit packet through. */
331: if (interrupts & ENISR_TX) {
332: ei_tx_intr(dev);
333: } else if (interrupts & ENISR_TX_ERR) {
334: ei_tx_err(dev);
335: }
336:
337: if (interrupts & ENISR_COUNTERS) {
338: ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
339: ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
340: ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
341: outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
342: }
343:
344: /* Ignore any RDC interrupts that make it back to here. */
345: if (interrupts & ENISR_RDC) {
346: outb_p(ENISR_RDC, e8390_base + EN0_ISR);
347: }
348:
349: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
350: }
351:
352: if (interrupts && ei_debug) {
353: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
354: if (nr_serviced >= MAX_SERVICE) {
355: printk("%s: Too much work at interrupt, status %#2.2x\n",
356: dev->name, interrupts);
357: outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
358: } else {
359: printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
360: outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
361: }
362: }
363: dev->interrupt = 0;
364: return;
365: }
366:
367: /*
368: * A transmitter error has happened. Most likely excess collisions (which
369: * is a fairly normal condition). If the error is one where the Tx will
370: * have been aborted, we try and send another one right away, instead of
371: * letting the failed packet sit and collect dust in the Tx buffer. This
372: * is a much better solution as it avoids kernel based Tx timeouts, and
373: * an unnecessary card reset.
374: */
375:
376: static void ei_tx_err(struct device *dev)
377: {
378: int e8390_base = dev->base_addr;
379: unsigned char txsr = inb_p(e8390_base+EN0_TSR);
380: unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
381: struct ei_device *ei_local = (struct ei_device *) dev->priv;
382:
383: #ifdef VERBOSE_ERROR_DUMP
384: printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
385: if (txsr & ENTSR_ABT)
386: printk("excess-collisions ");
387: if (txsr & ENTSR_ND)
388: printk("non-deferral ");
389: if (txsr & ENTSR_CRS)
390: printk("lost-carrier ");
391: if (txsr & ENTSR_FU)
392: printk("FIFO-underrun ");
393: if (txsr & ENTSR_CDH)
394: printk("lost-heartbeat ");
395: printk("\n");
396: #endif
397:
398: outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
399:
400: if (tx_was_aborted)
401: ei_tx_intr(dev);
402:
403: /*
404: * Note: NCR reads zero on 16 collisions so we add them
405: * in by hand. Somebody might care...
406: */
407: if (txsr & ENTSR_ABT)
408: ei_local->stat.collisions += 16;
409:
410: }
411:
412: /* We have finished a transmit: check for errors and then trigger the next
413: packet to be sent. */
414: static void ei_tx_intr(struct device *dev)
415: {
416: int e8390_base = dev->base_addr;
417: int status = inb(e8390_base + EN0_TSR);
418: struct ei_device *ei_local = (struct ei_device *) dev->priv;
419:
420: outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
421:
422: #ifdef EI_PINGPONG
423:
424: /*
425: * There are two Tx buffers, see which one finished, and trigger
426: * the send of another one if it exists.
427: */
428: ei_local->txqueue--;
429: if (ei_local->tx1 < 0) {
430: if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
431: printk("%s: bogus last_tx_buffer %d, tx1=%d.\n",
432: ei_local->name, ei_local->lasttx, ei_local->tx1);
433: ei_local->tx1 = 0;
434: dev->tbusy = 0;
435: if (ei_local->tx2 > 0) {
436: ei_local->txing = 1;
437: NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
438: dev->trans_start = jiffies;
439: ei_local->tx2 = -1,
440: ei_local->lasttx = 2;
441: } else
442: ei_local->lasttx = 20, ei_local->txing = 0;
443: } else if (ei_local->tx2 < 0) {
444: if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
445: printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
446: ei_local->name, ei_local->lasttx, ei_local->tx2);
447: ei_local->tx2 = 0;
448: dev->tbusy = 0;
449: if (ei_local->tx1 > 0) {
450: ei_local->txing = 1;
451: NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
452: dev->trans_start = jiffies;
453: ei_local->tx1 = -1;
454: ei_local->lasttx = 1;
455: } else
456: ei_local->lasttx = 10, ei_local->txing = 0;
457: } else
458: printk("%s: unexpected TX-done interrupt, lasttx=%d.\n",
459: dev->name, ei_local->lasttx);
460:
461: #else /* EI_PINGPONG */
462: /*
463: * Single Tx buffer: mark it free so another packet can be loaded.
464: */
465: ei_local->txing = 0;
466: dev->tbusy = 0;
467: #endif
468:
469: /* Minimize Tx latency: update the statistics after we restart TXing. */
470: if (status & ENTSR_COL)
471: ei_local->stat.collisions++;
472: if (status & ENTSR_PTX)
473: ei_local->stat.tx_packets++;
474: else {
475: ei_local->stat.tx_errors++;
476: if (status & ENTSR_ABT) ei_local->stat.tx_aborted_errors++;
477: if (status & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
478: if (status & ENTSR_FU) ei_local->stat.tx_fifo_errors++;
479: if (status & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
480: if (status & ENTSR_OWC) ei_local->stat.tx_window_errors++;
481: }
482:
483: mark_bh (NET_BH);
484: }
485:
486: /* We have a good packet(s), get it/them out of the buffers. */
487:
488: static void ei_receive(struct device *dev)
489: {
490: int e8390_base = dev->base_addr;
491: struct ei_device *ei_local = (struct ei_device *) dev->priv;
492: unsigned char rxing_page, this_frame, next_frame;
493: unsigned short current_offset;
494: int rx_pkt_count = 0;
495: struct e8390_pkt_hdr rx_frame;
496: int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
497:
498: while (++rx_pkt_count < 10) {
499: int pkt_len;
500:
501: /* Get the rx page (incoming packet pointer). */
502: outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
503: rxing_page = inb_p(e8390_base + EN1_CURPAG);
504: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
505:
506: /* Remove one frame from the ring. Boundary is always a page behind. */
507: this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
508: if (this_frame >= ei_local->stop_page)
509: this_frame = ei_local->rx_start_page;
510:
511: /* Someday we'll omit the previous, iff we never get this message.
512: (There is at least one clone claimed to have a problem.) */
513: if (ei_debug > 0 && this_frame != ei_local->current_page)
514: printk("%s: mismatched read page pointers %2x vs %2x.\n",
515: dev->name, this_frame, ei_local->current_page);
516:
517: if (this_frame == rxing_page) /* Read all the frames? */
518: break; /* Done for now */
519:
520: current_offset = this_frame << 8;
521: ei_get_8390_hdr(dev, &rx_frame, this_frame);
522:
523: pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
524:
525: next_frame = this_frame + 1 + ((pkt_len+4)>>8);
526:
527: /* Check for bogosity warned by 3c503 book: the status byte is never
528: written. This happened a lot during testing! This code should be
529: cleaned up someday. */
530: if (rx_frame.next != next_frame
531: && rx_frame.next != next_frame + 1
532: && rx_frame.next != next_frame - num_rx_pages
533: && rx_frame.next != next_frame + 1 - num_rx_pages) {
534: ei_local->current_page = rxing_page;
535: outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
536: ei_local->stat.rx_errors++;
537: continue;
538: }
539:
540: if (pkt_len < 60 || pkt_len > 1518) {
541: if (ei_debug)
542: printk("%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
543: dev->name, rx_frame.count, rx_frame.status,
544: rx_frame.next);
545: ei_local->stat.rx_errors++;
546: } else if ((rx_frame.status & 0x0F) == ENRSR_RXOK) {
547: struct sk_buff *skb;
548:
549: skb = dev_alloc_skb(pkt_len+2);
550: if (skb == NULL) {
551: if (ei_debug > 1)
552: printk("%s: Couldn't allocate a sk_buff of size %d.\n",
553: dev->name, pkt_len);
554: ei_local->stat.rx_dropped++;
555: break;
556: } else {
557: skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
558: skb->dev = dev;
559: skb_put(skb, pkt_len); /* Make room */
560: ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
561: skb->protocol=eth_type_trans(skb,dev);
562: netif_rx(skb);
563: ei_local->stat.rx_packets++;
564: }
565: } else {
566: int errs = rx_frame.status;
567: if (ei_debug)
568: printk("%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
569: dev->name, rx_frame.status, rx_frame.next,
570: rx_frame.count);
571: if (errs & ENRSR_FO)
572: ei_local->stat.rx_fifo_errors++;
573: }
574: next_frame = rx_frame.next;
575:
576: /* This _should_ never happen: it's here for avoiding bad clones. */
577: if (next_frame >= ei_local->stop_page) {
578: printk("%s: next frame inconsistency, %#2x\n", dev->name,
579: next_frame);
580: next_frame = ei_local->rx_start_page;
581: }
582: ei_local->current_page = next_frame;
583: outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
584: }
585:
586: /* We used to also ack ENISR_OVER here, but that would sometimes mask
587: a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
588: outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
589: return;
590: }
591:
592: /*
593: * We have a receiver overrun: we have to kick the 8390 to get it started
594: * again. Problem is that you have to kick it exactly as NS prescribes in
595: * the updated datasheets, or "the NIC may act in an unpredictable manner."
596: * This includes causing "the NIC to defer indefinitely when it is stopped
597: * on a busy network." Ugh.
598: */
599: static void ei_rx_overrun(struct device *dev)
600: {
601: int e8390_base = dev->base_addr;
602: unsigned long wait_start_time;
603: unsigned char was_txing, must_resend = 0;
604: struct ei_device *ei_local = (struct ei_device *) dev->priv;
605:
606: /*
607: * Record whether a Tx was in progress and then issue the
608: * stop command.
609: */
610: was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
611: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
612:
613: if (ei_debug > 1)
614: printk("%s: Receiver overrun.\n", dev->name);
615: ei_local->stat.rx_over_errors++;
616:
617: /*
618: * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
619: * Early datasheets said to poll the reset bit, but now they say that
620: * it "is not a reliable indicator and subsequently should be ignored."
621: * We wait at least 10ms.
622: */
623: wait_start_time = jiffies;
624: while (jiffies - wait_start_time <= 1*HZ/100)
625: barrier();
626:
627: /*
628: * Reset RBCR[01] back to zero as per magic incantation.
629: */
630: outb_p(0x00, e8390_base+EN0_RCNTLO);
631: outb_p(0x00, e8390_base+EN0_RCNTHI);
632:
633: /*
634: * See if any Tx was interrupted or not. According to NS, this
635: * step is vital, and skipping it will cause no end of havoc.
636: */
637: if (was_txing) {
638: unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
639: if (!tx_completed) must_resend = 1;
640: }
641:
642: /*
643: * Have to enter loopback mode and then restart the NIC before
644: * you are allowed to slurp packets up off the ring.
645: */
646: outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
647: outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
648:
649: /*
650: * Clear the Rx ring of all the debris, and ack the interrupt.
651: */
652: ei_receive(dev);
653: outb_p(ENISR_OVER, e8390_base+EN0_ISR);
654:
655: /*
656: * Leave loopback mode, and resend any packet that got stopped.
657: */
658: outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
659: if (must_resend)
660: outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
661:
662: }
663:
664: static struct enet_statistics *get_stats(struct device *dev)
665: {
666: short ioaddr = dev->base_addr;
667: struct ei_device *ei_local = (struct ei_device *) dev->priv;
668:
669: /* If the card is stopped, just return the present stats. */
670: if (dev->start == 0) return &ei_local->stat;
671:
672: /* Read the counter registers, assuming we are in page 0. */
673: ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
674: ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
675: ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
676:
677: return &ei_local->stat;
678: }
679:
680: /*
681: * Set or clear the multicast filter for this adaptor.
682: */
683:
684: static void set_multicast_list(struct device *dev)
685: {
686: short ioaddr = dev->base_addr;
687:
688: if(dev->flags&IFF_PROMISC)
689: {
690: outb_p(E8390_RXCONFIG | 0x18, ioaddr + EN0_RXCR);
691: }
692: else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
693: {
694: /* The multicast-accept list is initialized to accept-all, and we
695: rely on higher-level filtering for now. */
696: outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
697: }
698: else
699: outb_p(E8390_RXCONFIG, ioaddr + EN0_RXCR);
700: }
701:
702: /* Initialize the rest of the 8390 device structure. */
703: int ethdev_init(struct device *dev)
704: {
705: if (ei_debug > 1)
1.1.1.2 ! root 706: printk("%s", version);
1.1 root 707:
708: if (dev->priv == NULL) {
709: dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
710: if (dev->priv == NULL)
711: return -ENOMEM;
712: memset(dev->priv, 0, sizeof(struct ei_device));
713: }
714:
715: dev->hard_start_xmit = &ei_start_xmit;
716: dev->get_stats = get_stats;
717: dev->set_multicast_list = &set_multicast_list;
718:
719: ether_setup(dev);
720:
721: return 0;
722: }
723:
724:
725: /* This page of functions should be 8390 generic */
726: /* Follow National Semi's recommendations for initializing the "NIC". */
727: void NS8390_init(struct device *dev, int startp)
728: {
729: int e8390_base = dev->base_addr;
730: struct ei_device *ei_local = (struct ei_device *) dev->priv;
731: int i;
732: int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
733: unsigned long flags;
734:
735: /* Follow National Semi's recommendations for initing the DP83902. */
736: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base); /* 0x21 */
737: outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
738: /* Clear the remote byte count registers. */
739: outb_p(0x00, e8390_base + EN0_RCNTLO);
740: outb_p(0x00, e8390_base + EN0_RCNTHI);
741: /* Set to monitor and loopback mode -- this is vital!. */
742: outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
743: outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
744: /* Set the transmit page and receive ring. */
745: outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
746: ei_local->tx1 = ei_local->tx2 = 0;
747: outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
748: outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
749: ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
750: outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
751: /* Clear the pending interrupts and mask. */
752: outb_p(0xFF, e8390_base + EN0_ISR);
753: outb_p(0x00, e8390_base + EN0_IMR);
754:
755: /* Copy the station address into the DS8390 registers,
756: and set the multicast hash bitmap to receive all multicasts. */
757: save_flags(flags);
758: cli();
759: outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base); /* 0x61 */
760: for(i = 0; i < 6; i++) {
761: outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
762: }
763: /* Initialize the multicast list to accept-all. If we enable multicast
764: the higher levels can do the filtering. */
765: for(i = 0; i < 8; i++)
766: outb_p(0xff, e8390_base + EN1_MULT + i);
767:
768: outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
769: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
770: restore_flags(flags);
771: dev->tbusy = 0;
772: dev->interrupt = 0;
773: ei_local->tx1 = ei_local->tx2 = 0;
774: ei_local->txing = 0;
775: if (startp) {
776: outb_p(0xff, e8390_base + EN0_ISR);
777: outb_p(ENISR_ALL, e8390_base + EN0_IMR);
778: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base);
779: outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
780: /* 3c503 TechMan says rxconfig only after the NIC is started. */
781: outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
782: dev->set_multicast_list(dev); /* Get the multicast status right if this
783: was a reset. */
784: }
785: return;
786: }
787:
788: /* Trigger a transmit start, assuming the length is valid. */
789: static void NS8390_trigger_send(struct device *dev, unsigned int length,
790: int start_page)
791: {
792: int e8390_base = dev->base_addr;
793:
794: outb_p(E8390_NODMA+E8390_PAGE0, e8390_base);
795:
796: if (inb_p(e8390_base) & E8390_TRANS) {
797: printk("%s: trigger_send() called with the transmitter busy.\n",
798: dev->name);
799: return;
800: }
801: outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
802: outb_p(length >> 8, e8390_base + EN0_TCNTHI);
803: outb_p(start_page, e8390_base + EN0_TPSR);
804: outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base);
805: return;
806: }
807:
808: #ifdef MODULE
809:
810: int init_module(void)
811: {
812: return 0;
813: }
814:
815: void
816: cleanup_module(void)
817: {
818: }
819: #endif /* MODULE */
820:
821: /*
822: * Local variables:
823: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
824: * version-control: t
825: * kept-new-versions: 5
826: * c-indent-level: 4
827: * tab-width: 4
828: * End:
829: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.