![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devether.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc|
Return to devether.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "../port/error.h"
7: #include "io.h"
8: #include "devtab.h"
9:
10: #include "ether.h"
11:
12: /*
13: * Half-arsed attempt at a general top-level
14: * ethernet driver. Needs work:
15: * handle multiple controllers
16: * much tidying
17: * set ethernet address
18: * need a ctl file passed down to card drivers
19: * so we can set options.
20: */
21:
22: struct Ctlr *softctlr;
23:
24: Chan*
25: etherclone(Chan *c, Chan *nc)
26: {
27: return devclone(c, nc);
28: }
29:
30: int
31: etherwalk(Chan *c, char *name)
32: {
33: return netwalk(c, name, &softctlr->net);
34: }
35:
36: void
37: etherstat(Chan *c, char *dp)
38: {
39: netstat(c, dp, &softctlr->net);
40: }
41:
42: Chan*
43: etheropen(Chan *c, int omode)
44: {
45: return netopen(c, omode, &softctlr->net);
46: }
47:
48: void
49: ethercreate(Chan *c, char *name, int omode, ulong perm)
50: {
51: USED(c, name, omode, perm);
52: error(Eperm);
53: }
54:
55: void
56: etherclose(Chan *c)
57: {
58: if(c->stream)
59: streamclose(c);
60: }
61:
62: long
63: etherread(Chan *c, void *a, long n, ulong offset)
64: {
65: return netread(c, a, n, offset, &softctlr->net);
66: }
67:
68: long
69: etherwrite(Chan *c, char *a, long n, ulong offset)
70: {
71: USED(offset);
72: return streamwrite(c, a, n, 0);
73: }
74:
75: void
76: etherremove(Chan *c)
77: {
78: USED(c);
79: error(Eperm);
80: }
81:
82: void
83: etherwstat(Chan *c, char *dp)
84: {
85: netwstat(c, dp, &softctlr->net);
86: }
87:
88: static int
89: isobuf(void *arg)
90: {
91: Ctlr *ctlr = arg;
92:
93: return ctlr->tb[ctlr->th].owner == Host;
94: }
95:
96: static void
97: etheroput(Queue *q, Block *bp)
98: {
99: Ctlr *ctlr;
100: Type *type;
101: Etherpkt *pkt;
102: RingBuf *ring;
103: int len, n, s;
104: Block *nbp;
105: uchar ea[6];
106: char *err;
107:
108: type = q->ptr;
109: ctlr = type->ctlr;
110: if(bp->type == M_CTL){
111: err = 0;
112: qlock(ctlr);
113: if(streamparse("connect", bp)){
114: if(type->type == -1)
115: ctlr->all--;
116: type->type = strtol((char*)bp->rptr, 0, 0);
117: if(type->type == -1)
118: ctlr->all++;
119: }
120: else if(streamparse("promiscuous", bp)) {
121: if(type->prom)
122: goto ctlout;
123: if(type->filter){
124: err = "address already set";
125: goto ctlout;
126: }
127: type->prom = 1;
128: ctlr->prom++;
129: if(ctlr->prom+ctlr->filter == 1)
130: (*ctlr->card.mode)(ctlr, 1);
131: }
132: else if(streamparse("address", bp)) {
133: if(type->prom){
134: err = "already promiscuous";
135: goto ctlout;
136: }
137: if(parseether(ea, bp->rptr) < 0){
138: err = "bad ether address";
139: goto ctlout;
140: }
141: memmove(type->ea, ea, sizeof(ea));
142: if(!type->filter){
143: type->filter = 1;
144: ctlr->filter++;
145: if(ctlr->filter == 1)
146: (*ctlr->card.mode)(ctlr, 3);
147: }
148: }
149: ctlout:
150: qunlock(ctlr);
151: freeb(bp);
152: if(err)
153: error(err);
154: return;
155: }
156:
157: /*
158: * Give packet a local address, return upstream if destined for
159: * this machine.
160: */
161: if(BLEN(bp) < ETHERHDRSIZE && (bp = pullup(bp, ETHERHDRSIZE)) == 0)
162: return;
163: pkt = (Etherpkt*)bp->rptr;
164: memmove(pkt->s, type->ea, sizeof(type->ea));
165: if(memcmp(ctlr->ea, pkt->d, sizeof(ctlr->ea)) == 0){
166: len = blen(bp);
167: if(bp = expandb(bp, len >= ETHERMINTU ? len: ETHERMINTU)){
168: putq(&ctlr->lbq, bp);
169: wakeup(&ctlr->rr);
170: }
171: return;
172: }
173: if(memcmp(ctlr->ba, pkt->d, sizeof(ctlr->ba)) == 0 || ctlr->prom || ctlr->all){
174: len = blen(bp);
175: nbp = copyb(bp, len);
176: if(nbp = expandb(nbp, len >= ETHERMINTU ? len: ETHERMINTU)){
177: nbp->wptr = nbp->rptr+len;
178: putq(&ctlr->lbq, nbp);
179: wakeup(&ctlr->rr);
180: }
181: }
182:
183: /*
184: * Only one transmitter at a time.
185: */
186: qlock(&ctlr->tlock);
187: if(waserror()){
188: qunlock(&ctlr->tlock);
189: freeb(bp);
190: nexterror();
191: }
192:
193: /*
194: * Wait till we get an output buffer.
195: * should try to restart.
196: */
197: if(isobuf(ctlr) == 0){
198: tsleep(&ctlr->tr, isobuf, ctlr, 3*1000);
199: if(isobuf(ctlr) == 0){
200: qunlock(&ctlr->tlock);
201: freeb(bp);
202: poperror();
203: return;
204: }
205: }
206:
207: ring = &ctlr->tb[ctlr->th];
208:
209: /*
210: * Copy message into buffer.
211: */
212: len = 0;
213: for(nbp = bp; nbp; nbp = nbp->next){
214: if(sizeof(Etherpkt) - len >= (n = BLEN(nbp))){
215: memmove(ring->pkt+len, nbp->rptr, n);
216: len += n;
217: }
218: if(bp->flags & S_DELIM)
219: break;
220: }
221:
222: /*
223: * Pad the packet (zero the pad).
224: */
225: if(len < ETHERMINTU){
226: memset(ring->pkt+len, 0, ETHERMINTU-len);
227: len = ETHERMINTU;
228: }
229:
230: /*
231: * Set up the transmit buffer and
232: * start the transmission.
233: */
234: s = splhi();
235: ring->len = len;
236: ring->owner = Interface;
237: ctlr->th = NEXT(ctlr->th, ctlr->ntb);
238: (*ctlr->card.transmit)(ctlr);
239: ctlr->outpackets++;
240: splx(s);
241:
242: qunlock(&ctlr->tlock);
243: freeb(bp);
244: poperror();
245: }
246:
247: /*
248: * Open an ether line discipline.
249: */
250: static void
251: etherstopen(Queue *q, Stream *s)
252: {
253: Ctlr *ctlr = softctlr;
254: Type *type;
255:
256: type = &ctlr->type[s->id];
257: RD(q)->ptr = WR(q)->ptr = type;
258: type->type = 0;
259: type->q = RD(q);
260: type->inuse = 1;
261: memmove(type->ea, ctlr->ea, sizeof(type->ea));
262: type->ctlr = ctlr;
263: }
264:
265: /*
266: * Close ether line discipline.
267: *
268: * The locking is to synchronize changing the ethertype with
269: * sending packets up the stream on interrupts.
270: */
271: static int
272: isclosed(void *arg)
273: {
274: return ((Type*)arg)->q == 0;
275: }
276:
277: static void
278: etherstclose(Queue *q)
279: {
280: Type *type = (Type*)(q->ptr);
281: Ctlr *ctlr = type->ctlr;
282:
283: if(type->prom){
284: qlock(ctlr);
285: ctlr->prom--;
286: if(ctlr->prom+ctlr->filter == 0)
287: (*ctlr->card.mode)(ctlr, 0);
288: qunlock(ctlr);
289: }
290: if(type->filter){
291: qlock(ctlr);
292: ctlr->filter--;
293: if(ctlr->filter == 0)
294: (*ctlr->card.mode)(ctlr, ctlr->prom ? 1 : 0);
295: qunlock(ctlr);
296: }
297: if(type->type == -1){
298: qlock(ctlr);
299: ctlr->all--;
300: qunlock(ctlr);
301: }
302:
303: /*
304: * Mark as closing and wait for kproc
305: * to close us.
306: */
307: lock(&ctlr->clock);
308: type->clist = ctlr->clist;
309: ctlr->clist = type;
310: unlock(&ctlr->clock);
311: wakeup(&ctlr->rr);
312: sleep(&type->cr, isclosed, type);
313:
314: type->type = 0;
315: type->prom = 0;
316: type->filter = 0;
317: type->inuse = 0;
318: netdisown(type);
319: type->ctlr = 0;
320: }
321:
322: static Qinfo info = {
323: nullput,
324: etheroput,
325: etherstopen,
326: etherstclose,
327: "ether"
328: };
329:
330: static int
331: clonecon(Chan *c)
332: {
333: Ctlr *ctlr = softctlr;
334: Type *type;
335:
336: USED(c);
337: for(type = ctlr->type; type < &ctlr->type[NType]; type++){
338: qlock(type);
339: if(type->inuse || type->q){
340: qunlock(type);
341: continue;
342: }
343: type->inuse = 1;
344: memmove(type->ea, ctlr->ea, sizeof(type->ea));
345: netown(type, u->p->user, 0);
346: qunlock(type);
347: return type - ctlr->type;
348: }
349: exhausted("ether channels");
350: return 0;
351: }
352:
353: static void
354: statsfill(Chan *c, char *p, int n)
355: {
356: Ctlr *ctlr = softctlr;
357: char buf[256];
358:
359: USED(c);
360: sprint(buf, "in: %d\nout: %d\ncrc errs %d\noverflows: %d\nframe errs %d\nbuff errs: %d\noerrs %d\naddr: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x\n",
361: ctlr->inpackets, ctlr->outpackets, ctlr->crcs,
362: ctlr->overflows, ctlr->frames, ctlr->buffs, ctlr->oerrs,
363: ctlr->ea[0], ctlr->ea[1], ctlr->ea[2],
364: ctlr->ea[3], ctlr->ea[4], ctlr->ea[5]);
365: strncpy(p, buf, n);
366: }
367:
368: static void
369: typefill(Chan *c, char *p, int n)
370: {
371: char buf[16];
372: Type *type;
373:
374: type = &softctlr->type[STREAMID(c->qid.path)];
375: sprint(buf, "%d", type->type);
376: strncpy(p, buf, n);
377: }
378:
379: int
380: eaddrmatch(Ctlr *ctlr, uchar *ea)
381: {
382: Type *type;
383:
384: for(type = &ctlr->type[0]; type < &ctlr->type[NType]; type++){
385: if(type->q == 0 || ea[0] != type->ea[0])
386: continue;
387: if(memcmp(ea, type->ea, sizeof(type->ea)) == 0)
388: return 1;
389: }
390: return 0;
391: }
392:
393: static void
394: etherup(Ctlr *ctlr, Etherpkt *pkt, int len)
395: {
396: int t;
397: Type *type;
398: Block *bp;
399:
400: t = (pkt->type[0]<<8)|pkt->type[1];
401: for(type = &ctlr->type[0]; type < &ctlr->type[NType]; type++){
402:
403: /*
404: * Check for open, the right type, and flow control.
405: */
406: if(type->q == 0)
407: continue;
408: if(t != type->type && type->type >= 0)
409: continue;
410: if(type->q->next->len > Streamhi)
411: continue;
412:
413: /*
414: * Only a trace channel gets packets destined for other machines.
415: */
416: if(type->type != -1 && pkt->d[0] != 0xFF
417: && (*pkt->d != *type->ea || memcmp(pkt->d, type->ea, sizeof(pkt->d))))
418: continue;
419:
420: if(waserror() == 0){
421: bp = allocb(len);
422: memmove(bp->rptr, pkt, len);
423: bp->wptr += len;
424: bp->flags |= S_DELIM;
425: PUTNEXT(type->q, bp);
426: poperror();
427: }
428: }
429: }
430:
431: static int
432: isinput(void *arg)
433: {
434: Ctlr *ctlr = arg;
435:
436: return ctlr->lbq.first || ctlr->rb[ctlr->rh].owner == Host || ctlr->clist;
437: }
438:
439: static void
440: etherkproc(void *arg)
441: {
442: Ctlr *ctlr = arg;
443: RingBuf *ring;
444: Block *bp;
445: Type *type;
446:
447: if(waserror()){
448: print("%s noted\n", ctlr->name);
449: /* fix
450: if(ctlr->card.reset)
451: (*ctlr->card.reset)(ctlr);
452: */
453: ctlr->kproc = 0;
454: nexterror();
455: }
456:
457: for(;;){
458: tsleep(&ctlr->rr, isinput, ctlr, 500);
459: if(ctlr->card.watch)
460: (*ctlr->card.watch)(ctlr);
461:
462: /*
463: * Process any internal loopback packets.
464: */
465: while(bp = getq(&ctlr->lbq)){
466: ctlr->inpackets++;
467: etherup(ctlr, (Etherpkt*)bp->rptr, BLEN(bp));
468: freeb(bp);
469: }
470:
471: /*
472: * Process any received packets.
473: */
474: while(ctlr->rb[ctlr->rh].owner == Host){
475: ctlr->inpackets++;
476: ring = &ctlr->rb[ctlr->rh];
477: etherup(ctlr, (Etherpkt*)ring->pkt, ring->len);
478: ring->owner = Interface;
479: ctlr->rh = NEXT(ctlr->rh, ctlr->nrb);
480: }
481:
482: /*
483: * Close Types requesting it.
484: */
485: if(ctlr->clist){
486: lock(&ctlr->clock);
487: for(type = ctlr->clist; type; type = type->clist){
488: type->q = 0;
489: wakeup(&type->cr);
490: }
491: ctlr->clist = 0;
492: unlock(&ctlr->clock);
493: }
494: }
495: }
496:
497: static void
498: etherintr(Ureg *ur, void *a)
499: {
500: Ctlr *ctlr = softctlr;
501:
502: USED(ur, a);
503: (*ctlr->card.intr)(ctlr);
504: }
505:
506: static void
507: reset(Ctlr *ctlr)
508: {
509: int i;
510:
511: if(ctlr->nrb == 0)
512: ctlr->nrb = Nrb;
513: ctlr->rb = xalloc(sizeof(RingBuf)*ctlr->nrb);
514: if(ctlr->ntb == 0)
515: ctlr->ntb = Ntb;
516: ctlr->tb = xalloc(sizeof(RingBuf)*ctlr->ntb);
517:
518: memset(ctlr->ba, 0xFF, sizeof(ctlr->ba));
519:
520: ctlr->net.name = "ether";
521: ctlr->net.nconv = NType;
522: ctlr->net.devp = &info;
523: ctlr->net.protop = 0;
524: ctlr->net.listen = 0;
525: ctlr->net.clone = clonecon;
526: ctlr->net.ninfo = 2;
527: ctlr->net.info[0].name = "stats";
528: ctlr->net.info[0].fill = statsfill;
529: ctlr->net.info[1].name = "type";
530: ctlr->net.info[1].fill = typefill;
531: for(i = 0; i < NType; i++)
532: netadd(&ctlr->net, &ctlr->type[i], i);
533: }
534:
535: extern int wd8003reset(Ctlr*);
536: extern int ne2000reset(Ctlr*);
537: extern int ccc509reset(Ctlr*);
538: extern int nsciareset(Ctlr*);
539: extern int ne2000PCMreset(Ctlr*);
540:
541: #define NCARD 32
542: struct {
543: char *type;
544: int (*reset)(Ctlr*);
545: } cards[NCARD+1];
546:
547: void
548: addethercard(char *t, int (*r)(Ctlr*))
549: {
550: static int ncard;
551:
552: if(ncard == NCARD)
553: panic("too many ether cards");
554: cards[ncard].type = t;
555: cards[ncard].reset = r;
556: ncard++;
557: }
558:
559: void
560: etherreset(void)
561: {
562: Ctlr *ctlr;
563: int i, n, ctlrno;
564:
565: if(softctlr == 0)
566: softctlr = xalloc(sizeof(Ctlr));
567: else
568: memset(softctlr, 0, sizeof(Ctlr));
569: ctlr = softctlr;
570:
571: for(ctlrno = i = 0; isaconfig("ether", i, &ctlr->card); i++){
572: for(n = 0; cards[n].type; n++){
573: if(strcmp(cards[n].type, ctlr->card.type))
574: continue;
575: ctlr->ctlrno = ctlrno;
576: memmove(ctlr->ea, ctlr->card.ea, sizeof(ctlr->ea));
577: if((*cards[n].reset)(ctlr))
578: break;
579:
580: /*ctlrno++;*/
581: ctlr->present = 1;
582: /*
583: * IRQ2 doesn't really exist, it's used to gang the interrupt
584: * controllers together. A device set to IRQ2 will appear on
585: * the second interrupt controller as IRQ9.
586: */
587: if(ctlr->card.irq == 2)
588: ctlr->card.irq = 9;
589: setvec(Int0vec + ctlr->card.irq, etherintr, 0);
590:
591: print("ether%d:%s: port %lux irq %d addr %lux size %d width %d:",
592: ctlr->ctlrno, ctlr->card.type, ctlr->card.port, ctlr->card.irq,
593: ctlr->card.mem, ctlr->card.size, ctlr->card.bit16 ? 16: 8);
594: for(i = 0; i < sizeof(ctlr->ea); i++)
595: print("%2.2ux", ctlr->ea[i]);
596: print("\n");
597:
598: reset(ctlr);
599: return;
600: }
601: memset(softctlr, 0, sizeof(Ctlr));
602: }
603: }
604:
605: void
606: etherinit(void)
607: {
608: Ctlr *ctlr = softctlr;
609: int i;
610:
611: if(ctlr->present == 0)
612: return;
613:
614: ctlr->rh = 0;
615: ctlr->ri = 0;
616: for(i = 0; i < ctlr->nrb; i++)
617: ctlr->rb[i].owner = Interface;
618:
619: ctlr->th = 0;
620: ctlr->ti = 0;
621: for(i = 0; i < ctlr->ntb; i++)
622: ctlr->tb[i].owner = Host;
623: }
624:
625: Chan*
626: etherattach(char *spec)
627: {
628: Ctlr *ctlr = softctlr;
629:
630: if(ctlr->present == 0)
631: error(Enodev);
632:
633: /*
634: * Enable the interface
635: * and start the kproc.
636: */
637: (*ctlr->card.attach)(ctlr);
638: if(ctlr->kproc == 0){
639: sprint(ctlr->name, "ether%dkproc", 0);
640: ctlr->kproc = 1;
641: kproc(ctlr->name, etherkproc, ctlr);
642: }
643: return devattach('l', spec);
644: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.