![[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 / pc|
Return to devincon.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 "devtab.h"
8:
9: #include "io.h"
10:
11: /* Centronix parallel (printer) port */
12:
13: typedef struct Lptinfo Lptinfo;
14:
15: struct Lptinfo
16: {
17: int base; /* port number */
18: int ivec; /* interrupt number */
19: };
20:
21: static Lptinfo lptinfo[] = {
22: 0x3bc, Parallelvec, /* lpt1 (safari) */
23: 0x378, Parallelvec, /* lpt1 (`official') */
24: 0x278, Int0vec+5, /* lpt2 (`official') */
25: };
26: #define NDEV (sizeof lptinfo/sizeof lptinfo[0])
27:
28: extern int incondev; /* from config */
29:
30: /* offsets, and bits in the registers */
31: enum
32: {
33: /* data latch register */
34: Qdlr= 0x0,
35: /* printer status register */
36: Qpsr= 0x1,
37: Fbusy= 0x80,
38: Fintbar= 0x40,
39: /* printer control register */
40: Qpcr= 0x2,
41: Fie= 0x10,
42: Fsi= 0x08,
43: Finitbar= 0x04,
44: Faf= 0x02,
45: Fstrobe= 0x01,
46:
47: /* other `registers' */
48: Qstats= 0x03,
49: Qdebug= 0x04
50: };
51:
52: /*
53: * af si dlr<7:0>
54: * 0 x xxxxxxxx wr ctl/data char (si is dcto)
55: * 1 0 xxxxxxxx wr cmd
56: * 1 1 xxxxxx00 rd ctl/data char
57: * 1 1 xxxxxx01 rd status
58: * 1 1 xxxxxx11 nop (multiplexer to normal state)
59: *
60: * psr<7:3> multiplexed as follows:
61: *
62: * bc7 bc6 bc5 bc4 bc3
63: * rd, st- low bsy d8 d7 d6 d5
64: * rd, st- high d4 d3 d2 d1 d0
65: * other bsy int-
66: */
67:
68: typedef struct Incon Incon;
69:
70: #define NOW (MACHP(0)->ticks*MS2HZ)
71:
72: #define DPRINT if(incondebug)kprint
73:
74: static void inconintr(Ureg *ur, void *a);
75:
76: enum {
77: Minstation= 2, /* lowest station # to poll */
78: Maxstation= 15, /* highest station # to poll */
79: Nincon= 1, /* number of incons */
80: Nin= 32, /* Blocks in the input ring */
81: Bsize= 128, /* size of an input ring block */
82: Mfifo= 0xff /* a mask, must be 2^n-1, must be > Nin */
83: };
84:
85: struct Incon {
86: QLock;
87:
88: QLock xmit; /* transmit lock */
89: QLock reslock; /* reset lock */
90: int dev; /* base address of port */
91: int station; /* station number */
92: int state; /* chip state */
93: Rendez r; /* output process */
94: Rendez kr; /* input kernel process */
95: ushort chan; /* current input channel */
96: Queue *rq; /* read queue */
97: int kstarted; /* true if kernel process started */
98:
99: /* input blocks */
100:
101: Block *inb[Nin];
102: ushort wi;
103: ushort ri;
104:
105: /* statistics */
106:
107: ulong overflow; /* overflow errors */
108: ulong pack0; /* channel 0 */
109: ulong crc; /* crc errors */
110: ulong in; /* bytes in */
111: ulong out; /* bytes out */
112: ulong wait; /* wait time in milliseconds */
113: };
114:
115: Incon incon[Nincon];
116:
117: /*
118: * chip state
119: */
120: enum {
121: Selecting,
122: Selected,
123: Notliving,
124: };
125:
126: /*
127: * internal chip registers
128: */
129: #define sel_polln 0
130: #define sel_station 1
131: #define sel_poll0 2
132: #define sel_rcv_cnt 3
133: #define sel_rcv_tim 4
134: #define sel_tx_cnt 5
135:
136: /*
137: * CSR bits
138: */
139: #define INCON_RUN 0x80
140: #define INCON_STOP 0x00
141: #define ENABLE_IRQ 0x40
142: #define ENABLE_TX_IRQ 0x20
143: #define INCON_ALIVE 0x80
144: #define TX_FULL 0x10
145: #define TX_EMPTY 0x08
146: #define RCV_EMPTY 0x04
147: #define OVERFLOW 0x02
148: #define CRC_ERROR 0x01
149:
150: /*
151: * polling constants
152: */
153: #define HT_GNOT 0x30
154: #define HT_UNIX 0x31
155: #define ST_UNIX 0x04
156: #define NCHAN 64
157:
158: static void inconkproc(void*);
159:
160: /*
161: * incon stream module definition
162: */
163: static void inconoput(Queue*, Block*);
164: static void inconstopen(Queue*, Stream*);
165: static void inconstclose(Queue*);
166: Qinfo inconinfo =
167: {
168: nullput,
169: inconoput,
170: inconstopen,
171: inconstclose,
172: "incon"
173: };
174:
175: int incondebug = 0;
176:
177: Dirtab incondir[]={
178: "dlr", {Qdlr}, 1, 0666,
179: "psr", {Qpsr}, 5, 0444,
180: "pcr", {Qpcr}, 0, 0666,
181: "stats", {Qstats}, 0, 0444,
182: "debug", {Qdebug}, 0, 0666,
183: };
184: #define NINCON (sizeof incondir/sizeof incondir[0])
185:
186: static void
187: nop(void)
188: {
189: }
190:
191: static int
192: slowinb(int x)
193: {
194: nop();
195: nop();
196: return inb(x);
197: }
198:
199: static void
200: reset(int dev) /* hardware reset */
201: {
202: outb(dev+Qpcr, Finitbar);
203: outb(dev+Qpcr, 0);
204: outb(dev+Qpcr, Finitbar);
205: }
206:
207: static void
208: wrctl(int dev, int data) /* write control character */
209: {
210: outb(dev+Qpcr, Finitbar); /* no interrupts, please */
211: outb(dev+Qdlr, data);
212: outb(dev+Qpcr, Finitbar|Fstrobe);
213: outb(dev+Qpcr, Finitbar|Fie);
214: }
215:
216: static void
217: wrdata(int dev, int data) /* write data character */
218: {
219: outb(dev+Qpcr, Finitbar|Fsi);
220: outb(dev+Qdlr, data);
221: outb(dev+Qpcr, Finitbar|Fsi|Fstrobe);
222: outb(dev+Qpcr, Finitbar|Fsi|Fie);
223: }
224:
225: static void
226: wrcmd(int dev, int data) /* write command */
227: {
228: outb(dev+Qpcr, Finitbar|Faf);
229: outb(dev+Qdlr, data);
230: outb(dev+Qpcr, Finitbar|Faf|Fstrobe);
231: outb(dev+Qpcr, Finitbar|Faf|Fie);
232: }
233:
234: static int
235: rdstatus(Incon *ip) /* read status */
236: {
237: int dev, data;
238:
239: dev = ip->dev;
240:
241: outb(dev+Qpcr, Finitbar|Faf|Fsi);
242: outb(dev+Qdlr, 0x01);
243: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
244: data = (inb(dev+Qpsr)&0xf8)<<2;
245: outb(dev+Qpcr, Finitbar|Faf|Fsi);
246: data |= inb(dev+Qpsr)>>3;
247: if(data&(OVERFLOW|CRC_ERROR)){
248: if(data&OVERFLOW)
249: ip->overflow++;
250: if(data&CRC_ERROR)
251: ip->crc++;
252: }
253: outb(dev+Qdlr, 0x03);
254: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
255: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fie);
256:
257: return data;
258: }
259:
260: static void
261: iwrcmd(int dev, int data) /* write command at interrupt level */
262: {
263: outb(dev+Qdlr, data);
264: outb(dev+Qpcr, Finitbar|Faf|Fstrobe);
265: outb(dev+Qpcr, Finitbar|Faf);
266: }
267:
268: static int
269: irdstatus(Incon *ip) /* read status at interrupt level */
270: {
271: int dev, data;
272:
273: dev = ip->dev;
274:
275: outb(dev+Qdlr, 0x01);
276: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
277: data = (slowinb(dev+Qpsr)&0xf8)<<2;
278: outb(dev+Qpcr, Finitbar|Faf|Fsi);
279: data |= slowinb(dev+Qpsr)>>3;
280: if(data&(OVERFLOW|CRC_ERROR)){
281: if(data&OVERFLOW)
282: ip->overflow++;
283: if(data&CRC_ERROR)
284: ip->crc++;
285: }
286:
287: return data;
288: }
289:
290: static int
291: irddata(int dev) /* read data at interrupt level */
292: {
293: int data;
294:
295: outb(dev+Qdlr, 0x00);
296: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
297: data = (slowinb(dev+Qpsr)&0xf8)<<2;
298: outb(dev+Qpcr, Finitbar|Faf|Fsi);
299: data |= slowinb(dev+Qpsr)>>3;
300:
301: return data;
302: }
303:
304: static int
305: irdnext(int dev) /* read next data at interrupt level */
306: {
307: int data;
308:
309: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
310: data = (inb(dev+Qpsr)&0xf8)<<2;
311: outb(dev+Qpcr, Finitbar|Faf|Fsi);
312: data |= inb(dev+Qpsr)>>3;
313:
314: return data;
315: }
316:
317: static void
318: irdnop(int dev, int pcr) /* read nop (mux reset) */
319: {
320: outb(dev+Qdlr, 0x03);
321: outb(dev+Qpcr, Finitbar|Faf|Fsi|Fstrobe);
322: outb(dev+Qpcr, pcr);
323: }
324:
325: int Irdnext(int);
326: #define irdnext Irdnext
327: /**/
328:
329: /*
330: * set the incon parameters
331: */
332: void
333: inconset(Incon *ip, int cnt, int del)
334: {
335: int dev;
336:
337: if (cnt<1 || cnt>14 || del<1 || del>15)
338: error(Ebadarg);
339:
340: dev = ip->dev;
341: wrcmd(dev, sel_rcv_cnt | INCON_RUN);
342: wrdata(dev, cnt);
343: wrcmd(dev, sel_rcv_tim | INCON_RUN);
344: wrdata(dev, del);
345: wrcmd(dev, INCON_RUN | ENABLE_IRQ);
346: }
347:
348: /*
349: * parse a set request
350: */
351: void
352: inconsetctl(Incon *ip, Block *bp)
353: {
354: char *field[3];
355: int n;
356: int del;
357: int cnt;
358:
359: del = 15;
360: n = getfields((char *)bp->rptr, field, 3, " ");
361: switch(n){
362: default:
363: freeb(bp);
364: error(Ebadarg);
365: case 2:
366: del = strtol(field[1], 0, 0);
367: if(del<0 || del>15){
368: freeb(bp);
369: error(Ebadarg);
370: }
371: /* fall through */
372: case 1:
373: cnt = strtol(field[0], 0, 0);
374: if(cnt<0 || cnt>15){
375: freeb(bp);
376: error(Ebadarg);
377: }
378: }
379: inconset(ip, cnt, del);
380: freeb(bp);
381: }
382:
383: /*
384: * poll for a station number
385: */
386: void
387: inconpoll(Incon *ip, int station)
388: {
389: ulong timer;
390: int dev;
391: char *p;
392:
393: dev = ip->dev;
394:
395: /*
396: * get us to a known state
397: */
398: ip->state = Notliving;
399: wrcmd(dev, INCON_STOP);
400:
401: /*
402: * try a station number
403: */
404: wrcmd(dev, sel_station);
405: wrdata(dev, station);
406: wrcmd(dev, sel_poll0);
407: wrdata(dev, HT_GNOT);
408: wrcmd(dev, sel_rcv_cnt);
409: wrdata(dev, 3);
410: wrcmd(dev, sel_rcv_tim);
411: wrdata(dev, 15);
412: wrcmd(dev, sel_tx_cnt);
413: wrdata(dev, 1);
414: wrcmd(dev, sel_polln);
415: wrdata(dev, 0x00);
416: wrdata(dev, ST_UNIX);
417: wrdata(dev, NCHAN);
418: for(p = "gnot"; *p; p++)
419: wrdata(dev, *p);
420: wrctl(dev, 0);
421:
422: /*
423: * poll and wait for ready (or 1/4 second)
424: */
425: ip->state = Selecting;
426: wrcmd(dev, INCON_RUN | ENABLE_IRQ);
427: timer = NOW + 250;
428: while (NOW < timer) {
429: nop();
430: if(rdstatus(ip) & INCON_ALIVE){
431: ip->station = station;
432: ip->state = Selected;
433: break;
434: }
435: }
436: }
437:
438: /*
439: * reset the chip and find a new station number
440: */
441: void
442: inconrestart(Incon *ip)
443: {
444: int i;
445:
446: if(!canqlock(&ip->reslock))
447: return;
448:
449: /*
450: * poll for incon station numbers
451: */
452: DPRINT("inconrestart\n");
453: for(i = Minstation; i <= Maxstation; i++){
454: inconpoll(ip, i);
455: if(ip->state == Selected)
456: break;
457: }
458: switch(ip->state) {
459: case Selecting:
460: DPRINT("incon[%d] not polled\n", ip-incon);
461: print("incon[%d] not polled\n", ip-incon);
462: break;
463: case Selected:
464: DPRINT("incon[%d] station %d\n", ip-incon, ip->station);
465: print("incon[%d] station %d\n", ip-incon, ip->station);
466: inconset(ip, 3, 15);
467: break;
468: default:
469: DPRINT("incon[%d] bollixed\n", ip-incon);
470: print("incon[%d] bollixed\n", ip-incon);
471: break;
472: }
473: qunlock(&ip->reslock);
474: }
475:
476: /*
477: * reset all incon chips.
478: */
479:
480: void
481: inconreset(void)
482: {
483: int i;
484: char *p;
485:
486: /*
487: * get incondev from p9rc
488: */
489: p = getconf("incondev");
490: if(p)
491: incondev = atoi(p);
492:
493: /*
494: * state is Selected if we used incon as the boot device
495: * i.e. we've already got a station number.
496: * state is Selecting if this is a first-time open.
497: */
498: /* inconset(&incon[0], 3, 15); /**/
499: for(i=0; i<Nincon; i++){
500: incon[i].dev = lptinfo[incondev].base;
501: incon[i].state = Notliving;
502: reset(incon[i].dev);
503: incon[i].ri = incon[i].wi = 0;
504: }
505: incon[0].state = Selecting;
506: wrcmd(incon[0].dev, INCON_STOP);
507: }
508:
509: void
510: inconinit(void)
511: {
512: wrcmd(incon[0].dev, INCON_STOP);
513: }
514:
515: /*
516: * enable the device for interrupts, spec is the device number
517: */
518: Chan*
519: inconattach(char *spec)
520: {
521: Incon *ip;
522: int i;
523: Chan *c;
524:
525: setvec(lptinfo[incondev].ivec, inconintr, 0);
526: i = strtoul(spec, 0, 0);
527: if(i >= Nincon)
528: error(Ebadarg);
529: ip = &incon[i];
530: rdstatus(ip);
531: if(ip->state != Selected)
532: inconrestart(ip);
533:
534: c = devattach('i', spec);
535: c->dev = i;
536: c->qid.path = CHDIR;
537: c->qid.vers = 0;
538: return c;
539: }
540:
541: Chan*
542: inconclone(Chan *c, Chan *nc)
543: {
544: return devclone(c, nc);
545: }
546:
547: int
548: inconwalk(Chan *c, char *name)
549: {
550: return devwalk(c, name, incondir, NINCON, streamgen);
551: }
552:
553: void
554: inconstat(Chan *c, char *dp)
555: {
556: devstat(c, dp, incondir, NINCON, streamgen);
557: }
558:
559: Chan*
560: inconopen(Chan *c, int omode)
561: {
562: if(c->qid.path != CHDIR && c->qid.path >= Slowqid)
563: streamopen(c, &inconinfo);
564: c->mode = openmode(omode);
565: c->flag |= COPEN;
566: c->offset = 0;
567: return c;
568: }
569:
570: void
571: inconcreate(Chan *c, char *name, int omode, ulong perm)
572: {
573: USED(c, name, omode, perm);
574: error(Eperm);
575: }
576:
577: void
578: inconclose(Chan *c)
579: {
580: if(c->qid.path != CHDIR && c->qid.path >= Slowqid)
581: streamclose(c);
582: }
583:
584: long
585: inconread(Chan *c, void *buf, long n, ulong offset)
586: {
587: char b[256];
588: Incon *ip;
589:
590: if(c->qid.path == CHDIR)
591: return devdirread(c, buf, n, incondir, NINCON, streamgen);
592: ip = &incon[c->dev];
593: switch(c->qid.path){
594: default:
595: return streamread(c, buf, n);
596: case Qdlr:
597: case Qpsr:
598: case Qpcr:
599: sprint(b, "0x%2.2ux\n", inb(ip->dev + c->qid.path));
600: break;
601: case Qstats:
602: sprint(b, "state: %d\nstation: %d\nin: %d\nout: %d\noverflow: %d\ncrc: %d\nwait: %d\n",
603: ip->state, ip->station, ip->in, ip->out, ip->overflow, ip->crc, ip->wait);
604: break;
605: case Qdebug:
606: sprint(b, "%d\n", incondebug);
607: break;
608: }
609: return readstr(offset, buf, n, b);
610: }
611:
612: long
613: inconwrite(Chan *c, void *buf, long n, ulong offset)
614: {
615: char b[8];
616: Incon *ip;
617: int data;
618:
619: USED(offset);
620: switch(c->qid.path){
621: default:
622: return streamwrite(c, buf, n, 0);
623: case Qdlr:
624: case Qpcr:
625: case Qdebug:
626: break;
627: }
628: if(n > sizeof b-1)
629: n = sizeof b-1;
630: memmove(b, buf, n);
631: b[n] = 0;
632: data = strtoul(b, 0, 0);
633: switch(c->qid.path){
634: default:
635: ip = &incon[c->dev];
636: outb(ip->dev + c->qid.path, data);
637: break;
638: case Qdebug:
639: incondebug = data;
640: break;
641: }
642: return n;
643: }
644:
645: void
646: inconremove(Chan *c)
647: {
648: USED(c);
649: error(Eperm);
650: }
651:
652: void
653: inconwstat(Chan *c, char *dp)
654: {
655: USED(c, dp);
656: error(Eperm);
657: }
658:
659: /*
660: * the stream routines
661: */
662:
663: /*
664: * kill off the kernel process
665: */
666: static int
667: kNotliving(void *arg)
668: {
669: Incon *ip;
670:
671: ip = (Incon *)arg;
672: return ip->kstarted == 0;
673: }
674:
675: static void
676: inconstclose(Queue * q)
677: {
678: Incon *ip;
679:
680: ip = (Incon *)q->ptr;
681: qlock(ip);
682: ip->rq = 0;
683: qunlock(ip);
684: wakeup(&ip->kr);
685: sleep(&ip->r, kNotliving, ip);
686: }
687:
688: /*
689: * create the kernel process for input
690: * first wait for any old ones to die
691: */
692: static void
693: inconstopen(Queue *q, Stream *s)
694: {
695: Incon *ip;
696: char name[32];
697:
698: ip = &incon[s->dev];
699: sprint(name, "incon%d", s->dev);
700: q->ptr = q->other->ptr = ip;
701: wakeup(&ip->kr);
702: sleep(&ip->r, kNotliving, ip);
703: ip->rq = q;
704: kproc(name, inconkproc, ip);
705: }
706:
707: /*
708: * free all blocks of a message in `q', `bp' is the first block
709: * of the message
710: */
711: static void
712: freemsg(Queue *q, Block *bp)
713: {
714: for(; bp; bp = getq(q)){
715: if(bp->flags & S_DELIM){
716: freeb(bp);
717: return;
718: }
719: freeb(bp);
720: }
721: }
722:
723: static void
724: showpkt(char *str, int chan, int ctl, Block *bp, int i)
725: {
726: int n;
727:
728: n = bp->wptr - bp->rptr;
729: kprint("%s(%d)%uo %d", str, chan, ctl, n);
730: if(n > 8)
731: n = 8;
732: for(; i<n; i++)
733: kprint(" %2.2ux", bp->rptr[i]);
734: kprint("\n");
735: }
736:
737: /*
738: * output a block
739: *
740: * the first 2 bytes of every message are the channel number,
741: * low order byte first. the third is a possible trailing control
742: * character.
743: */
744: void
745: inconoput(Queue *q, Block *bp)
746: {
747: int dev;
748: Incon *ip;
749: ulong end;
750: int status, chan, ctl;
751: int n, size;
752:
753: ip = (Incon *)q->ptr;
754:
755: if(bp->type != M_DATA){
756: if(streamparse("inconset", bp))
757: inconsetctl(ip, bp);
758: else
759: freeb(bp);
760: return;
761: }
762: if(BLEN(bp) < 3){
763: bp = pullup(bp, 3);
764: if(bp == 0){
765: print("inconoput pullup failed\n");
766: return;
767: }
768: }
769:
770: /*
771: * get a whole message before handing bytes to the device
772: */
773: if(!putq(q, bp))
774: return;
775:
776: /*
777: * one transmitter at a time
778: */
779: qlock(&ip->xmit);
780: dev = ip->dev;
781:
782: /*
783: * parse message
784: */
785: bp = getq(q);
786: chan = bp->rptr[0] | (bp->rptr[1]<<8);
787: ctl = bp->rptr[2];
788: bp->rptr += 3;
789: if(chan<=0)
790: print("bad channel %d\n", chan);
791:
792: if(incondebug){
793: kprint("0x%.2ux ", rdstatus(ip));
794: showpkt("->", chan, ctl, bp, 0);
795: }
796:
797: /*
798: * make sure there's an incon out there
799: */
800: if(!(rdstatus(ip)&INCON_ALIVE) || ip->state==Notliving){
801: DPRINT("inconoput: not ready");
802: inconrestart(ip);
803: freemsg(q, bp);
804: qunlock(&ip->xmit);
805: return;
806: }
807:
808: /*
809: * send the 8 bit data
810: */
811: for(;;){
812: /*
813: * spin till there is room
814: */
815: for(n=0, end = NOW+1000; (status=rdstatus(ip)) & TX_FULL; n++){
816: nop(); /* make sure we don't optimize too much */
817: if(NOW > end){
818: print("incon output stuck 0 %.2ux\n", status);
819: freemsg(q, bp);
820: qunlock(&ip->xmit);
821: return;
822: }
823: }
824: ip->wait = (n + ip->wait)>>1;
825:
826: /*
827: * put in next packet
828: */
829: n = bp->wptr - bp->rptr;
830: if(n > 16)
831: n = 16;
832: size = n;
833: wrctl(dev, chan);
834: ip->out += n;
835: while(n--){
836: wrdata(dev, *bp->rptr++);
837: }
838:
839: /*
840: * get next block
841: */
842: if(bp->rptr >= bp->wptr){
843: if(bp->flags & S_DELIM){
844: freeb(bp);
845: break;
846: }
847: freeb(bp);
848: bp = getq(q);
849: if(bp==0)
850: break;
851: }
852:
853: /*
854: * end packet
855: */
856: wrctl(dev, 0);
857: }
858:
859: /*
860: * send the control byte if there is one
861: */
862: if(ctl){
863: if(size >= 16){
864: wrctl(dev, 0);
865: for(end = NOW+1000; rdstatus(ip) & TX_FULL;){
866: nop(); /* make sure we don't optimize too much */
867: if(NOW > end){
868: print("incon output stuck 1\n");
869: freemsg(q, bp);
870: qunlock(&ip->xmit);
871: return;
872: }
873: }
874: wrctl(dev, chan);
875: }
876: if(rdstatus(ip) & TX_FULL)
877: print("inconfull\n");
878: ip->out += 1;
879: wrctl(dev, ctl);
880: }
881: wrctl(dev, 0);
882:
883: qunlock(&ip->xmit);
884: return;
885: }
886:
887: /*
888: * return true if the raw fifo is non-empty
889: */
890: static int
891: notempty(void *arg)
892: {
893: Incon *ip;
894:
895: ip = (Incon *)arg;
896: return ip->ri!=ip->wi;
897: }
898:
899: /*
900: * Read bytes from the raw input circular buffer.
901: */
902: static void
903: inconkproc(void *arg)
904: {
905: Incon *ip;
906: Block *bp;
907: int i;
908: int locked;
909:
910: ip = (Incon *)arg;
911: ip->kstarted = 1;
912:
913: /*
914: * create a number of blocks for input
915: */
916: for(i = 0; i < Nin; i++){
917: bp = ip->inb[i] = allocb(Bsize);
918: bp->wptr += 3;
919: }
920:
921: locked = 0;
922: if(waserror()){
923: if(locked)
924: qunlock(ip);
925: ip->kstarted = 0;
926: wakeup(&ip->r);
927: return;
928: }
929:
930: for(;;){
931: /*
932: * sleep if input fifo empty
933: */
934: sleep(&ip->kr, notempty, ip);
935:
936: /*
937: * die if the device is closed
938: */
939: USED(locked);
940: qlock(ip);
941: locked = 1;
942: if(ip->rq == 0){
943: qunlock(ip);
944: ip->kstarted = 0;
945: wakeup(&ip->r);
946: poperror();
947: return;
948: }
949:
950: /*
951: * send blocks upstream and stage new blocks.
952: */
953: while(ip->ri != ip->wi){
954: bp = ip->inb[ip->ri];
955: bp->flags |= S_DELIM;
956: ip->in += BLEN(bp);
957: PUTNEXT(ip->rq, bp);
958: bp = ip->inb[ip->ri] = allocb(Bsize);
959: bp->wptr += 3;
960: ip->ri = (ip->ri+1)%Nin;
961: }
962: USED(locked);
963: qunlock(ip);
964: locked = 0;
965: }
966: }
967:
968: /*
969: * drop a single packet
970: */
971: static void
972: droppacket(int dev)
973: {
974: if(irddata(dev) == 0)
975: return;
976: while(irdnext(dev))
977: ;
978: }
979:
980: /*
981: * flush the input fifo
982: */
983: static void
984: flushfifo(Incon *ip)
985: {
986: while(!(irdstatus(ip) & RCV_EMPTY))
987: droppacket(ip->dev);
988: }
989:
990: /*
991: * advance the queue. if we've run out of staged input blocks,
992: * drop the packet and return 0. otherwise return the next input
993: * block to fill.
994: */
995: static Block *
996: nextin(Incon *ip, unsigned int c)
997: {
998: Block *bp;
999: int next;
1000:
1001: bp = ip->inb[ip->wi];
1002: bp->rptr[0] = ip->chan;
1003: bp->rptr[1] = ip->chan>>8;
1004: bp->rptr[2] = c;
1005: if(incondebug)
1006: showpkt("<-", ip->chan, c, bp, 3);
1007:
1008: next = (ip->wi+1)%Nin;
1009: if(next == ip->ri){
1010: bp->wptr = bp->rptr+3;
1011: return bp;
1012: }
1013: ip->wi = next;
1014:
1015: return ip->inb[ip->wi];
1016: }
1017:
1018: /*
1019: * read the packets from the device into the staged input blocks.
1020: * we have to do this at interrupt tevel to turn off the interrupts.
1021: */
1022: static void
1023: rdpackets(Incon *ip)
1024: {
1025: Block *bp;
1026: unsigned int c;
1027: int dev;
1028: uchar *p;
1029: int first = ip->wi;
1030:
1031: dev = ip->dev;
1032: bp = ip->inb[ip->wi];
1033: if(bp==0){
1034: flushfifo(ip);
1035: return;
1036: }
1037: p = bp->wptr;
1038: while(!(irdstatus(ip) & RCV_EMPTY)){
1039: /*
1040: * get channel number
1041: */
1042: c = irddata(dev);
1043: if(c == 0){
1044: droppacket(dev);
1045: continue;
1046: }
1047: if(ip->chan != c){
1048: if(p - bp->rptr > 3){
1049: bp->wptr = p;
1050: bp = nextin(ip, 0);
1051: p = bp->wptr;
1052: }
1053: ip->chan = c;
1054: }
1055:
1056: /*
1057: * null byte marks end of packet
1058: */
1059: while(c = irdnext(dev)){ /* assign = */
1060: if((c & 0x100) == 0){
1061: /*
1062: * control byte ends block
1063: */
1064: bp->wptr = p;
1065: bp = nextin(ip, c);
1066: p = bp->wptr;
1067: }else{
1068: /*
1069: * data byte, put in local buffer
1070: */
1071: *p++ = c;
1072: }
1073: }
1074:
1075: /*
1076: * pass a block on if it doesn't have room for one more
1077: * packet. this way we don't have to check per byte.
1078: */
1079: if(p + 16 > bp->lim){
1080: bp->wptr = p;
1081: bp = nextin(ip, 0);
1082: p = bp->wptr;
1083: }
1084: }
1085: bp->wptr = p;
1086: if(bp->wptr != bp->rptr+3)
1087: nextin(ip, 0);
1088:
1089: if(first != ip->wi)/**/
1090: wakeup(&ip->kr);
1091: }
1092:
1093: /*
1094: * Receive an incon interrupt. One entry point
1095: * for all types of interrupt. Until we figure out
1096: * how to use more than one incon, this routine only
1097: * is for incon[0].
1098: */
1099: static void
1100: inconintr(Ureg *ur, void *a)
1101: {
1102: uchar status;
1103: int pcr;
1104: Incon *ip;
1105:
1106: USED(ur, a);
1107: ip = &incon[0];
1108: pcr = inb(ip->dev+Qpcr);
1109: if(!(pcr & Fie))
1110: return;
1111: status = irdstatus(ip);
1112: if(incondebug){
1113: kprint("pcr=%2.2x status=%2.2x\n", pcr, status);
1114: if(pcr & Fstrobe)
1115: kprint("YIKES!!\n");
1116: }
1117: if(!(status & RCV_EMPTY))
1118: rdpackets(ip);
1119:
1120: /* see if it died underneath us */
1121: if(!(status&INCON_ALIVE)){
1122: switch(ip->state){
1123: case Selected:
1124: iwrcmd(ip->dev, INCON_STOP);
1125: DPRINT("Incon died\n");
1126: print("Incon died\n");
1127: break;
1128: case Selecting:
1129: DPRINT("rejected\n");
1130: print("rejected\n");
1131: break;
1132: default:
1133: iwrcmd(ip->dev, INCON_STOP);
1134: DPRINT("state was %d\n", ip->state);
1135: break;
1136: }
1137: ip->state = Notliving;
1138: }
1139: irdnop(ip->dev, pcr);
1140: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.