![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devincon.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 / gnot|
Return to devincon.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot |
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 "devtab.h"
8:
9: #include "io.h"
10: #include "ureg.h"
11:
12: typedef struct Incon Incon;
13: typedef struct Device Device;
14:
15: #define NOW (MACHP(0)->ticks*MS2HZ)
16:
17: #define MICROSECOND USED(NOW)
18:
19: #define DPRINT if(0)
20:
21: enum {
22: Minstation= 2, /* lowest station # to poll */
23: Maxstation= 15, /* highest station # to poll */
24: Nincon= 1, /* number of incons */
25: Nin= 32, /* Blocks in the input ring */
26: Bsize= 128, /* size of an input ring block */
27: Mfifo= 0xff, /* a mask, must be 2^n-1, must be > Nin */
28:
29: Qstats= 1, /* qid of the statistics file */
30: };
31:
32: /*
33: * incon datakit board
34: */
35: struct Device {
36: uchar cdata;
37: #define cpolln cdata
38: uchar u0;
39: uchar cstatus;
40: uchar u1;
41: uchar creset;
42: uchar u2;
43: uchar csend;
44: uchar u3;
45: ushort data_cntl; /* data is high byte, cntl is low byte */
46: uchar status;
47: #define cmd status
48: uchar u5;
49: uchar reset;
50: uchar u6;
51: uchar send;
52: uchar u7;
53: };
54: #define INCON ((Device *)0x40700000)
55:
56: struct Incon {
57: QLock;
58:
59: QLock xmit; /* transmit lock */
60: QLock reslock; /* reset lock */
61: Device *dev;
62: int station; /* station number */
63: int state; /* chip state */
64: Rendez r; /* output process */
65: Rendez kr; /* input kernel process */
66: ushort chan; /* current input channel */
67: Queue *rq; /* read queue */
68: int kstarted; /* true if kernel process started */
69:
70: /* input blocks */
71:
72: Block *inb[Nin];
73: ushort wi;
74: ushort ri;
75:
76: /* statistics */
77:
78: ulong overflow; /* overflow errors */
79: ulong pack0; /* channel 0 */
80: ulong crc; /* crc errors */
81: ulong in; /* bytes in */
82: ulong out; /* bytes out */
83: ulong wait; /* wait time in milliseconds */
84: };
85:
86: Incon incon[Nincon];
87:
88: /*
89: * chip state
90: */
91: enum {
92: Selecting,
93: Selected,
94: Notliving,
95: };
96:
97: /*
98: * internal chip registers
99: */
100: #define sel_polln 0
101: #define sel_station 1
102: #define sel_poll0 2
103: #define sel_rcv_cnt 3
104: #define sel_rcv_tim 4
105: #define sel_tx_cnt 5
106:
107: /*
108: * CSR bits
109: */
110: #define INCON_RUN 0x80
111: #define INCON_STOP 0x00
112: #define ENABLE_IRQ 0x40
113: #define ENABLE_TX_IRQ 0x20
114: #define INCON_ALIVE 0x80
115: #define TX_FULL 0x10
116: #define TX_EMPTY 0x08
117: #define RCV_EMPTY 0x04
118: #define OVERFLOW 0x02
119: #define CRC_ERROR 0x01
120:
121: /*
122: * polling constants
123: */
124: #define HT_GNOT 0x30
125: #define ST_UNIX 0x04
126: #define NCHAN 16
127:
128: static void inconkproc(void*);
129:
130: /*
131: * incon stream module definition
132: */
133: static void inconoput(Queue*, Block*);
134: static void inconstopen(Queue*, Stream*);
135: static void inconstclose(Queue*);
136: Qinfo inconinfo =
137: {
138: nullput,
139: inconoput,
140: inconstopen,
141: inconstclose,
142: "incon"
143: };
144:
145: int incondebug;
146:
147: Dirtab incondir[]={
148: "stats", {Qstats}, 0, 0444,
149: };
150:
151: /*
152: * set the incon parameters
153: */
154: void
155: inconset(Incon *ip, int cnt, int del)
156: {
157: Device *dev;
158:
159: if (cnt<1 || cnt>14 || del<1 || del>15)
160: error(Ebadarg);
161:
162: dev = ip->dev;
163: dev->cmd = sel_rcv_cnt | INCON_RUN;
164: MICROSECOND;
165: *(uchar *)&dev->data_cntl = cnt;
166: MICROSECOND;
167: dev->cmd = sel_rcv_tim | INCON_RUN;
168: MICROSECOND;
169: *(uchar *)&dev->data_cntl = del;
170: MICROSECOND;
171: dev->cmd = INCON_RUN | ENABLE_IRQ;
172: }
173:
174: /*
175: * parse a set request
176: */
177: void
178: inconsetctl(Incon *ip, Block *bp)
179: {
180: char *field[3];
181: int n;
182: int del;
183: int cnt;
184:
185: del = 15;
186: n = getfields((char *)bp->rptr, field, 3, " ");
187: switch(n){
188: default:
189: freeb(bp);
190: error(Ebadarg);
191: case 2:
192: del = strtol(field[1], 0, 0);
193: if(del<0 || del>15){
194: freeb(bp);
195: error(Ebadarg);
196: }
197: /* fall through */
198: case 1:
199: cnt = strtol(field[0], 0, 0);
200: if(cnt<0 || cnt>15){
201: freeb(bp);
202: error(Ebadarg);
203: }
204: }
205: inconset(ip, cnt, del);
206: freeb(bp);
207: }
208:
209: static void
210: nop(void)
211: {
212: }
213:
214: /*
215: * poll for a station number
216: */
217: void
218: inconpoll(Incon *ip, int station)
219: {
220: ulong timer;
221: Device *dev;
222:
223: dev = ip->dev;
224:
225: /*
226: * get us to a known state
227: */
228: ip->state = Notliving;
229: dev->cmd = INCON_STOP;
230:
231: /*
232: * try a station number
233: */
234: dev->cmd = sel_station;
235: *(uchar *)&dev->data_cntl = station;
236: dev->cmd = sel_poll0;
237: *(uchar *)&dev->data_cntl = HT_GNOT;
238: dev->cmd = sel_rcv_cnt;
239: *(uchar *)&dev->data_cntl = 3;
240: dev->cmd = sel_rcv_tim;
241: *(uchar *)&dev->data_cntl = 15;
242: dev->cmd = sel_tx_cnt;
243: *(uchar *)&dev->data_cntl = 1;
244: dev->cmd = sel_polln;
245: *(uchar *)&dev->data_cntl = 0x00;
246: *(uchar *)&dev->data_cntl = ST_UNIX;
247: *(uchar *)&dev->data_cntl = NCHAN;
248: *(uchar *)&dev->data_cntl = 'g';
249: *(uchar *)&dev->data_cntl = 'n';
250: *(uchar *)&dev->data_cntl = 'o';
251: *(uchar *)&dev->data_cntl = 't';
252: dev->cpolln = 0;
253:
254: /*
255: * poll and wait for ready (or 1/4 second)
256: */
257: ip->state = Selecting;
258: dev->cmd = INCON_RUN | ENABLE_IRQ;
259: timer = NOW + 250;
260: while (NOW < timer) {
261: nop();
262: if(dev->status & INCON_ALIVE){
263: ip->station = station;
264: ip->state = Selected;
265: break;
266: }
267: }
268: }
269:
270: /*
271: * reset the chip and find a new staion number
272: */
273: void
274: inconrestart(Incon *ip)
275: {
276: int i;
277:
278: if(!canqlock(&ip->reslock))
279: return;
280:
281: /*
282: * poll for incon station numbers
283: */
284: for(i = Minstation; i <= Maxstation; i++){
285: inconpoll(ip, i);
286: if(ip->state == Selected)
287: break;
288: }
289: switch(ip->state) {
290: case Selecting:
291: print("incon[%d] not polled\n", ip-incon);
292: break;
293: case Selected:
294: print("incon[%d] station %d\n", ip-incon, ip->station);
295: inconset(ip, 3, 15);
296: break;
297: default:
298: print("incon[%d] bollixed\n", ip-incon);
299: break;
300: }
301: qunlock(&ip->reslock);
302: }
303:
304: /*
305: * reset all incon chips.
306: */
307: void
308: inconreset(void)
309: {
310: int i;
311:
312: incon[0].dev = INCON;
313: incon[0].state = Selected;
314: incon[0].ri = incon[0].wi = 0;
315: /* inconset(&incon[0], 3, 15); /**/
316: for(i=1; i<Nincon; i++){
317: incon[i].dev = INCON+i;
318: incon[i].state = Notliving;
319: incon[i].dev->cmd = INCON_STOP;
320: incon[i].ri = incon[i].wi = 0;
321: }
322: }
323:
324: void
325: inconinit(void)
326: {
327: }
328:
329: /*
330: * enable the device for interrupts, spec is the device number
331: */
332: Chan*
333: inconattach(char *spec)
334: {
335: Incon *ip;
336: int i;
337: Chan *c;
338:
339: i = strtoul(spec, 0, 0);
340: if(i >= Nincon)
341: error(Ebadarg);
342: ip = &incon[i];
343: if(ip->state != Selected)
344: inconrestart(ip);
345:
346: c = devattach('i', spec);
347: c->dev = i;
348: c->qid.path = CHDIR;
349: c->qid.vers = 0;
350: return c;
351: }
352:
353: Chan*
354: inconclone(Chan *c, Chan *nc)
355: {
356: return devclone(c, nc);
357: }
358:
359: int
360: inconwalk(Chan *c, char *name)
361: {
362: return devwalk(c, name, incondir, 1, streamgen);
363: }
364:
365: void
366: inconstat(Chan *c, char *dp)
367: {
368: devstat(c, dp, incondir, 1, streamgen);
369: }
370:
371: Chan*
372: inconopen(Chan *c, int omode)
373: {
374: if(c->qid.path == CHDIR || c->qid.path == Qstats){
375: if(omode != OREAD)
376: error(Eperm);
377: }else
378: streamopen(c, &inconinfo);
379: c->mode = openmode(omode);
380: c->flag |= COPEN;
381: c->offset = 0;
382: return c;
383: }
384:
385: void
386: inconcreate(Chan *c, char *name, int omode, ulong perm)
387: {
388: USED(c, name, omode, perm);
389: error(Eperm);
390: }
391:
392: void
393: inconclose(Chan *c)
394: {
395: if(c->qid.path != CHDIR)
396: streamclose(c);
397: }
398:
399: long
400: inconread(Chan *c, void *buf, long n, ulong offset)
401: {
402: char b[256];
403: Incon *i;
404:
405: if(c->qid.path == CHDIR)
406: return devdirread(c, buf, n, incondir, 1, streamgen);
407: else if(c->qid.path == Qstats){
408: i = &incon[c->dev];
409: sprint(b, "in: %d\nout: %d\noverflow: %d\ncrc: %d\nwait: %d\n", i->in,
410: i->out, i->overflow, i->crc, i->wait);
411: return readstr(offset, buf, n, b);
412: } else
413: return streamread(c, buf, n);
414: }
415:
416: long
417: inconwrite(Chan *c, void *buf, long n, ulong offset)
418: {
419: USED(offset);
420: return streamwrite(c, buf, n, 0);
421: }
422:
423: void
424: inconremove(Chan *c)
425: {
426: USED(c);
427: error(Eperm);
428: }
429:
430: void
431: inconwstat(Chan *c, char *dp)
432: {
433: USED(c, dp);
434: error(Eperm);
435: }
436:
437: /*
438: * the stream routines
439: */
440:
441: /*
442: * for sleeping while kproc dies
443: */
444: static int
445: kNotliving(void *arg)
446: {
447: Incon *ip;
448:
449: ip = (Incon *)arg;
450: return ip->kstarted == 0;
451: }
452:
453: /*
454: * create the kernel process for input
455: * first wait for any old ones to die
456: */
457: static void
458: inconstopen(Queue *q, Stream *s)
459: {
460: Incon *ip;
461: char name[32];
462:
463: ip = &incon[s->dev];
464: sprint(name, "incon%d", s->dev);
465: q->ptr = q->other->ptr = ip;
466: wakeup(&ip->kr);
467: sleep(&ip->r, kNotliving, ip);
468: ip->rq = q;
469: kproc(name, inconkproc, ip);
470: }
471:
472: /*
473: * kill off the kernel process
474: */
475: static void
476: inconstclose(Queue * q)
477: {
478: Incon *ip;
479:
480: ip = (Incon *)q->ptr;
481: qlock(ip);
482: ip->rq = 0;
483: qunlock(ip);
484: wakeup(&ip->kr);
485: sleep(&ip->r, kNotliving, ip);
486: }
487:
488: /*
489: * free all blocks of a message in `q', `bp' is the first block
490: * of the message
491: */
492: static void
493: freemsg(Queue *q, Block *bp)
494: {
495: for(; bp; bp = getq(q)){
496: if(bp->flags & S_DELIM){
497: freeb(bp);
498: return;
499: }
500: freeb(bp);
501: }
502: }
503:
504: /*
505: * output a block
506: *
507: * the first 2 bytes of every message are the channel number,
508: * low order byte first. the third is a possible trailing control
509: * character.
510: */
511: void
512: inconoput(Queue *q, Block *bp)
513: {
514: Device *dev;
515: Incon *ip;
516: ulong start, end;
517: int chan;
518: int ctl;
519: int n, size;
520:
521: ip = (Incon *)q->ptr;
522:
523: if(bp->type != M_DATA){
524: if(streamparse("inconset", bp))
525: inconsetctl(ip, bp);
526: else
527: freeb(bp);
528: return;
529: }
530: if(BLEN(bp) < 3){
531: bp = pullup(bp, 3);
532: if(bp == 0){
533: print("inconoput pullup failed\n");
534: return;
535: }
536: }
537:
538: /*
539: * get a whole message before handing bytes to the device
540: */
541: if(!putq(q, bp))
542: return;
543:
544: /*
545: * one transmitter at a time
546: */
547: qlock(&ip->xmit);
548: dev = ip->dev;
549:
550: /*
551: * parse message
552: */
553: bp = getq(q);
554: chan = bp->rptr[0] | (bp->rptr[1]<<8);
555: ctl = bp->rptr[2];
556: bp->rptr += 3;
557: if(chan<=0)
558: print("bad channel %d\n", chan);
559:
560: if(incondebug)
561: print("->(%d)%uo %d\n", chan, ctl, bp->wptr - bp->rptr);
562:
563: /*
564: * make sure there's an incon out there
565: */
566: if(!(dev->status&INCON_ALIVE) || ip->state==Notliving){
567: inconrestart(ip);
568: freemsg(q, bp);
569: qunlock(&ip->xmit);
570: return;
571: }
572:
573: /*
574: * send the 8 bit data
575: */
576: for(;;){
577: /*
578: * spin till there is room
579: */
580: start = NOW;
581: for(n = 0, end = start+1000; dev->status & TX_FULL; n++){
582: nop(); /* make sure we don't optimize too much */
583: if(NOW > end){
584: print("incon output stuck\n");
585: freemsg(q, bp);
586: qunlock(&ip->xmit);
587: return;
588: }
589: }
590: ip->wait = (n + ip->wait)>>1;
591:
592: /*
593: * put in next packet
594: */
595: n = bp->wptr - bp->rptr;
596: if(n > 16)
597: n = 16;
598: size = n;
599: dev->cdata = chan;
600: ip->out += n;
601: while(n--){
602: *(uchar *)&dev->data_cntl = *bp->rptr++;
603: }
604:
605: /*
606: * get next block
607: */
608: if(bp->rptr >= bp->wptr){
609: if(bp->flags & S_DELIM){
610: freeb(bp);
611: break;
612: }
613: freeb(bp);
614: bp = getq(q);
615: if(bp==0)
616: break;
617: }
618:
619: /*
620: * end packet
621: */
622: dev->cdata = 0;
623: }
624:
625: /*
626: * send the control byte if there is one
627: */
628: if(ctl){
629: if(size >= 16){
630: dev->cdata = 0;
631: MICROSECOND;
632: for(end = NOW+1000; dev->status & TX_FULL;){
633: nop(); /* make sure we don't optimize too much */
634: if(NOW > end){
635: print("incon output stuck\n");
636: freemsg(q, bp);
637: qunlock(&ip->xmit);
638: return;
639: }
640: }
641: dev->cdata = chan;
642: MICROSECOND;
643: }
644: if(dev->status & TX_FULL)
645: print("inconfull\n");
646: dev->cdata = ctl;
647: }
648: MICROSECOND;
649: dev->cdata = 0;
650:
651: qunlock(&ip->xmit);
652: return;
653: }
654:
655: /*
656: * return true if the raw fifo is non-empty
657: */
658: static int
659: notempty(void *arg)
660: {
661: Incon *ip;
662:
663: ip = (Incon *)arg;
664: return ip->ri!=ip->wi;
665: }
666:
667: /*
668: * Read bytes from the raw input circular buffer.
669: */
670: static void
671: inconkproc(void *arg)
672: {
673: Incon *ip;
674: Block *bp;
675: int i;
676: int locked;
677:
678: ip = (Incon *)arg;
679: ip->kstarted = 1;
680:
681: /*
682: * create a number of blocks for input
683: */
684: for(i = 0; i < Nin; i++){
685: bp = ip->inb[i] = allocb(Bsize);
686: bp->wptr += 3;
687: }
688:
689: locked = 0;
690: if(waserror()){
691: if(locked)
692: qunlock(ip);
693: ip->kstarted = 0;
694: wakeup(&ip->r);
695: return;
696: }
697:
698: for(;;){
699: /*
700: * sleep if input fifo empty
701: */
702: sleep(&ip->kr, notempty, ip);
703:
704: /*
705: * die if the device is closed
706: */
707: USED(locked);
708: qlock(ip);
709: locked = 1;
710: if(ip->rq == 0){
711: qunlock(ip);
712: ip->kstarted = 0;
713: wakeup(&ip->r);
714: poperror();
715: return;
716: }
717:
718: /*
719: * send blocks upstream and stage new blocks. if the block is small
720: * (< 64 bytes) copy into a smaller buffer.
721: */
722: while(ip->ri != ip->wi){
723: bp = ip->inb[ip->ri];
724: ip->in += BLEN(bp);
725: PUTNEXT(ip->rq, bp);
726: bp = ip->inb[ip->ri] = allocb(Bsize);
727: bp->wptr += 3;
728: ip->ri = (ip->ri+1)%Nin;
729: }
730: USED(locked);
731: qunlock(ip);
732: locked = 0;
733: }
734: }
735:
736: /*
737: * drop a single packet
738: */
739: static void
740: droppacket(Device *dev)
741: {
742: int i;
743: int c;
744:
745: for(i = 0; i < 17; i++){
746: c = dev->data_cntl;
747: if(c==0)
748: break;
749: }
750: }
751:
752: /*
753: * flush the input fifo
754: */
755: static void
756: flushfifo(Device *dev)
757: {
758: while(!(dev->status & RCV_EMPTY))
759: droppacket(dev);
760: }
761:
762: /*
763: * advance the queue. if we've run out of staged input blocks,
764: * drop the packet and return 0. otherwise return the next input
765: * block to fill.
766: */
767: static Block *
768: nextin(Incon *ip, unsigned int c)
769: {
770: Block *bp;
771: int next;
772:
773: bp = ip->inb[ip->wi];
774: bp->rptr[0] = ip->chan;
775: bp->rptr[1] = ip->chan>>8;
776: bp->rptr[2] = c;
777: if(incondebug)
778: print("<-(%d)%uo %d\n", ip->chan, c, bp->wptr-bp->rptr);
779:
780: next = (ip->wi+1)%Nin;
781: if(next == ip->ri){
782: bp->wptr = bp->rptr+3;
783: return bp;
784: }
785: ip->wi = next;
786:
787: return ip->inb[ip->wi];
788: }
789:
790: /*
791: * read the packets from the device into the staged input blocks.
792: * we have to do this at interrupt tevel to turn off the interrupts.
793: */
794: static void
795: rdpackets(Incon *ip)
796: {
797: Block *bp;
798: unsigned int c;
799: Device *dev;
800: uchar *p;
801: int first = ip->wi;
802:
803: dev = ip->dev;
804: bp = ip->inb[ip->wi];
805: if(bp==0){
806: flushfifo(ip->dev);
807: return;
808: }
809: p = bp->wptr;
810: while(!(dev->status & RCV_EMPTY)){
811: /*
812: * get channel number
813: */
814: c = (dev->data_cntl)>>8;
815: if(c == 0){
816: droppacket(dev);
817: continue;
818: }
819: if(ip->chan != c){
820: if(p - bp->rptr > 3){
821: bp->wptr = p;
822: bp = nextin(ip, 0);
823: if(bp==0){
824: flushfifo(ip->dev);
825: return;
826: }
827: p = bp->wptr;
828: }
829: ip->chan = c;
830: }
831:
832: /*
833: * null byte marks end of packet
834: */
835: for(;;){
836: if((c=dev->data_cntl)&1) {
837: /*
838: * data byte, put in local buffer
839: */
840: *p++ = c>>8;
841: } else if (c>>=8) {
842: /*
843: * control byte ends block
844: */
845: bp->wptr = p;
846: bp = nextin(ip, c);
847: if(bp==0){
848: flushfifo(ip->dev);
849: return;
850: }
851: p = bp->wptr;
852: } else {
853: /* end of packet */
854: break;
855: }
856: }
857:
858: /*
859: * pass a block on if it doesn't have room for one more
860: * packet. this way we don't have to check per byte.
861: */
862: if(p + 16 > bp->lim){
863: bp->wptr = p;
864: bp = nextin(ip, 0);
865: p = bp->wptr;
866: }
867: }
868: bp->wptr = p;
869: if(bp->wptr != bp->rptr+3)
870: nextin(ip, 0);
871:
872: if(first != ip->wi)/**/
873: wakeup(&ip->kr);
874: }
875:
876: /*
877: * Receive an incon interrupt. One entry point
878: * for all types of interrupt. Until we figure out
879: * how to use more than one incon, this routine only
880: * is for incon[0].
881: */
882: void
883: inconintr(Ureg *ur)
884: {
885: uchar status;
886: Incon *ip;
887:
888: USED(ur);
889: ip = &incon[0];
890:
891: status = ip->dev->status;
892: if(!(status & RCV_EMPTY))
893: rdpackets(ip);
894:
895: /* check for exceptional conditions */
896: if(status&(OVERFLOW|CRC_ERROR)){
897: if(status&OVERFLOW)
898: ip->overflow++;
899: if(status&CRC_ERROR)
900: ip->crc++;
901: }
902:
903: /* see if it died underneath us */
904: if(!(status&INCON_ALIVE)){
905: switch(ip->state){
906: case Selected:
907: ip->dev->cmd = INCON_STOP;
908: print("Incon died\n");
909: break;
910: case Selecting:
911: print("rejected\n");
912: break;
913: default:
914: ip->dev->cmd = INCON_STOP;
915: break;
916: }
917: ip->state = Notliving;
918: }
919: }
920:
921: void
922: incontoggle(void)
923: {
924: incondebug ^= 1;
925: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.