![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to ec.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: #include "ec.h"
2: #if NEC > 0
3:
4:
5: #include "../h/param.h"
6: #include "../h/systm.h"
7: #include "../h/pte.h"
8: #include "../h/map.h"
9: #include "../h/buf.h"
10: #include "../h/ubareg.h"
11: #include "../h/ubavar.h"
12: #include "../h/conf.h"
13: #include "../h/ioctl.h"
14: #include "../h/ttyld.h"
15: #include "../h/stream.h"
16: #include "../h/ethernet.h"
17: #include "sparam.h"
18:
19: extern char ECmem[]; /* .set in locore.s */
20: #define ECADDR ((caddr_t)(ECmem)) /* Virt addr of EC buffer mem */
21:
22: /* NOTE: The ECRHBF/ECRLBF/ECTBF definitions must match the address
23: and size of EC memory as defined in locore.s in the kernel.
24: If locore maps in full 32K, then use all buffers, otherwise,
25: change accordingly.
26: */
27:
28: #define ENETDOWN ENODEV
29: #define ECRHBF 11
30: #define ECRLBF 1
31: #define ECTBF 0
32:
33: /* Following ethernet address only has meaning if UE prom is missing */
34:
35: #define ECPRI (PZERO+8)
36: #define ECBFSZ 2048 /* Size of each EC buffer */
37:
38: struct ecdevice {
39: short ecrcr; /* Transmit Control Register */
40: short ecxcr; /* Receive Control Register */
41: };
42:
43: /* Bits in ecxcr: */
44: #define EC_WBN 0x0010 /* Write Buffer Number */
45: #define EC_CLRDN 0x0020 /* Clear Done */
46: #define EC_IE 0x0040 /* Interrupt Enable */
47: #define EC_DONE 0x0080 /* Xmt/Rcv complete */
48: #define EC_CLR 0x0100 /* Clear EC */
49: #define EC_CLRJAM 0x2000 /* Clear Jam */
50: #define EC_JIE 0x4000 /* Jam Interrupt Enable */
51: #define EC_JAM 0x8000 /* Jam */
52:
53: /* Bits WBN, CLRDN, IE, and DONE are also used for ecrcr */
54: #define EC_BITS "\20\20JAM\17JIE\16CLRJAM\11CLR\10DONE\7IE\6CLRDN\5WBN"
55:
56: /* Bits in ecrcr: */
57: #define EC_RANDATA 0xA00 /* Alternating 1/0 in 4 data bits */
58: #define EC_ADATAMSK 0xF00 /* Mask for 4 data bits */
59: #define EC_OWN_BDCST 0x600 /* Recog addrs for me + broadcast*/
60: #define EC_ARALL 0 /* Pass all addresses */
61: #define EC_AWCLK 0x1000 /* Clock data into address recog ram */
62: #define EC_AROM 0x2000 /* Select rom vs default ram */
63: #define EC_ASTEP 0x4000 /* Step rom/ram address one bit */
64:
65:
66: /*
67: * Useful combinations
68: */
69: #define EC_READ (EC_OWN_BDCST|EC_IE|EC_WBN)
70: #define EC_WRITE (EC_JIE|EC_IE|EC_WBN)
71: #define EC_CLEAR (EC_JIE|EC_IE|EC_CLRJAM)
72:
73: #define ECXBUSY 010
74: #define ECDEBUG 0200
75:
76: /* corresponds to minor device numbers (# of servers) */
77: #define CHANS_PER_UNIT 8
78:
79: struct ec { /* per controller */
80: char myethadr[6]; /* My Ethernet address */
81: char attached; /* Non zero when ec has been attached */
82: char active;
83: short collisions; /* Jam counter */
84: int state; /* Device state */
85: int bits;
86: int ierrors, oerrors;
87: int ipackets, opackets;
88: } ec[NEC] = { {0x02, 0x60, 0x8c, 0x00, 0x4, 0x62}, };
89:
90: #define NECCHAN (CHANS_PER_UNIT * NEC)
91: struct ecchan {
92: int unit;
93: int packets;
94: struct queue *ecq;
95: int type;
96: } ecchan[NECCHAN];
97:
98: int nodev(), ecopen(), ecclose(), ecput(), ecsrv();
99: static struct qinit ecrinit = { nodev, NULL, ecopen, ecclose, 0, 0 };
100: static struct qinit ecwinit = { ecput, NULL, ecopen, ecclose, 1514, 0 };
101: /* 1514 bytes is minimum highwater mark to send 1514 byte packets */
102: struct streamtab ecsinfo = { &ecrinit, &ecwinit };
103:
104: /* JUNK FOR AUTOCONFIGURE */
105: struct uba_device *ecinfo[1];
106: int ecprobe(), ecattach();
107: u_short ecstd[] = { 0 };
108: struct uba_driver ecdriver =
109: { ecprobe, 0, ecattach, 0, ecstd, "ec", ecinfo };
110: extern bsize[];
111:
112: ecprobe(reg)
113: caddr_t reg;
114: {
115: register int br, cvec; /* value-result */
116: br = 0x16; /* BR Level 16 = UNIBUS 6 */
117: cvec = 0440; /* Int vector */
118: return 1;
119: }
120:
121: /* ARGSUSED */
122: ecattach(ui)
123: struct uba_device *ui;
124: {
125: register struct ecdevice *ecaddr = (struct ecdevice *)ui->ui_addr;
126: register struct ec *ecu = &ec[ui->ui_unit];
127: unsigned short s0, s1;
128: register i, j;
129: register char *cp;
130: char bdethadr[6]; /* copy of bd rom; -1=>chip missing */
131:
132:
133: if(ecu->attached) /* Do this only once */
134: return;
135: ecaddr->ecxcr = EC_CLR; /* Reset the EC */
136:
137: /* Fetch out the ROM ethernet address into tmp ethadr */
138:
139: ecaddr->ecrcr = EC_AROM; /* Select the ROM */
140: cp = bdethadr;
141: for(i = 0; i < 6; i++) {
142: *cp = 0;
143: for(j = 0; j <= 4; j += 4) {
144: s1 = ecaddr->ecrcr;
145: *cp |= ((s1 >> 8) & 017) << j;
146: for(s1 = 0; s1 < 4; s1++) {
147: ecaddr->ecrcr = EC_ASTEP+EC_AROM;
148: ecaddr->ecrcr = EC_AROM;
149: }
150: }
151: cp++;
152: }
153: for(i = 0, cp = bdethadr; i < 6; i++)
154: if(*cp++ != -1) { /* Rom is good if not -1 */
155: for(i = 0; i < 6; i++)
156: ecu->myethadr[i] = bdethadr[i];
157: }
158: /* use the RAM for addr recog */
159: laddrec(ui);
160:
161: for(i = ECRHBF; i >= ECRLBF; i--)
162: ecaddr->ecrcr = EC_READ + i;
163: ecsrand((long)ecu->myethadr[5]);
164: ecu->attached = 1;
165: ecu->bits = EC_READ;
166: }
167:
168: laddrec(ui)
169: struct uba_device *ui;
170: {
171: register struct ecdevice *ecaddr = (struct ecdevice *)ui->ui_addr;
172: register struct ec *ecu = &ec[ui->ui_unit];
173: register i, j, s0, s1;
174: register char *cp;
175:
176: /* Have to load myethadr into hardware ram! */
177: ecaddr->ecxcr = EC_CLR; /* Reset bit ptr */
178: for(i = 0, cp = ecu->myethadr; i < 6; i++, cp++)
179: for(j = 0; j <= 4; j += 4) {
180: s1 = ((*cp >> j) & 017) << 8;
181: ecaddr->ecrcr = s1;
182: ecaddr->ecrcr = s1 | EC_AWCLK;
183: ecaddr->ecrcr = s1;
184: for(s0 = 0; s0 < 4; s0++) {
185: ecaddr->ecrcr = EC_ASTEP;
186: ecaddr->ecrcr = 0;
187: }
188: }
189: }
190:
191:
192: /* ARGSUSED */
193: ecopen(q, dev)
194: register struct queue *q;
195: register dev_t dev;
196: {
197: register struct ecchan *ecd;
198: register struct ec *ecu;
199: register unit;
200:
201: dev = minor(dev);
202: unit = dev / CHANS_PER_UNIT;
203:
204: if (dev >= NECCHAN)
205: return(0);
206: if (unit >= NEC)
207: return(0);
208:
209: ecu = &ec[unit];
210: if(!ecu->attached)
211: return(0);
212: ecd = &ecchan[dev];
213: if (ecd->ecq)
214: return(0);
215:
216: ecd->unit = unit;
217: ecd->ecq = q;
218: q->ptr = (caddr_t)ecd;
219: q->flag |= QBIGB | QDELIM;
220: WR(q)->ptr = (caddr_t)ecd;
221: WR(q)->flag |= QBIGB|QDELIM;
222:
223: if (ecu->state & ECDEBUG)
224: printf("ECo%d, ", minor(dev));
225: return(1);
226: }
227: ecclose(q)
228: register struct queue *q;
229: {
230: register struct ecchan *ecd;
231: register struct ec *ecu;
232: register unit;
233:
234: ecd = (struct ecchan *)q->ptr;
235: ecu = &ec[ecd->unit];
236: if (ecu->state & ECDEBUG)
237: printf("ECc\n");
238: flushq(WR(q), 1);
239: ecd->ecq = NULL;
240: }
241:
242: ecput(q, bp)
243: register struct queue *q;
244: register struct block *bp;
245: {
246: register struct ecchan *ecd;
247: register struct ec *ecu;
248: register unit, type, count, ps;
249:
250: ecd = (struct ecchan *)q->ptr;
251: unit = ecd->unit;
252: ecu = &ec[unit];
253:
254: switch(bp->type) {
255:
256: case M_IOCTL:
257: ecioctl(q, bp);
258: return;
259:
260: case M_DATA:
261: putq(q, bp);
262: return;
263:
264: case M_DELIM:
265: break;
266:
267: default:
268: freeb(bp);
269: return;
270: }
271:
272: putq(q, bp);
273: ps = spl6();
274: ecd->packets++;
275: if (ecu->active == 0)
276: ecstart(unit);
277: splx(ps);
278: }
279: ecstart(unit)
280: {
281: register u_char *tsp, *fsp;
282: register struct ec *ecu;
283: register struct ecchan *ecd;
284: register struct ecdevice *ecaddr = (struct ecdevice *)ecinfo[unit]->ui_addr;
285: register struct queue *q, *bq;
286: register struct block *bp, *head, *nbp, **bnext;
287: register len, count = 0, i;
288:
289: ecu = &ec[unit];
290: if (ecu->active) {
291: printf(" start but active %d\n", unit);
292: ecu->active = 0;
293: }
294: ecd = &ecchan[unit * CHANS_PER_UNIT];
295: for(i = 0; i < CHANS_PER_UNIT; i++, ecd++)
296: if (ecd->ecq && ecd->packets > 0)
297: break;
298: if (i >= CHANS_PER_UNIT)
299: return;
300:
301: ecd->packets--;
302: q = WR(ecd->ecq);
303:
304: /* The packet must be justified to the end of the buffer.
305: * Therefore, we have to count the bytes before copying.
306: */
307: bnext = &head;
308: while (*bnext = bp = getq(q)) {
309: if (bp->type == M_DELIM) {
310: bp->next = 0;
311: break;
312: }
313: count += bp->wptr - bp->rptr;
314: bnext = &bp->next;
315: }
316: bp = head;
317:
318: /* if there is no ethernet header in packet, throw it out */
319: if (count < sizeof(struct ether_out)) {
320: while(bp) {
321: nbp = bp->next;
322: freeb(bp);
323: bp = nbp;
324: }
325: return;
326: }
327: ecu->active = 1;
328:
329: /* test for small packets */
330: if (count < 46 + sizeof(struct ether_out))
331: count = 46 + sizeof(struct ether_out);
332:
333: /* test for too large packets */
334: else if (count > 1500 + sizeof(struct ether_out))
335: count = 1500 + sizeof(struct ether_out);
336:
337: /* Fill buffer - packet is justified to end of buffer. */
338: tsp = (u_char *)(ECmem+(ECBFSZ*ECTBF));
339: *(short *)tsp = (ECBFSZ) - count; /* Stuff offset into buffer */
340: tsp += ((ECBFSZ) - count); /* Adjust ptr into buffer */
341:
342: while (count > 0 && bp != 0) {
343: len = bp->wptr - bp->rptr;
344: fsp = bp->rptr;
345: count -= len;
346: while (len-- > 0) /* Could this use scopy()? */
347: *tsp++ = *fsp++;
348: nbp = bp->next;
349: freeb(bp);
350: bp = nbp;
351: }
352:
353: /* if no buffers left but count > 0, (i.e. padded packet), zero fill */
354: while (count-- > 0)
355: *tsp++ = 0;
356:
357: /* flush remaining buffers, if any (too large packet: count > 1500) */
358: while (bp) {
359: nbp = bp->next;
360: freeb(bp);
361: bp = nbp;
362: }
363:
364: if (ecu->state & ECDEBUG) {
365: register i;
366: printf("\ncount=%d, packet = ", count);
367: tsp = (u_char *)(ECmem+(ECBFSZ*ECTBF)) + (ECBFSZ - count);
368: for(i = 0; i < count; i++)
369: printf("%02x ", (unsigned int)*tsp++);
370: printf("\n");
371: }
372: ecu->state |= ECXBUSY;
373: ecu->collisions = 0;
374: ecaddr->ecxcr = EC_WRITE + ECTBF;
375: }
376:
377: ecioctl(q, bp)
378: register struct queue *q;
379: register struct block *bp;
380: {
381: #ifndef EIOCSETP
382: #define EIOCSETP (('e'<<8)|3) /* set ec_state (state of driver) */
383: #define EIOCGETP (('e'<<8)|4) /* get ec_state (driver state) */
384: #define EIOCAREC (('e'<<8)|5) /* set address recognition */
385: #endif
386: register struct ecdevice *ecaddr;
387: register struct ecchan *ecd;
388: register struct ec *ecu;
389: register u_char *msg;
390: register unit, i, ps, cmd;
391:
392: ecd = (struct ecchan *)q->ptr;
393: unit = ecd->unit;
394: ecu = &ec[unit];
395: ecaddr = (struct ecdevice *)ecinfo[unit]->ui_addr;
396: cmd = ((union stmsg *)(bp->rptr))->ioc1.com;
397: msg = (u_char *)&((union stmsg *)(bp->rptr))->ioc1.sb;
398:
399: bp->type = M_IOCACK;
400: if (ecu->state & ECDEBUG)
401: printf("ecioctl: cmd = %x\n");
402: switch(cmd) {
403: case ENIOADDR: /* get my Ethernet address */
404: bcopy(ecu->myethadr, (int *)msg, 6);
405: break;
406:
407: /*
408: * SETP, SETD, SSIG, AREC should be super user ioctl calls.
409: * Since it is impossible to know who the initiator of an ioctl call is,
410: * it would be desirable to have a special minor device number for super user
411: * privileges
412: */
413: case EIOCSETP:
414: case EIOCGETP:
415: if (cmd == EIOCGETP) {
416: *(int *)msg = ecu->state;
417: } else {
418: ecu->state = *(int *)msg;
419: }
420: if (ecu->state & ECDEBUG)
421: printf("state = %o\n", ecu->state);
422: break;
423:
424: case ENIOTYPE:
425: ecd->type = *(int *)msg;
426: break;
427:
428: case EIOCAREC:
429: ecu->bits = *(int *)msg;
430: ecu->bits |= EC_IE|EC_WBN;
431: if (ecu->state & ECDEBUG)
432: printf("set addr rec, bits = %b\n", ecu->bits, EC_BITS);
433: ps = spl6();
434: ecaddr->ecxcr = EC_CLR; /* Reset the UE */
435: for(i = ECRHBF; i >= ECRLBF; i--)
436: ecaddr->ecrcr = ecu->bits + i;
437: splx(ps);
438: break;
439:
440: default:
441: bp->type = M_IOCNAK;
442: break;
443: }
444: qreply(q, bp);
445: }
446:
447:
448: /* Come here only after hardware has decided packet is for us--
449: either exactly, or multi-cast */
450: ecrint(unit)
451: {
452: register struct ecchan *ecd;
453: register struct ec *ecu = &ec[unit];
454: register struct ecdevice *ecaddr = (struct ecdevice *)ecinfo[unit]->ui_addr;
455: register struct queue *q;
456: register struct block *bp;
457: register short buf; /* Extract done rcv buffer */
458: register short type;
459: register short *fsp;
460: register len, min, i;
461: register u_char *p;
462:
463: while (ecaddr->ecrcr & EC_DONE) {
464: buf = ecaddr->ecrcr & 0xF; /* Extract buffer # */
465: if (buf < ECRLBF || buf > ECRHBF)
466: panic("ec%d: rcvr interrupt (bad buf=%d)\n", unit, buf);
467:
468: /* fsp points to the buffer in VAX virt memory */
469:
470: fsp = (short *)(ECmem+(ECBFSZ*buf));
471: if (*fsp < 0) { /* negative offset => FCS err */
472: ecu->ierrors++;
473: goto out;
474: }
475: if (((*fsp) & 0x3fff) == 0) { /* 0 offset => TOO LONG pkt */
476: ecu->ierrors++;
477: goto out;
478: }
479: /* *fsp contains offset to end of packet - ie (length + beginning offset);
480: packet starts at offset 528 into the buffer */
481:
482: if (*fsp < 592 || *fsp > 2046) { /* illegal count */
483: ecu->ierrors++;
484: goto out;
485: }
486: len = *fsp - (528+4); /* +4 is the FCS */
487: fsp = fsp + (528/2); /* Offset of beg of packet */
488: type = *(fsp + 6);
489: p = (u_char *)fsp;
490:
491: ecd = &ecchan[unit * CHANS_PER_UNIT];
492: for (i = 0; i < CHANS_PER_UNIT; i++, ecd++)
493: if (ecd->ecq && ecd->type == type)
494: break;
495: if (i >= CHANS_PER_UNIT)
496: goto out;
497: q = ecd->ecq;
498: if (q->next->flag & QFULL) {
499: if(ecu->state & ECDEBUG)
500: printf(" q full\n");
501: ecu->ierrors++;
502: goto out;
503: }
504: while (len > 0) {
505: bp = allocb(len);
506: if (bp == 0) {
507: printf("ecrint no buffers\n");
508: goto out;
509: }
510: min = MIN((bp->lim - bp->base), len);
511: len -= min;
512: while (min-- > 0)
513: *bp->wptr++ = *p++;
514: (*q->next->qinfo->putp)(q->next, bp);
515: }
516: if (putctl(q->next, M_DELIM))
517: ecu->ipackets++;
518: else
519: printf("ecrint no DELIM bp\n");
520: out:
521: ecaddr->ecrcr = ecu->bits | EC_CLRDN | buf;
522: }
523: }
524:
525: ecjint(unit)
526: {
527: register struct ecdevice *ecaddr = (struct ecdevice *)ecinfo[unit]->ui_addr;
528: register struct ec *ecu = &ec[unit];
529: register i;
530:
531: if(++ecu->collisions > 8) {
532: printf("ec gak\n");
533: ecu->oerrors++;
534: /* Hmmm, can't xmit in 8 tries */
535: ecaddr->ecxcr = EC_CLR; /* Reset the UE */
536: /* And re-read all rcv buffers */
537: for(i = ECRHBF; i >= ECRLBF; i--)
538: ecaddr->ecrcr = ecu->bits + i;
539: ecu->state &= ~ECXBUSY;
540: } else {
541: ecu->collisions++;
542: backoff(ecu->collisions);
543: ecaddr->ecxcr = EC_CLEAR; /* RESET */
544: }
545: }
546:
547:
548: /* backoff: this routine implements an approximation of the binary
549: * exponential backoff algorithm. When called with an argument n,
550: * the retry number, this routine will delay (in a busy loop)
551: * a random amount of time between 0 and 2**n slot times. A slot
552: * time is defined as 51.2 microseconds. This routine assumes it
553: * takes about 300 microseconds to be called after the jam actually
554: * occurs, and that the random number generator takes about 50
555: * microseconds.
556: */
557: backoff(n)
558: register int n;
559: {
560: long ecrand();
561: register int time;
562:
563: if (n < 4)
564: return;
565: if (n > 10)
566: n = 10;
567:
568: /* compute number of slot times to delay */
569: time = ((int)ecrand() & ((1 << n) - 1)) - 7;
570: if (time <= 0)
571: return;
572:
573: while(time--)
574: ecidle();
575: }
576:
577: static long randx = 1;
578:
579: ecsrand(x)
580: unsigned x;
581: {
582: randx = x;
583: }
584:
585: ecrand()
586: {
587: return(((randx = randx*1103515245 + 12345)>>16) & 077777);
588: }
589:
590:
591: ecidle()
592: {
593: register i = 40;
594:
595: while(--i) ;
596: }
597:
598: /*
599: * ecxint gets called when a transmit completes normally.
600: */
601: ecxint(unit)
602: {
603: register struct ecdevice *ecaddr = (struct ecdevice *)ecinfo[unit]->ui_addr;
604: register struct ec *ecu;
605: register struct ecchan *ecd;
606: register struct block *bp;
607: register buf = ecaddr->ecxcr & 0xF;
608:
609: if((ecaddr->ecxcr & EC_DONE) == 0 || buf != ECTBF)
610: printf("ec%d: xmit interrupt-bad bufno, xcsr=%b\n", unit, ecaddr->ecxcr, EC_BITS);
611:
612: ecu = &ec[unit];
613: if(ecu->active == 0) {
614: printf("ec%d: stray xmit interrupt, xcsr=%b\n", unit, ecaddr->ecxcr, EC_BITS);
615: return;
616: }
617:
618: ecaddr->ecxcr = EC_CLRDN;
619: ecu->state &= ~ECXBUSY;
620: ecu->active = 0;
621: ecu->opackets++;
622: ecstart(unit);
623: }
624: scopy(f, t, c)
625: register u_char *f, *t;
626: register c;
627: {
628: while(c-- > 0)
629: *t++ = *f++;
630: }
631: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.