![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to le.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to le.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 root 1: /*
2: * Copyright (c) 1985 by Sun Microsystems, Inc.
3: */
4: #include "le.h"
5:
6: /*
7: * AMD Am7990 LANCE Ethernet Controller driver
8: */
9: #include "../h/param.h"
10: #include "../h/systm.h"
11: #include "../machine/pte.h"
12: #include "../h/map.h"
13: #include "../h/buf.h"
14: #include "../h/vmmac.h"
15: #include "../h/conf.h"
16: #include "../h/ttyio.h"
17: #include "../h/enio.h"
18: #include "../h/ttyld.h"
19: #include "../h/stream.h"
20: #include "../h/ethernet.h"
21:
22: #include "../sundev/mbvar.h"
23: #include "../sundev/lereg.h"
24:
25: #define ETHERMAXP (1500 + sizeof(struct etherpup))
26:
27: /* corresponds to minor device numbers (# of servers) */
28: #define CHANS_PER_UNIT 8
29:
30: int leprobe(), leattach(), leintr();
31: struct mb_device *leinfo[NLE];
32: struct mb_driver ledriver = {
33: leprobe, 0, leattach, 0, 0, leintr,
34: sizeof (struct le_device), "le", leinfo, 0, 0, 0,
35: };
36:
37: /*
38: * Transmit and receive buffer layout.
39: * The buffer size is chosen to give room for the maximum ether
40: * transmission unit, an overrun consisting of the entire fifo
41: * contents, and slop that experience indicates is necessary.
42: * (The exact amount of slop required is still unknown.)
43: */
44: struct lebuf {
45: char buffer[MAXBUF]; /* Packet's data */
46: };
47:
48: struct leu {
49: struct le_device *dev; /* hardware pointer */
50: struct le_init_block *ib; /* Initialization block */
51: struct le_md *rdrp; /* Receive Descriptor Ring Ptr */
52: struct le_md *tdrp; /* Transmit Descriptor Ring Ptr */
53: struct le_md *rdrend; /* Receive Descriptor Ring End */
54: struct le_md *his_rmd; /* Next descriptor in ring */
55: int nrmdp2; /* log(2) Num. Rcv. Msg. Descs. */
56: int ntmdp2; /* log(2) Num. Tran. Msg. Descs. */
57: int nrmds; /* Num. Rcv. Msg. Descs. */
58: int ntmds; /* Num. Xmit. Msg. Descs. */
59: struct lebuf *rbufs; /* Receive Buffers */
60: struct lebuf *tbufs; /* Transmit Buffers */
61: /* Error counters */
62: int frame; /* Receive Framing Errors (dribble) */
63: int crc; /* Receive CRC Errors */
64: int oflo; /* Receive overruns */
65: int uflo; /* Transmit underruns */
66: int retries; /* Transmit retries */
67: int missed; /* Number of missed packets */
68: int noheartbeat; /* Number of nonexistent heartbeats */
69: int ierrors, oerrors;
70: int ipackets, opackets;
71: char myetheradr[6];
72: char attached;
73: char active;
74: } leu[NLE];
75:
76: #define NLECHAN (CHANS_PER_UNIT * NLE)
77: struct lechan {
78: struct leu *leu;
79: int packets;
80: struct queue *q;
81: int type;
82: } lechan[NLECHAN];
83:
84: int nodev(), leopen(), leclose(), leput();
85: static struct qinit lerinit = { nodev, NULL, leopen, leclose, 0, 0 };
86: static struct qinit lewinit = { leput, NULL, leopen, leclose, 1514, 0 };
87: /* 1514 bytes is minimum highwater mark to send 1514 byte packets */
88: struct streamtab lesinfo = { &lerinit, &lewinit };
89:
90: /*
91: * Resource amounts.
92: */
93: /* Numbers of ring descriptors */
94: int le_ntmdp2 = 0; /* 2 ^ 0 = 1 */
95: int le_nrmdp2 = 4; /* 2 ^ 4 = 16 */
96:
97: /*
98: * Return the address of an adjacent descriptor in the given ring.
99: */
100: #define next_rmd(lu,rmdp) ((rmdp) == (lu)->rdrend \
101: ? (lu)->rdrp : ((rmdp) + 1))
102:
103: /*
104: * Probe for device.
105: */
106: leprobe(reg)
107: caddr_t reg;
108: {
109: register struct le_device *le = (struct le_device *)reg;
110:
111: if (pokec((char *)&le->le_rdp, 0))
112: return (0);
113: return (sizeof (struct le_device));
114: }
115:
116: /*
117: * Interface exists: make available by filling in network interface
118: * record. System will initialize the interface when it is ready
119: * to accept packets.
120: */
121: leattach(md)
122: struct mb_device *md;
123: {
124: struct leu *lu = &leu[md->md_unit];
125:
126: /* Reset the chip. */
127: lu->dev = (struct le_device *)md->md_addr;
128: lu->dev->le_rap = LE_CSR0;
129: lu->dev->le_csr = LE_STOP;
130: localetheraddr(NULL, lu->myetheradr);
131: le_alloc_buffers(lu);
132: lu->attached = 1;
133: }
134:
135: /* ARGSUSED */
136: leopen(q, dev)
137: register struct queue *q;
138: register dev_t dev;
139: {
140: register struct lechan *led;
141: register struct leu *lu;
142: register unit;
143:
144: dev = minor(dev);
145: unit = dev / CHANS_PER_UNIT;
146:
147: if (dev >= NLECHAN)
148: return(0);
149: if (unit >= NLE)
150: return(0);
151:
152: lu = &leu[unit];
153: if(!lu->attached)
154: return(0);
155: led = &lechan[dev];
156: if (led->q)
157: return(0);
158: led->leu = lu;
159: led->q = q;
160: q->ptr = (caddr_t)led;
161: q->flag |= QBIGB | QDELIM;
162: WR(q)->ptr = (caddr_t)led;
163: WR(q)->flag |= QBIGB|QDELIM;
164: return(1);
165: }
166:
167: leclose(q)
168: register struct queue *q;
169: {
170: register struct lechan *led;
171:
172: led = (struct lechan *)q->ptr;
173: flushq(WR(q), 1);
174: lechan->q = NULL;
175: }
176:
177: leput(q, bp)
178: register struct queue *q;
179: register struct block *bp;
180: {
181: register struct lechan *led;
182: register struct leu *lu;
183: register s;
184:
185: led = (struct lechan *)q->ptr;
186: lu = led->leu;
187:
188: switch(bp->type) {
189:
190: case M_IOCTL:
191: leioctl(q, bp);
192: return;
193:
194: case M_DATA:
195: putq(q, bp);
196: return;
197:
198: case M_DELIM:
199: break;
200:
201: default:
202: freeb(bp);
203: return;
204: }
205:
206: putq(q, bp);
207: s = splimp();
208: led->packets++;
209: if (lu->active == 0)
210: lestart(lu);
211: splx(s);
212: }
213:
214: /*
215: * Grab memory for message descriptors and buffers and set fields
216: * in the interfaces's software status structure accordingly.
217: */
218: le_alloc_buffers(lu)
219: register struct leu *lu;
220: {
221: int size;
222: int memall();
223: caddr_t wmemall(), v;
224:
225: /* Set numbers of message descriptors. */
226: lu->nrmdp2 = le_nrmdp2;
227: lu->ntmdp2 = le_ntmdp2;
228: lu->nrmds = 1 << lu->nrmdp2;
229: lu->ntmds = 1 << lu->ntmdp2;
230:
231: size = sizeof(struct le_md) * (lu->nrmds + lu->ntmds) +
232: sizeof(struct lebuf) * (lu->nrmds + lu->ntmds) +
233: sizeof(struct le_init_block);
234: v = wmemall(memall, size);
235:
236: #define valloc(name, type, num) \
237: (name) = (type *)(v); (v) = (caddr_t)((name)+(num))
238:
239: valloc(lu->rdrp, struct le_md , lu->nrmds);
240: valloc(lu->tdrp, struct le_md , lu->ntmds);
241: valloc(lu->ib, struct le_init_block , 1);
242: valloc(lu->rbufs, struct lebuf , lu->nrmds);
243: valloc(lu->tbufs, struct lebuf , lu->ntmds);
244:
245: /*
246: * Remember address of last descriptor in the ring for
247: * ease of bumping pointers around the ring.
248: */
249: lu->rdrend = &((lu->rdrp)[lu->nrmds-1]);
250: leinit(lu);
251: }
252:
253: /*
254: * Initialization of interface; clear recorded pending
255: * operations.
256: */
257: leinit(lu)
258: register struct leu *lu;
259: {
260: register struct le_device *le;
261: register struct le_init_block *ib;
262: register int s;
263: register struct lebuf *bp;
264: register struct le_md *md;
265: int i;
266:
267: s = splimp();
268:
269: le = lu->dev;
270: le->le_csr = LE_STOP; /* reset the chip */
271:
272: /*
273: * Reset message descriptors.
274: */
275: lu->his_rmd = lu->rdrp;
276:
277: /* Construct the initialization block */
278: ib = lu->ib;
279: bzero((caddr_t)ib, sizeof (struct le_init_block));
280:
281: ib->ib_padr[0] = lu->myetheradr[1];
282: ib->ib_padr[1] = lu->myetheradr[0];
283: ib->ib_padr[2] = lu->myetheradr[3];
284: ib->ib_padr[3] = lu->myetheradr[2];
285: ib->ib_padr[4] = lu->myetheradr[5];
286: ib->ib_padr[5] = lu->myetheradr[4];
287:
288: /* No multicast filter yet, FIXME MULTICAST, leave zeros. */
289:
290: ib->ib_rdrp.drp_laddr = (long)lu->rdrp;
291: ib->ib_rdrp.drp_haddr = (long)lu->rdrp >> 16;
292: ib->ib_rdrp.drp_len = (long)lu->nrmdp2;
293: ib->ib_tdrp.drp_laddr = (long)lu->tdrp;
294: ib->ib_tdrp.drp_haddr = (long)lu->tdrp >> 16;
295: ib->ib_tdrp.drp_len = (long)lu->ntmdp2;
296:
297: /* Clear all the descriptors */
298: bzero((caddr_t)lu->rdrp, lu->nrmds * sizeof (struct le_md));
299: bzero((caddr_t)lu->tdrp, lu->ntmds * sizeof (struct le_md));
300:
301: /* Hang out the receive buffers. */
302: for(i = 0; i < lu->nrmds; i++) {
303: bp = &lu->rbufs[i];
304: md = &lu->rdrp[i];
305: md->lmd_ladr = (u_short) bp;
306: md->lmd_hadr = (long)bp >> 16;
307: md->lmd_bcnt = -MAXBUF;
308: md->lmd_mcnt = 0;
309: md->lmd_flags = LMD_OWN;
310: }
311: lu->his_rmd == lu->rdrp;
312:
313: /* Transmit md intialization */
314: for(i = 0; i < lu->ntmds; i++) {
315: bp = &lu->tbufs[i];
316: md = &lu->tdrp[i];
317: md->lmd_ladr = (u_short) bp;
318: md->lmd_hadr = (long)bp >> 16;
319: }
320:
321: /* Give the init block to the chip */
322: le->le_rap = LE_CSR1; /* select the low address register */
323: le->le_rdp = (long)ib & 0xffff;
324:
325: le->le_rap = LE_CSR2; /* select the high address register */
326: le->le_rdp = ((long)ib >> 16) & 0xff;
327:
328: le->le_rap = LE_CSR3; /* Bus Master control register */
329: le->le_rdp = LE_BSWP;
330:
331: le->le_rap = LE_CSR0; /* main control/status register */
332: le->le_csr = LE_INIT;
333:
334: for (i = 10000; ! (le->le_csr & LE_IDON); i-- )
335: if (i <= 0)
336: panic("le: chip didn't initialize");
337: le->le_csr = LE_IDON; /* Now reset the interrupt */
338: lu->active = 0;
339: /* (Re)start the chip. */
340: le->le_csr = LE_STRT | LE_INEA;
341: (void) splx(s);
342: }
343:
344: /*
345: * Start or restart output on interface.
346: * If interface is already active, then this is a nop.
347: * If interface is not already active, get another packet
348: * to send from the interface queue, and map it to the
349: * interface before starting the output.
350: */
351: lestart(lu)
352: register struct leu *lu;
353: {
354: register char *to;
355: register struct lechan *led;
356: register struct queue *q;
357: register struct block *bp;
358: register count, i;
359: struct le_device *le;
360: register struct le_md *t;
361:
362: led = &lechan[(lu - leu) * CHANS_PER_UNIT];
363: for(i = 0; i < CHANS_PER_UNIT; i++, led++)
364: if (led->q && led->packets > 0)
365: break;
366: if (i >= CHANS_PER_UNIT)
367: return;
368:
369: led->packets--;
370: q = WR(led->q);
371:
372: le = (struct le_device *)lu->dev;
373: to = lu->tbufs->buffer;
374: count = 0;
375: while (bp = getq(q)) {
376: if (bp->type == M_DELIM) {
377: freeb(bp);
378: break;
379: }
380: i = bp->wptr - bp->rptr;
381: /*
382: * If larger than maximum packet, throw out extra
383: */
384: if (count + i > ETHERMAXP) {
385: i = ETHERMAXP - count;
386: bcopy(bp->rptr, to, i);
387: count += i;
388: freeb(bp);
389: while (bp = getq(q)) {
390: if (bp->type == M_DELIM) {
391: freeb(bp);
392: break;
393: }
394: freeb(bp);
395: }
396: break;
397: }
398: bcopy(bp->rptr, to, i);
399: to += i;
400: count += i;
401: freeb(bp);
402: }
403:
404: /* if there is no ethernet header in packet, throw it out */
405: if (count < sizeof(struct etherpup))
406: return;
407: if (count < 60)
408: count = 60;
409:
410: to = lu->tbufs->buffer + 6;
411: bcopy(lu->myetheradr, to, 6);
412: t = lu->tdrp;
413: if (t->lmd_flags & LMD_OWN)
414: panic("lestart: tmd ownership conflict");
415: t->lmd_bcnt = -count;
416: t->lmd_flags3 = 0;
417: t->lmd_flags = 0;
418: t->lmd_flags = LMD_STP|LMD_ENP;
419: t->lmd_flags |= LMD_OWN;
420: lu->active = 1;
421: le->le_csr = LE_TDMD | LE_INEA;
422:
423: }
424:
425: /*
426: * interrupt routine
427: */
428: leintr()
429: {
430: register struct leu *lu;
431: register struct le_device *le;
432: register struct le_md *lmd;
433: register struct mb_device *md;
434: int serviced = 0;
435:
436: lu = leu;
437: for (lu = leu; lu < &leu[NLE]; lu++) {
438: if (!lu->attached)
439: continue;
440: le = lu->dev;
441: if (!(le->le_csr & LE_INTR))
442: continue;
443:
444: /* Keep statistics for lack of heartbeat */
445: if (le->le_csr & LE_CERR) {
446: le->le_csr = LE_CERR | LE_INEA;
447: lu->noheartbeat++;
448: }
449:
450: /* Check for receive activity */
451: if ( (le->le_csr & LE_RINT) && (le->le_csr & LE_RXON) ) {
452: /* Pull packets off interface */
453: for (lmd = lu->his_rmd;
454: !(lmd->lmd_flags & LMD_OWN);
455: lu->his_rmd = lmd = next_rmd(lu, lmd)) {
456: serviced = 1;
457: le->le_csr = LE_RINT | LE_INEA;
458: leread(lu, lmd);
459: lmd->lmd_mcnt = 0;
460: lmd->lmd_flags = LMD_OWN;
461: }
462: if (!serviced)
463: panic("RINT with buffer owned by chip");
464: }
465:
466: /* Check for transmit activity */
467: if ((le->le_csr & LE_TINT) && (le->le_csr & LE_TXON)) {
468: lmd = lu->tdrp;
469: if (lmd->lmd_flags & (TMD_MORE | TMD_ONE))
470: lu->retries++;
471: if (lmd->lmd_flags3 &
472: (TMD_BUFF|TMD_UFLO|TMD_LCOL|TMD_LCAR|TMD_RTRY))
473: le_xmit_error(lu, lmd->lmd_flags3, le);
474: le->le_csr = LE_TINT | LE_INEA;
475: lu->active = 0;
476: lu->opackets++;
477: lestart(lu);
478: serviced = 1;
479: }
480:
481: /*
482: * Check for errors not specifically related
483: * to transmission or reception.
484: */
485: if ( (le->le_csr & (LE_BABL|LE_MERR|LE_MISS|LE_TXON|LE_RXON))
486: != (LE_RXON|LE_TXON) ) {
487: serviced = 1;
488: le_chip_error(lu, le);
489: }
490: }
491: return (serviced);
492: }
493:
494: /*
495: * Move info from driver toward protocol interface
496: */
497: leread(lu, rmd)
498: register struct leu *lu;
499: register struct le_md *rmd;
500: {
501: register struct lechan *led;
502: register struct queue *q;
503: register struct block *bp;
504: register short type;
505: register caddr_t from;
506: register len, i;
507:
508: /* Check for packet errors. */
509: if ((rmd->lmd_flags & ~RMD_OFLO) != (LMD_STP|LMD_ENP)) {
510: le_rcv_error(lu, rmd->lmd_flags);
511: lu->ierrors++;
512: return;
513: }
514:
515: /*
516: * Get input data length (minus crc)
517: */
518: len = rmd->lmd_mcnt - 4; /* subtract off trailing crc */
519: if (len == 0) {
520: printf("runt packet\n");
521: lu->ierrors++;
522: return;
523: }
524:
525: from = (caddr_t)lu->rbufs[rmd - lu->rdrp].buffer;
526: type = ((struct etherpup *)from)->type;
527: led = &lechan[(lu - leu) * CHANS_PER_UNIT];
528: for (i = 0; i < CHANS_PER_UNIT; i++, led++)
529: if (led->q && led->type == type)
530: break;
531: if (i >= CHANS_PER_UNIT)
532: return;
533: q = led->q;
534: if (q->next->flag & QFULL) {
535: lu->ierrors++;
536: return;
537: }
538: while (len > 0) {
539: bp = allocb(len);
540: i = MIN((bp->lim - bp->base), len);
541: len -= i;
542: bcopy(from, bp->wptr, i);
543: bp->wptr += i;
544: from += i;
545: (*q->next->qinfo->putp)(q->next, bp);
546: }
547: if (putctl(q->next, M_DELIM))
548: lu->ipackets++;
549: else
550: printf("leread no DELIM bp\n");
551: }
552:
553: /*
554: * Process an ioctl request.
555: */
556: leioctl(q, bp)
557: register struct queue *q;
558: register struct block *bp;
559: {
560: register struct lechan *led;
561: register struct leu *lu;
562: register u_char *msg;
563: int cmd;
564:
565: led = (struct lechan *)q->ptr;
566: lu = led->leu;
567: cmd = ((union stmsg *)(bp->rptr))->ioc1.com;
568: msg = (u_char *)&((union stmsg *)(bp->rptr))->ioc1.sb;
569:
570: bp->type = M_IOCACK;
571: switch (cmd) {
572: case ENIOADDR: /* get my Ethernet address */
573: bcopy(lu->myetheradr, (int *)msg, 6);
574: break;
575:
576: case ENIOTYPE:
577: led->type = *(int *)msg;
578: break;
579:
580: default:
581: bp->type = M_IOCNAK;
582: break;
583: }
584: qreply(q, bp);
585: }
586:
587: le_rcv_error(lu, flags)
588: struct leu *lu;
589: u_char flags;
590: {
591: if (flags & RMD_FRAM)
592: lu->frame++;
593: if (flags & RMD_CRC )
594: lu->crc++;
595: if (flags & RMD_OFLO)
596: lu->oflo++;
597: if (flags & RMD_BUFF)
598: printf("Receive buffer error - BUFF bit set in rmd\n");
599: if (!(flags & LMD_STP))
600: printf("Received packet with STP bit in rmd cleared\n");
601: if (!(flags & LMD_ENP))
602: printf("Received packet with ENP bit in rmd cleared\n");
603: }
604:
605: le_xmit_error(lu, flags, le)
606: struct leu *lu;
607: u_short flags;
608: struct le_device *le;
609: {
610: /*
611: * The BUFF bit isn't valid if the RTRY bit is set.
612: */
613: if ((flags & (TMD_BUFF | TMD_RTRY)) == TMD_BUFF)
614: printf("Transmit buffer error - BUFF bit set in tmd\n");
615: if (flags & TMD_UFLO) {
616: printf("Transmit underflow error\n");
617: lu->uflo++;
618: }
619: if (flags & TMD_LCOL)
620: printf("Transmit late collision - net problem?\n");
621: if (flags & TMD_LCAR)
622: printf("No carrier - transceiver cable problem?\n");
623: if (flags & TMD_RTRY)
624: printf("Transmit retried more than 16 times - net jammed\n");
625: }
626:
627: /* Handles errors that are reported in the chip's status register */
628: /* ARGSUSED */
629: le_chip_error(lu, le)
630: struct leu *lu;
631: struct le_device *le;
632: {
633: register u_short csr = le->le_csr;
634: int restart = 0;
635:
636: if (csr & LE_MISS) {
637: lu->missed++;
638: le->le_csr = LE_MISS | LE_INEA;
639: }
640:
641: if (csr & LE_BABL) {
642: printf("Babble error - sent a packet longer than the maximum length\n");
643: le->le_csr = LE_BABL | LE_INEA;
644: }
645: /*
646: * If a memory error has occurred, both the transmitter
647: * and the receiver will have shut down.
648: */
649: if (csr & LE_MERR) {
650: printf("Memory Error! Ethernet chip memory access timed out\n");
651: le->le_csr = LE_MERR | LE_INEA;
652: }
653: if ( !(csr & LE_RXON) ) {
654: printf("Reception stopped\n");
655: restart++;
656: }
657: if ( !(csr & LE_TXON) ) {
658: printf("Transmission stopped\n");
659: restart++;
660: }
661: if (restart) {
662: le_print_csr(csr);
663: leinit(lu);
664: }
665: }
666:
667: /*
668: * Print out a csr value in a nicely formatted way.
669: */
670: le_print_csr (csr)
671: register u_short csr;
672: {
673: printf("csr: %b\n", csr,
674: "\20\20ERR\17BABL\16CERR\15MISS\14MERR\13RINT\12TINT\11IDON\10INTR\7INEA\6RXON\5TXON\4TDMD\3STOP\2STRT\1INIT\n");
675: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.