![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ns.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|
Return to if_ns.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl |
1.1 root 1: /*
2: * Copyright (c) 1994 Shantanu Goel
3: * All Rights Reserved.
4: *
5: * Permission to use, copy, modify and distribute this software and its
6: * documentation is hereby granted, provided that both the copyright
7: * notice and this permission notice appear in all copies of the
8: * software, derivative works or modified versions, and any portions
9: * thereof, and that both notices appear in supporting documentation.
10: *
11: * THE AUTHOR ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
12: * CONDITION. THE AUTHOR DISCLAIMS ANY LIABILITY OF ANY KIND FOR
13: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
14: */
15:
16: /*
17: * Written 1992,1993 by Donald Becker.
18: *
19: * Copyright 1993 United States Government as represented by the
20: * Director, National Security Agency. This software may be used and
21: * distributed according to the terms of the GNU Public License,
22: * incorporated herein by reference.
23: *
24: * The Author may be reached as [email protected] or
25: * C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
26: */
27:
28: #include <ul.h>
29: #include <wd.h>
30: #include <hpp.h>
31: #if NUL > 0 || NWD > 0 || NHPP > 0
32: /*
33: * Generic NS8390 routines.
34: * Derived from the Linux driver by Donald Becker.
35: *
36: * Shantanu Goel ([email protected])
37: */
38: #include <sys/types.h>
39: #include <device/device_types.h>
40: #include <device/errno.h>
41: #include <device/io_req.h>
42: #include <device/if_hdr.h>
43: #include <device/if_ether.h>
44: #include <device/net_status.h>
45: #include <device/net_io.h>
46: #include <chips/busses.h>
47: #include <i386/machspl.h>
48: #include <i386/pio.h>
49: #include <i386at/gpl/if_nsreg.h>
50:
51: #define IO_DELAY __asm__ __volatile__ ("outb %al,$0x80")
52: #define outb_p(p, v) { outb(p, v); IO_DELAY; }
53: #define inb_p(p) ({ unsigned char _v; _v = inb(p); IO_DELAY; _v; })
54:
55: #define NSDEBUG
56: #ifdef NSDEBUG
57: int nsdebug = 0;
58: #define DEBUGF(stmt) { if (nsdebug) stmt; }
59: #else
60: #define DEBUGF(stmt)
61: #endif
62:
63: void nsxint(struct nssoftc *);
64: void nsrint(struct nssoftc *);
65: void nsxmit(struct nssoftc *, unsigned, int);
66: void nsrxoverrun(struct nssoftc *);
67:
68: /*
69: * Initialize the NIC.
70: * Must be called at splimp().
71: */
72: void
73: nsinit(sc)
74: struct nssoftc *sc;
75: {
76: int port = sc->sc_port, i, rxconfig;
77: int endcfg = sc->sc_word16 ? (0x48 | ENDCFG_WTS) : 0x48;
78: struct ifnet *ifp = &sc->sc_if;
79:
80: /*
81: * Reset the board.
82: */
83: (*sc->sc_reset)(sc);
84:
85: sc->sc_oactive = 0;
86: sc->sc_txing = 0;
87: sc->sc_timer = 0;
88: sc->sc_tx1 = sc->sc_tx2 = 0;
89: sc->sc_curpg = sc->sc_rxstrtpg;
90:
91: /*
92: * Follow National Semiconductor's recommendations for
93: * initializing the DP83902.
94: */
95: outb_p(port, E8390_NODMA+E8390_PAGE0+E8390_STOP); /* 0x21 */
96: outb_p(port + EN0_DCFG, endcfg); /* 0x48 or 0x49 */
97:
98: /*
99: * Clear remote byte count registers.
100: */
101: outb_p(port + EN0_RCNTLO, 0);
102: outb_p(port + EN0_RCNTHI, 0);
103:
104: /*
105: * Set to monitor and loopback mode -- this is vital!
106: */
107: outb_p(port + EN0_RXCR, E8390_RXOFF); /* 0x20 */
108: outb_p(port + EN0_TXCR, E8390_TXOFF); /* 0x02 */
109:
110: /*
111: * Set transmit page and receive ring.
112: */
113: outb_p(port + EN0_TPSR, sc->sc_txstrtpg);
114: outb_p(port + EN0_STARTPG, sc->sc_rxstrtpg);
115: outb_p(port + EN0_BOUNDARY, sc->sc_stoppg - 1);
116: outb_p(port + EN0_STOPPG, sc->sc_stoppg);
117:
118: /*
119: * Clear pending interrupts and mask.
120: */
121: outb_p(port + EN0_ISR, 0xff);
122:
123: /*
124: * Enable the following interrupts: receive/transmit complete,
125: * receive/transmit error, and Receiver OverWrite.
126: *
127: * Counter overflow and Remote DMA complete are *not* enabled.
128: */
129: outb_p(port + EN0_IMR, ENISR_RX | ENISR_TX | ENISR_RX_ERR |
130: ENISR_TX_ERR | ENISR_OVER );
131:
132: /*
133: * Copy station address into 8390 registers.
134: */
135: outb_p(port, E8390_NODMA + E8390_PAGE1 + E8390_STOP); /* 0x61 */
136: for (i = 0; i < ETHER_ADDR_LEN; i++)
137: outb_p(port + EN1_PHYS + i, sc->sc_addr[i]);
138:
139: /*
140: * Set up to accept all multicast packets.
141: */
142: for (i = 0; i < 8; i++)
143: outb_p(port + EN1_MULT + i, 0xff);
144:
145: /*
146: * Initialize CURRent pointer
147: */
148: outb_p(port + EN1_CURPAG, sc->sc_rxstrtpg);
149:
150: /*
151: * Program command register for page 0.
152: */
153: outb_p(port, E8390_NODMA + E8390_PAGE0 + E8390_STOP);
154:
155: #if 0
156: outb_p(port + EN0_ISR, 0xff);
157: outb_p(port + EN0_IMR, ENISR_ALL);
158: #endif
159:
160: outb_p(port + E8390_CMD, E8390_NODMA + E8390_PAGE0 + E8390_START);
161: outb_p(port + EN0_TXCR, E8390_TXCONFIG); /* xmit on */
162:
163: /* 3c503 TechMan says rxconfig only after the NIC is started. */
164: rxconfig = E8390_RXCONFIG;
165: if (ifp->if_flags & IFF_ALLMULTI)
166: rxconfig |= 0x08;
167: if (ifp->if_flags & IFF_PROMISC)
168: rxconfig |= 0x10;
169: outb_p(port + EN0_RXCR, rxconfig); /* rx on */
170:
171: /*
172: * Mark interface as up and start output.
173: */
174: ifp->if_flags |= IFF_RUNNING;
175: nsstart(sc);
176: }
177:
178: /*
179: * Start output on interface.
180: * Must be called at splimp().
181: */
182: void
183: nsstart(sc)
184: struct nssoftc *sc;
185: {
186: io_req_t ior;
187: struct ifnet *ifp = &sc->sc_if;
188:
189: /*
190: * Drop packets if interface is down.
191: */
192: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
193: while (1) {
194: IF_DEQUEUE(&ifp->if_snd, ior);
195: if (ior == 0)
196: return;
197: iodone(ior);
198: }
199: }
200: /*
201: * If transmitter is busy, bail out.
202: */
203: if (sc->sc_oactive)
204: return;
205:
206: /*
207: * Dequeue a packet.
208: */
209: IF_DEQUEUE(&ifp->if_snd, ior);
210: if (ior == 0)
211: return;
212:
213: /* Mask interrupts from the ethercard. */
214: outb( sc->sc_port + EN0_IMR, 0x00);
215:
216: if (sc->sc_pingpong) {
217: int count, output_page;
218:
219: if (sc->sc_tx1 == 0) {
220: output_page = sc->sc_txstrtpg;
221: sc->sc_tx1 = count = (*sc->sc_output)(sc,
222: ior->io_count,
223: ior->io_data,
224: sc->sc_txstrtpg);
225: } else if (sc->sc_tx2 == 0) {
226: output_page = sc->sc_txstrtpg + 6;
227: sc->sc_tx2 = count = (*sc->sc_output)(sc,
228: ior->io_count,
229: ior->io_data,
230: output_page);
231: } else {
232: sc->sc_oactive = 1;
233: IF_PREPEND(&ifp->if_snd, ior);
234: return;
235: }
236:
237: DEBUGF({
238: struct ether_header *eh;
239:
240: eh = (struct ether_header *)ior->io_data;
241: printf("send: %s%d: %x:%x:%x:%x:%x:%x, "
242: "olen %d, len %d\n",
243: sc->sc_name, sc->sc_unit,
244: eh->ether_dhost[0], eh->ether_dhost[1],
245: eh->ether_dhost[2], eh->ether_dhost[3],
246: eh->ether_dhost[4], eh->ether_dhost[5],
247: ior->io_count, count);
248: });
249:
250: if (!sc->sc_txing) {
251: nsxmit(sc, count, output_page);
252: if (output_page == sc->sc_txstrtpg)
253: sc->sc_tx1 = -1, sc->sc_lasttx = -1;
254: else
255: sc->sc_tx2 = -1, sc->sc_lasttx = -2;
256: }
257: sc->sc_oactive = (sc->sc_tx1 && sc->sc_tx2);
258: } else {
259: int count;
260:
261: count = (*sc->sc_output)(sc, ior->io_count,
262: ior->io_data, sc->sc_txstrtpg);
263:
264: DEBUGF({
265: struct ether_header *eh;
266:
267: eh = (struct ether_header *)ior->io_data;
268: printf("send: %s%d: %x:%x:%x:%x:%x:%x, "
269: "olen %d, len %d\n",
270: sc->sc_name, sc->sc_unit,
271: eh->ether_dhost[0], eh->ether_dhost[1],
272: eh->ether_dhost[2], eh->ether_dhost[3],
273: eh->ether_dhost[4], eh->ether_dhost[5],
274: ior->io_count, count);
275: });
276:
277: nsxmit(sc, count, sc->sc_txstrtpg);
278: sc->sc_oactive = 1;
279: }
280:
281: /* reenable 8390 interrupts. */
282: outb_p(sc->sc_port + EN0_IMR, ENISR_ALL);
283:
284: iodone(ior);
285: }
286:
287: /*
288: * Interrupt routine.
289: * Called by board level driver.
290: */
291: void
292: nsintr(sc)
293: struct nssoftc *sc;
294: {
295: int port = sc->sc_port;
296: int interrupts, boguscount = 0;
297: struct ifnet *ifp = &sc->sc_if;
298:
299: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
300: DEBUGF(printf("nsintr: %s%d: interface down\n",
301: sc->sc_name, sc->sc_unit));
302: return;
303: }
304:
305: /*
306: * Change to page 0 and read intr status reg.
307: */
308: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE0);
309:
310: while ((interrupts = inb_p(port + EN0_ISR)) != 0 && ++boguscount < 9) {
311: if (interrupts & ENISR_RDC) {
312: /*
313: * Ack meaningless DMA complete.
314: */
315: outb_p(port + EN0_ISR, ENISR_RDC);
316: }
317:
318: if (interrupts & ENISR_OVER)
319: nsrxoverrun(sc);
320: else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
321: nsrint(sc);
322: }
323:
324: if (interrupts & ENISR_TX) {
325: nsxint(sc);
326: }
327: else if (interrupts & ENISR_COUNTERS) {
328: /*
329: * XXX - We really should be storing statistics
330: * about the interface. For now we just drop them.
331: */
332:
333: /* reading resets the counters! */
334: (void) inb_p(port + EN0_COUNTER0); /* frame */
335: (void) inb_p(port + EN0_COUNTER1); /* crc */
336: (void) inb_p(port + EN0_COUNTER2); /* miss */
337:
338: DEBUGF(printf("%s%d: acked counter interrupt.\n",
339: sc->sc_name, sc->sc_unit));
340:
341: outb_p(port + EN0_ISR, ENISR_COUNTERS); /* ack intr */
342: }
343:
344: if (interrupts & ENISR_TX_ERR) {
345: DEBUGF(printf("acking transmit error\n"));
346: outb_p(port + EN0_ISR, ENISR_TX_ERR); /* ack intr */
347: }
348:
349: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE0+E8390_START);
350: }
351:
352: DEBUGF({
353: if (interrupts) {
354: printf("%s%d: unknown interrupt 0x%x",
355: sc->sc_name, sc->sc_unit, interrupts);
356: outb_p(port + E8390_CMD,
357: E8390_NODMA+E8390_PAGE0+E8390_START);
358: outb_p(port + EN0_ISR, 0xff); /* ack all intrs */
359: }
360: })
361: }
362:
363: /*
364: * Process a transmit interrupt.
365: */
366: void
367: nsxint(sc)
368: struct nssoftc *sc;
369: {
370: int port = sc->sc_port, status;
371: struct ifnet *ifp = &sc->sc_if;
372:
373: status = inb(port + EN0_TSR);
374: outb_p(port + EN0_ISR, ENISR_TX); /* ack intr */
375:
376: sc->sc_txing = 0;
377: sc->sc_timer = 0;
378: sc->sc_oactive = 0;
379:
380: if (sc->sc_pingpong) {
381: if (sc->sc_tx1 < 0) {
382: if (sc->sc_lasttx != 1 && sc->sc_lasttx != -1)
383: printf("%s%d: bogus last_tx_buffer %d,"
384: "tx1 = %d\n",
385: sc->sc_name, sc->sc_unit,
386: sc->sc_lasttx, sc->sc_tx1);
387: sc->sc_tx1 = 0;
388: if (sc->sc_tx2 > 0) {
389: nsxmit(sc, sc->sc_tx2, sc->sc_txstrtpg + 6);
390: sc->sc_tx2 = -1;
391: sc->sc_lasttx = 2;
392: } else
393: sc->sc_lasttx = 20;
394: } else if (sc->sc_tx2 < 0) {
395: if (sc->sc_lasttx != 2 && sc->sc_lasttx != -2)
396: printf("%s%d: bogus last_tx_buffer %d,"
397: "tx2 = %d\n",
398: sc->sc_name, sc->sc_unit,
399: sc->sc_lasttx, sc->sc_tx2);
400: sc->sc_tx2 = 0;
401: if (sc->sc_tx1 > 0) {
402: nsxmit(sc, sc->sc_tx1, sc->sc_txstrtpg);
403: sc->sc_tx1 = -1;
404: sc->sc_lasttx = 1;
405: } else
406: sc->sc_lasttx = 10;
407: } else
408: printf("%s%d: unexpected TX-done interrupt, "
409: "lasttx = %d\n",
410: sc->sc_name, sc->sc_unit, sc->sc_lasttx);
411: }
412: /*
413: * Update stats.
414: */
415: if (status & ENTSR_COL) {
416: if (status & ENTSR_ABT)
417: ifp->if_collisions += 16;
418: else
419: ifp->if_collisions += inb(port + EN0_NCR);
420: }
421: if (status & ENTSR_PTX) {
422: DEBUGF(printf("sent: %s%d\n", sc->sc_name, sc->sc_unit));
423: ifp->if_opackets++;
424: } else
425: ifp->if_oerrors++;
426:
427: /*
428: * Start output on interface.
429: */
430: nsstart(sc);
431: }
432:
433: /*
434: * Process a receive interrupt.
435: */
436: void
437: nsrint(sc)
438: struct nssoftc *sc;
439: {
440: int port = sc->sc_port;
441: int rxing_page, this_frame, next_frame, current_offset;
442: int rx_pkt_count = 0;
443: int num_rx_pages = sc->sc_stoppg - sc->sc_rxstrtpg;
444: struct nspkthdr rx_frame;
445: struct ifnet *ifp = &sc->sc_if;
446:
447: while (++rx_pkt_count < 10) {
448: int pkt_len;
449:
450: /*
451: * Get the rx page (incoming packet pointer).
452: */
453: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE1);
454: rxing_page = inb_p(port + EN1_CURPAG);
455: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE0);
456:
457: /*
458: * Remove one frame from the ring.
459: * Boundary is always a page behind.
460: */
461: this_frame = inb_p(port + EN0_BOUNDARY) + 1;
462: if (this_frame >= sc->sc_stoppg)
463: this_frame = sc->sc_rxstrtpg;
464:
465: DEBUGF({
466: if (this_frame != sc->sc_curpg)
467: printf("%s%d: mismatched read page pointers "
468: "%x vs %x\n",
469: sc->sc_name, sc->sc_unit,
470: this_frame, sc->sc_curpg);
471: });
472:
473: if (this_frame == rxing_page) {
474: DEBUGF(printf("this_frame = rxing_page!\n"));
475: break;
476: }
477:
478: current_offset = this_frame << 8;
479: (*sc->sc_input)(sc, sizeof(rx_frame), (char *)&rx_frame,
480: current_offset);
481:
482: pkt_len = rx_frame.count - sizeof(rx_frame);
483:
484: next_frame = this_frame + 1 + ((pkt_len + 4) >> 8);
485:
486: if (rx_frame.next != next_frame
487: && rx_frame.next != next_frame + 1
488: && rx_frame.next != next_frame - num_rx_pages
489: && rx_frame.next != next_frame + 1 - num_rx_pages) {
490: sc->sc_curpg = rxing_page;
491: outb(port + EN0_BOUNDARY, sc->sc_curpg - 1);
492: ifp->if_ierrors++;
493: DEBUGF(printf("INPUT ERROR?\n"));
494: continue;
495: }
496: if (pkt_len < 60 || pkt_len > 1518) {
497: ifp->if_ierrors++;
498: DEBUGF(printf("%s%d: bad packet length %d\n",
499: sc->sc_name, sc->sc_unit, pkt_len));
500: } else if ((rx_frame.status & 0x0f) == ENRSR_RXOK) {
501: ipc_kmsg_t kmsg;
502:
503: kmsg = net_kmsg_get();
504: if (kmsg == 0) {
505: DEBUGF(printf("%s%d: dropped packet\n",
506: sc->sc_name, sc->sc_unit));
507: ifp->if_rcvdrops++;
508: } else {
509: int len, off;
510: struct ether_header *eh;
511: struct packet_header *pkt;
512:
513: ifp->if_ipackets++;
514: off = current_offset + sizeof(rx_frame);
515: eh = ((struct ether_header *)
516: (&net_kmsg(kmsg)->header[0]));
517: (*sc->sc_input)(sc,
518: sizeof(struct ether_header),
519: (char *)eh, off);
520: off += sizeof(struct ether_header);
521: len = pkt_len - sizeof(struct ether_header);
522:
523: DEBUGF(printf("rcv: %s%d: %x:%x:%x:%x:%x:%x, "
524: "len %d, type 0x%x\n",
525: sc->sc_name, sc->sc_unit,
526: eh->ether_shost[0],
527: eh->ether_shost[1],
528: eh->ether_shost[2],
529: eh->ether_shost[3],
530: eh->ether_shost[4],
531: eh->ether_shost[5],
532: len, eh->ether_type));
533:
534: pkt = ((struct packet_header *)
535: (&net_kmsg(kmsg)->packet[0]));
536: (*sc->sc_input)(sc, len, (char *)(pkt+1), off);
537: pkt->type = eh->ether_type;
538: pkt->length = len+sizeof(struct packet_header);
539: net_packet(ifp, kmsg, pkt->length,
540: ethernet_priority(kmsg));
541: }
542: } else {
543: DEBUGF(printf("%s%d: bogus packet: "
544: "status=0x%x nxpg=0x%x size=%d\n",
545: sc->sc_name, sc->sc_unit,
546: rx_frame.status, rx_frame.next,
547: rx_frame.count));
548: ifp->if_ierrors++;
549: }
550: next_frame = rx_frame.next;
551: if (next_frame >= sc->sc_stoppg) {
552: DEBUGF(printf("%s%d: next frame inconsistency, 0x%x\n",
553: sc->sc_name, sc->sc_unit, next_frame));
554: next_frame = sc->sc_rxstrtpg;
555: }
556: sc->sc_curpg = next_frame;
557: outb(port + EN0_BOUNDARY, next_frame - 1);
558: }
559:
560: /*
561: * Bug alert! Reset ENISR_OVER to avoid spurious overruns!
562: */
563: outb_p(port + EN0_ISR, ENISR_RX+ENISR_RX_ERR+ENISR_OVER);
564: }
565:
566: /*
567: * Handle a receive overrun condition.
568: *
569: * XXX - this needs to be gone over in light of the NS documentation.
570: */
571: void
572: nsrxoverrun(sc)
573: struct nssoftc *sc;
574: {
575: int port = sc->sc_port, i;
576: extern unsigned delaycount;
577:
578: printf("%s%d: receive overrun\n", sc->sc_name, sc->sc_unit);
579:
580: /*
581: * We should already be stopped and in page0, but just to be sure...
582: */
583: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE0+E8390_STOP);
584:
585: /*
586: * Clear remote byte counter registers.
587: */
588: outb_p(port + EN0_RCNTLO, 0);
589: outb_p(port + EN0_RCNTHI, 0);
590:
591: /*
592: * Wait for reset to complete.
593: */
594: for (i = delaycount*2; i && !(inb_p(port+EN0_ISR) & ENISR_RESET); i--)
595: ;
596: if (i == 0) {
597: printf("%s%d: reset did not complete at overrun\n",
598: sc->sc_name, sc->sc_unit);
599: nsinit(sc);
600: return;
601: }
602: /*
603: * Disable transmitter.
604: */
605: outb_p(port + EN0_TXCR, E8390_TXOFF);
606:
607: /*
608: * Remove packets.
609: */
610: nsrint(sc);
611:
612: outb_p(port + EN0_ISR, 0xff);
613: outb_p(port + E8390_CMD, E8390_NODMA+E8390_PAGE0+E8390_START);
614: outb_p(port + EN0_TXCR, E8390_TXCONFIG);
615: }
616:
617: /*
618: * Trigger a transmit start.
619: */
620: void
621: nsxmit(sc, length, start_page)
622: struct nssoftc *sc;
623: unsigned length;
624: int start_page;
625: {
626: int port = sc->sc_port;
627:
628: sc->sc_txing = 1;
629: outb_p(port, E8390_NODMA+E8390_PAGE0);
630: if (inb_p(port) & E8390_TRANS) {
631: printf("%s%d: nsxmit() called with the transmitter busy\n",
632: sc->sc_name, sc->sc_unit);
633: return;
634: }
635: outb_p(port + EN0_TCNTLO, length & 0xff);
636: outb_p(port + EN0_TCNTHI, (length >> 8) & 0xff);
637: outb_p(port + EN0_TPSR, start_page);
638: outb_p(port, E8390_NODMA+E8390_TRANS+E8390_START);
639: sc->sc_timer = 4;
640: }
641:
642: #endif /* NUL > 0 || NWD > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.