![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nkb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io|
Return to nkb.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io |
1.1 root 1: /*
2: * User configurable AT keyboard/display driver.
3: * 286/386 AT COHERENT
4: */
5: #include <sys/coherent.h>
6: #include <sys/i8086.h>
7: #include <sys/con.h>
8: #include <errno.h>
9: #include <sys/stat.h>
10: #include <sys/tty.h>
11: #include <sys/uproc.h>
12: #include <signal.h>
13: #include <sys/seg.h>
14: #include <sys/sched.h>
15: #include <sys/kb.h>
16: #include <sys/devices.h>
17:
18: #define ISVEC 1 /* Keyboard interrupt vector */
19:
20: #if DEBUG
21: #define KBDEBUG(x) printf(x) /* debugging output */
22: #define KBDEBUG2(x,y) printf(x,y) /* debugging output */
23: #define KBDEBUG3(x,y,z) printf(x,y,z) /* debugging output */
24: #else
25: #define KBDEBUG(x) /* no output */
26: #define KBDEBUG2(x,y) /* no output */
27: #define KBDEBUG3(x,y,z) /* no output */
28: #endif
29:
30: /*
31: * values for kbstate
32: */
33: #define KB_IDLE 0 /* nothing going on right now */
34: #define KB_SINGLE 1 /* sent a single byte cmd to the kbd */
35: #define KB_DOUBLE_1 2 /* sent 1st byte of 2-byte cmd to kbd */
36: #define KB_DOUBLE_2 3 /* sent 2nd byte of 2-byte cmd to kbd */
37:
38: /*
39: * patchable params for non-standard keyboards
40: */
41: int KBDATA = 0x60; /* Keyboard data */
42: int KBCTRL = 0x61; /* Keyboard control */
43: int KBSTS_CMD = 0x64; /* Keyboard status/command */
44: int KBFLAG = 0x80; /* Keyboard reset flag */
45: int KBBOOT = 1; /* 0: disallow reboot from keyboard */
46: int KBTIMEOUT = 10000; /* shouldn't need this much */
47: int KBCMDBYTE = 0x05; /* no translation */
48:
49: /*
50: * KBSTATUS bits
51: */
52: #define STS_OBUF_FULL 0x01 /* kbd output buffer full */
53: #define STS_IBUF_FULL 0x02 /* kbd input buffer full */
54: #define STS_SYSTEM 0x04
55: #define STS_CMD_DATA 0x08 /* 1: command or status */
56: #define STS_INHIBIT 0x10 /* 0: keyboard inhibited */
57: #define STS_AUX_OBUF_FULL 0x20
58: #define STS_TIMEOUT 0x40 /* general timeout */
59: #define STS_PAR_ERR 0x80 /* parity error */
60:
61: /*
62: * The following are magic commands which read from or write to the
63: * controller command byte. These get output to the KBSTS_CMD port.
64: */
65: #define C_READ_CMD 0x20 /* read controller command byte */
66: #define C_WRITE_CMD 0x60 /* write controller command byte */
67: #define C_TRANSLATE 0x40 /* translate enable bit in cmd byte */
68:
69: /*
70: * Globals:
71: * The 286 keyboard mapping table is too large to fit into kernel data space,
72: * so we need to allocate a segment to it. 386 is easy.
73: * The function keys tend to be small and tend to change substantially
74: * more often than the mapping table, so we keep them in the kernel data space.
75: */
76: static unsigned shift; /* state of all shift/lock keys */
77: static unsigned char **funkeyp = 0; /* ptr to array of func. keys ptrs */
78: static FNKEY *fnkeys = 0; /* pointer to structure of values */
79: static unsigned fklength; /* length of k_fnval field in fnkeys */
80: static unsigned prev_cmd; /* previous command sent to KBD */
81: static unsigned cmd2; /* 2nd byte of command to KBD */
82: static unsigned sh_index; /* shift/lock state index */
83: #if COH386
84: static KBTBL kb[MAX_KEYS]; /* keyboard table */
85: #else
86: static SEG *kbsegp; /* keyboard table segment */
87: #endif
88:
89: /*
90: * State variables.
91: */
92: int islock; /* Keyboard locked flag */
93: int isbusy; /* Raw input conversion busy */
94: static char table_loaded; /* true == keyboard table resident */
95: static char fk_loaded; /* true == function keys resident */
96: static int kbstate = KB_IDLE; /* current keyboard state */
97:
98: /*
99: * Functions.
100: */
101: int isrint();
102: int istime();
103: void isbatch();
104: int mmstart();
105: int isopen();
106: int isclose();
107: int isread();
108: int mmwrite();
109: int isioctl();
110: void mmwatch();
111: int isload();
112: int isuload();
113: int ispoll();
114: int nulldev();
115: int nonedev();
116: int updleds();
117:
118: /*
119: * Configuration table.
120: */
121: CON iscon ={
122: DFCHR|DFPOL, /* Flags */
123: KB_MAJOR, /* Major index */
124: isopen, /* Open */
125: isclose, /* Close */
126: nulldev, /* Block */
127: isread, /* Read */
128: mmwrite, /* Write */
129: isioctl, /* Ioctl */
130: nulldev, /* Powerfail */
131: mmwatch, /* Timeout */
132: isload, /* Load */
133: isuload, /* Unload */
134: ispoll /* Poll */
135: };
136:
137: /*
138: * Terminal structure.
139: */
140: TTY istty = {
141: {0}, {0}, 0, mmstart, NULL, 0, 0
142: };
143:
144: /*
145: * Load entry point.
146: */
147: isload()
148: {
149: kbstate = KB_IDLE;
150: table_loaded = 0; /* no keyboard table yet */
151: fk_loaded = 0; /* no Fn keys yet */
152:
153: /*
154: * Enable mmwatch() invocation every second.
155: */
156: drvl[KB_MAJOR].d_time = 1;
157:
158: /*
159: * Seize keyboard interrupt.
160: */
161: setivec(ISVEC, isrint);
162:
163: /*
164: * Initiailize video display.
165: */
166: mmstart( &istty );
167:
168: #if !COH386
169: /*
170: * Allocate a 286 segment to store the in-core keyboard table.
171: * This would be a lot more convenient in kernel data space,
172: * but small model COHERENT doesn't have that luxury.
173: */
174: kbsegp = salloc((fsize_t)MAX_TABLE_SIZE, SFSYST|SFNSWP|SFHIGH);
175: if (kbsegp == (SEG *)0)
176: printf("kb: unable to allocate keyboard table segment\n");
177: #endif
178: fklength = 0;
179: KBDEBUG("Exiting kbload()\n");
180: }
181:
182: /*
183: * Unload entry point.
184: */
185: isuload()
186: {
187: if (kbstate != KB_IDLE)
188: printf("kb: keyboard busy during unload\n");
189: clrivec(ISVEC);
190: #if !COH386
191: if (kbsegp != (SEG *)0) {
192: table_loaded = 0;
193: sfree(kbsegp);
194: }
195: #endif
196: }
197:
198: /*
199: * Open routine.
200: */
201: isopen(dev)
202: dev_t dev;
203: {
204: register int s;
205:
206: KBDEBUG(" kbopen()");
207: if (minor(dev) != 0) {
208: u.u_error = ENXIO;
209: return;
210: }
211: if ((istty.t_flags&T_EXCL) != 0 && !super()) {
212: u.u_error = ENODEV;
213: return;
214: }
215: ttsetgrp(&istty, dev);
216:
217: s = sphi();
218: if (istty.t_open++ == 0) {
219: istty.t_flags = T_CARR; /* indicate "carrier" */
220: ttopen(&istty);
221: }
222: spl(s);
223: #if 0
224: updleds(); /* update keyboard status LEDS */
225: #endif
226: }
227:
228: /*
229: * Close a tty.
230: */
231: isclose(dev)
232: {
233: register int s;
234:
235: s = sphi();
236: if (--istty.t_open == 0) {
237: ttclose(&istty);
238: }
239: spl(s);
240: }
241:
242: /*
243: * Read routine.
244: */
245: isread(dev, iop)
246: dev_t dev;
247: IO *iop;
248: {
249: ttread(&istty, iop, 0);
250: if (istty.t_oq.cq_cc)
251: mmtime(&istty);
252: }
253:
254: /*
255: * Ioctl routine.
256: * nb: archaic TIOCSHIFT and TIOCCSHIFT no longer needed/supported.
257: */
258: isioctl(dev, com, vec)
259: dev_t dev;
260: struct sgttyb *vec;
261: {
262: register int s;
263:
264: switch (com) {
265: case TIOCSETF:
266: case TIOCGETF:
267: isfunction(com, (char *)vec);
268: break;
269: case TIOCSETKBT:
270: issettable(vec);
271: break;
272: case TIOCGETKBT:
273: isgettable(vec);
274: break;
275: default: /* pass to TTY driver */
276: s = sphi();
277: ttioctl(&istty, com, vec);
278: spl(s);
279: break;
280: }
281: }
282:
283: /*
284: * Set the in-core keyboard mapping table.
285: * The table is sorted by scan code prior to calling ioctl().
286: * All unused table entries (holes in the scan code map) have
287: * a zero for the k_key field.
288: * This makes key lookup at interrupt time fast by using the scan code
289: * as an index into the table.
290: */
291: issettable(vec)
292: char *vec;
293: {
294: register unsigned i;
295: register int s;
296: int timeout;
297: static KBTBL this_key; /* current key from kbd table */
298: unsigned int cmd_byte;
299: #if !COH386
300: register faddr_t faddr; /* address of keyboard table */
301: #endif
302:
303: KBDEBUG(" TIOCSETKBT");
304: kb_cmd2(K_SCANCODE_CMD, 3); /* select set 3 */
305: kb_cmd(K_ALL_TMB_CMD); /* default: TMB for all keys */
306: #if !COH386
307: faddr = kbsegp->s_faddr;
308: #endif
309: for (i = 0; i < MAX_KEYS; ++i) {
310: ukcopy(vec, &this_key, sizeof(this_key));
311: #if COH386
312: kb[i] = this_key; /* store away */
313: #else
314: kfcopy(&this_key, faddr, sizeof(this_key));
315: faddr += sizeof(this_key);
316: #endif
317: vec += sizeof(this_key);
318: if (this_key.k_key != i && this_key.k_key != 0) {
319: printf("kb: incorrect or unsorted table entry %d\n", i);
320: u.u_error = EBADFMT;
321: return;
322: }
323: if (this_key.k_key != i)
324: continue; /* no key */
325: switch (this_key.k_flags&TMODE) {
326: case T: /* typematic */
327: kb_cmd2(K_KEY_T_CMD, i);
328: break;
329: case M: /* make only */
330: kb_cmd2(K_KEY_M_CMD, i);
331: break;
332: case MB: /* make/break */
333: kb_cmd2(K_KEY_MB_CMD, i);
334: break;
335: case TMB: /* typematic make/break */
336: break; /* this is the default */
337: default:
338: printf("kb: bad key mode\n");
339: }
340: }
341: updleds();
342: kb_cmd2(K_SCANCODE_CMD, 3); /* select set 3 */
343: kb_cmd(K_ENABLE_CMD); /* start scanning */
344: /*
345: * The following code disables translation from the on-board
346: * keyboard/aux controller. Without disabling translation, the
347: * received scan codes still look like code set 1 codes even
348: * though we put the keyboard controller in scan code set 3.
349: * Yes, this is progress....
350: */
351: #if 0
352: while (inb(KBSTS_CMD) & STS_IBUF_FULL)
353: ;
354: outb(KBSTS_CMD, C_READ_CMD); /* read controller cmd byte */
355: while (!(inb(KBSTS_CMD) & STS_OBUF_FULL))
356: ;
357: cmd_byte = inb(KBDATA);
358: KBDEBUG2(" cmd_byte=%x", cmd_byte);
359: #endif
360: timeout = KBTIMEOUT;
361: s = sphi();
362: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0)
363: ;
364: outb(KBSTS_CMD, C_WRITE_CMD); /* write controller cmd byte */
365: for (timeout = 50; --timeout > 0; )
366: ;
367: timeout = KBTIMEOUT;
368: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0)
369: ;
370: outb(KBDATA, KBCMDBYTE); /* turn off translation */
371: timeout = KBTIMEOUT;
372: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0)
373: ;
374: spl(s);
375: #if DEBUG
376: kb_cmd2(K_SCANCODE_CMD, 0); /* query s.c. mode */
377: #endif
378: ++table_loaded;
379: }
380:
381: /*
382: * Get the in-core keyboard mapping table and pass it to the user.
383: */
384: isgettable(vec)
385: char *vec;
386: {
387: #if COH386
388: KBDEBUG(" TIOCGETKBT");
389: kucopy(kb, vec, sizeof(kb));
390: #else
391: register unsigned i;
392: register faddr_t faddr; /* address of keyboard table */
393: static KBTBL this_key; /* current key from kbd table */
394:
395: KBDEBUG(" TIOCGETKBT");
396: faddr = kbsegp->s_faddr;
397: for (i = 0; i < MAX_KEYS; ++i) {
398: fkcopy( faddr, &this_key, sizeof(this_key));
399: kucopy( &this_key, vec, sizeof(this_key));
400: faddr += sizeof(this_key);
401: vec += sizeof(this_key);
402: }
403: #endif
404: }
405:
406:
407: /*
408: * Set and receive the function keys.
409: */
410: isfunction(c, v)
411: int c;
412: FNKEY *v;
413: {
414: register unsigned char *cp;
415: register unsigned i;
416: unsigned char numkeys = 0;
417:
418: if (c == TIOCGETF) {
419: KBDEBUG(" TIOCGETF");
420: if (!fk_loaded)
421: u.u_error = EINVAL;
422: else
423: kucopy(fnkeys, v, fklength); /* copy ours to user */
424: } else { /* TIOCSETF */
425: /*
426: * If we had a previous function key arena, free it up.
427: * Since we don't know how large the function key arena will
428: * be, we must size it in the user data space prior to
429: * (re)kalloc()'ing it. This is ugly, but a helluva lot better
430: * than the old driver which used a hard coded limit of 150!
431: */
432: KBDEBUG(" TIOCSETF");
433: fk_loaded = 0;
434: if (fnkeys != (FNKEY *)0)
435: kfree(fnkeys); /* free old arena */
436: if (funkeyp != NULL)
437: kfree(funkeyp); /* free old ptr array */
438: ukcopy(&v->k_nfkeys, &numkeys, sizeof(numkeys));
439: fklength = sizeof(FNKEY);
440: cp = v->k_fnval;
441: for (i = 0; i < numkeys; i++) {
442: do {
443: ++fklength;
444: } while (getubd(cp++) != DELIM);
445: }
446: fnkeys = (FNKEY *)kalloc(fklength);
447: funkeyp = (unsigned char **)kalloc(numkeys * sizeof(char *));
448: if (fnkeys == (FNKEY *)0 || funkeyp == NULL) {
449: if (fnkeys != (FNKEY *)0) {
450: kfree(fnkeys);
451: fnkeys = 0;
452: }
453: if (funkeyp != NULL) {
454: kfree(funkeyp);
455: funkeyp = 0;
456: }
457: u.u_error = ENOMEM;
458: return;
459: }
460: cp = fnkeys->k_fnval; /* point to Fn ... */
461: v = v->k_fnval; /* ... key arena */
462: for (i = 0; i < numkeys; i++) {
463: funkeyp[i] = cp; /* save pointer */
464: while ((*cp++ = getubd(v++)) != DELIM) /* copy key */
465: ;
466: }
467: fnkeys->k_nfkeys = numkeys;
468: fk_loaded = 1;
469: }
470: }
471:
472:
473: /*
474: * Poll routine.
475: */
476: ispoll( dev, ev, msec )
477: dev_t dev;
478: int ev;
479: int msec;
480: {
481: /*
482: * Priority polls not supported.
483: */
484: ev &= ~POLLPRI;
485:
486: /*
487: * Input poll failure.
488: */
489: if ( (ev & POLLIN) && (istty.t_iq.cq_cc == 0) ) {
490: if ( msec != 0 )
491: pollopen( &istty.t_ipolls );
492: /*
493: * Second look AFTER enabling monitor, avoiding interrupt race.
494: */
495: if ( istty.t_iq.cq_cc == 0 )
496: ev &= ~POLLIN;
497: }
498: return ev;
499: }
500:
501: /*
502: * Receive interrupt.
503: */
504: isrint()
505: {
506: register unsigned c;
507: register unsigned r;
508: static char keyup;
509:
510: /*
511: * Schedule raw input handler if not already active.
512: */
513: if ( !isbusy ) {
514: defer( isbatch, &istty );
515: isbusy = 1;
516: }
517:
518: /*
519: * Pull character from the data
520: * port. Pulse the KBFLAG in the control
521: * port to reset the data buffer.
522: */
523: r = inb(KBDATA) & 0xFF;
524: c = inb(KBCTRL);
525: outb(KBCTRL, c|KBFLAG);
526: outb(KBCTRL, c);
527:
528: /*
529: * check returned value from keyboard to see if it's a command
530: * or status back to us. If not, it we assume that it's a key code.
531: */
532: KBDEBUG2(" intr(%x)", r);
533: switch (r) {
534: case K_BREAK:
535: keyup = 1; /* key going up */
536: break;
537: case K_ECHO_R:
538: case K_BAT_OK:
539: break; /* very nice, but ignored */
540: case K_BAT_BAD:
541: printf("kb: keyboard BAT failed\n");
542: break;
543: case K_RESEND:
544: KBDEBUG("\nkb: request to resend command\n");
545: outb(KBDATA, prev_cmd);
546: break;
547: case K_OVERRUN_23:
548: printf("kb: keyboard buffer overrun\n");
549: break;
550: case K_ACK:
551: /*
552: * we received an ACKnowledgement from the keyboard.
553: * advance the state machine and continue.
554: */
555: KBDEBUG(" ACK");
556: switch (kbstate) {
557: case KB_IDLE: /* shouldn't happen */
558: printf("kb: ACK while keyboard idle\n");
559: break;
560: case KB_SINGLE: /* done with 1-byte command */
561: case KB_DOUBLE_2: /* done w/ 2nd of 2-byte cmd */
562: kbstate = KB_IDLE;
563: wakeup(&kbstate);
564: break;
565: case KB_DOUBLE_1:
566: kbstate = KB_DOUBLE_2;
567: outb(KBDATA, cmd2);
568: break;
569: default:
570: printf("kb: bad kbstate %d\n", kbstate);
571: break;
572: }
573: break;
574: default:
575: process_key(r, keyup);
576: keyup = 0;
577: }
578: }
579:
580: /*
581: * Process a key given its scan code and direction.
582: *
583: * In this table driven version of the keyboard driver, we trade off the
584: * code complexity associated with all the black magic that used to be
585: * performed on a per-key basis with the increased memory requirements
586: * associated with the table driven approach.
587: */
588: process_key( key, up)
589: unsigned key;
590: int up;
591: {
592: register unsigned char *cp;
593: KBTBL key_vals; /* table values for this key */
594: unsigned val;
595: unsigned char flags;
596:
597: KBDEBUG3(" proc(%x %s)", key, (up ? "up" : "down"));
598: if (!table_loaded)
599: return; /* throw away key */
600: #if COH386
601: key_vals = kb[key];
602: #else
603: fkcopy( kbsegp->s_faddr + (key * sizeof(KBTBL)),
604: &key_vals, sizeof(key_vals));
605: #endif
606: if (key_vals.k_key != key) /* empty entry */
607: return;
608: flags = key_vals.k_flags;
609:
610: if (flags & S) { /* some shift/lock key ? */
611: switch (key_vals.k_val[BASE]) {
612: case caps:
613: case num:
614: if (!up) {
615: shift ^= (1 << key_vals.k_val[BASE]);
616: updleds2();
617: }
618: break;
619: case scroll:
620: if (!up) {
621: shift ^= (1 << key_vals.k_val[BASE]);
622: updleds2();
623: if (!(istty.t_sgttyb.sg_flags&RAWIN)) {
624: if (istty.t_flags & T_STOP) {
625: isin(istty.t_tchars.t_startc);
626: } else {
627: isin(istty.t_tchars.t_stopc);
628: }
629: }
630: }
631: break;
632: default:
633: if (up)
634: shift &= ~(1 << key_vals.k_val[BASE]);
635: else
636: shift |= (1 << key_vals.k_val[BASE]);
637: break;
638: }
639: /*
640: * Calculate the shift index based upon the state of
641: * the shift and lock keys.
642: */
643: sh_index = BASE; /* default condition */
644: if (shift & (1 << altgr))
645: sh_index = ALT_GR;
646: else {
647: if (shift & ((1 << lalt)|(1 << ralt)))
648: sh_index |= ALT;
649: if (shift & ((1 << lctrl)|(1 << rctrl)))
650: sh_index |= CTRL;
651: if (shift & ((1 << lshift)|(1 << rshift)))
652: sh_index |= SHIFT;
653: }
654: return;
655: } /* if (flags & S) */
656:
657: /*
658: * If the tty is not open or the key has no value in the current
659: * shift state, the key is just tossed away.
660: */
661: if (up || !istty.t_open || key_vals.k_val[sh_index] == none)
662: return;
663: if (((flags & C) && (shift & (1 << caps)))
664: || ((flags & N) && (shift & (1 << num))))
665: val = key_vals.k_val[sh_index^SHIFT];
666: else
667: val = key_vals.k_val[sh_index];
668:
669: /*
670: * Check for function key or special key implemented as
671: * a function key (reboot == f0, tab and back-tab, etc).
672: */
673: if (flags & F) {
674: if (val == 0 && !up && KBBOOT)
675: boot();
676: if (!fk_loaded || val >= fnkeys->k_nfkeys)
677: return;
678: if ((cp = funkeyp[val]) == NULL) /* has a value? */
679: return;
680: while (*cp != DELIM)
681: isin(*cp++); /* queue up Fn key value */
682: return;
683: }
684:
685: /*
686: * Normal key processing.
687: */
688: isin(val); /* send the char */
689: return;
690: }
691:
692: /**
693: *
694: * void
695: * ismmfunc( c ) -- process keyboard related output escape sequences
696: * char c;
697: */
698: void
699: ismmfunc(c)
700: register int c;
701: {
702: switch (c) {
703: case 't': /* Enter numlock */
704: shift |= (1 << num);
705: updleds(); /* update LED status */
706: break;
707: case 'u': /* Leave numlock */
708: shift &= ~(1 << num);
709: updleds(); /* update LED status */
710: break;
711: case '=': /* Enter alternate keypad -- ignored */
712: case '>': /* Exit alternate keypad -- ignored */
713: break;
714: case 'c': /* Reset terminal */
715: islock = 0;
716: break;
717: }
718: }
719:
720: /**
721: *
722: * void
723: * isin( c ) -- append character to raw input silo
724: * char c;
725: */
726: static
727: isin( c )
728: register int c;
729: {
730: int cache_it = 1;
731: TTY * tp = &istty;
732:
733: /*
734: * If using software incoming flow control, process and
735: * discard t_stopc and t_startc.
736: */
737: if (!ISRIN) {
738: if (ISSTOP) {
739: if ((tp->t_flags&T_STOP) == 0)
740: tp->t_flags |= T_STOP;
741: cache_it = 0;
742: }
743: if (ISSTART) {
744: tp->t_flags &= ~T_STOP;
745: ttstart(tp);
746: cache_it = 0;
747: }
748: }
749:
750: /*
751: * Cache received character.
752: */
753: if (cache_it) {
754: istty.t_rawin.si_buf[ istty.t_rawin.si_ix ] = c;
755:
756: if ( ++istty.t_rawin.si_ix >= sizeof(istty.t_rawin.si_buf) )
757: istty.t_rawin.si_ix = 0;
758: }
759: }
760:
761: /**
762: *
763: * void
764: * isbatch() -- raw input conversion routine
765: *
766: * Action: Enable the video display.
767: * Canonize the raw input silo.
768: *
769: * Notes: isbatch() was scheduled as a deferred process by isrint().
770: */
771: static void
772: isbatch( tp )
773: register TTY * tp;
774: {
775: register int c;
776: static int lastc;
777:
778: /*
779: * Ensure video display is enabled.
780: */
781: mm_von();
782: isbusy = 0;
783:
784: /*
785: * Process all cached characters.
786: */
787: while ( tp->t_rawin.si_ix != tp->t_rawin.si_ox ) {
788: /*
789: * Get next cached char.
790: */
791: c = tp->t_rawin.si_buf[ tp->t_rawin.si_ox ];
792:
793: if ( tp->t_rawin.si_ox >= sizeof(tp->t_rawin.si_buf) - 1 )
794: tp->t_rawin.si_ox = 0;
795: else
796: tp->t_rawin.si_ox++;
797:
798: if ( (islock == 0) || ISINTR || ISQUIT ) {
799: ttin( tp, c );
800: } else if ( (c == 'b') && (lastc == '\033') ) {
801: islock = 0;
802: ttin( tp, lastc );
803: ttin( tp, c );
804: } else if ( (c == 'c') && (lastc == '\033') ) {
805: ttin( tp, lastc );
806: ttin( tp, c );
807: } else
808: putchar('\007');
809: lastc = c;
810: }
811: }
812:
813: /*
814: * update the keyboard status LEDS.
815: * we chose the shift/lock key positions so this would be easy.
816: * this flavor of routine is called while processing a system call on
817: * behalf of the user.
818: */
819: updleds()
820: {
821: kb_cmd2(K_LED_CMD, (shift >> 1) & 0x7);
822: }
823:
824: /*
825: * same as above, but callable from interrupt routines and other places
826: * which cannot sleep() waiting for the state machine to go idle.
827: */
828: updleds2()
829: {
830: register timeout;
831: register int s;
832:
833: timeout = KBTIMEOUT;
834: s = sphi();
835: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL))
836: ;
837: kbstate = KB_DOUBLE_1;
838: cmd2 = (shift >> 1) & 0x7;
839: prev_cmd = K_LED_CMD;
840: outb(KBDATA, K_LED_CMD);
841: spl(s);
842: }
843:
844: /*
845: * unlock the scroll in case an interrupt character is received
846: */
847: kbunscroll()
848: {
849: shift &= ~(1 << scroll);
850: updleds();
851: }
852:
853: /*
854: * ship a single byte command to the keyboard
855: */
856: kb_cmd(cmd)
857: unsigned cmd;
858: {
859: register int timeout;
860: register int s;
861:
862: s = sphi();
863: KBDEBUG2(" kb_cmd(%x)", cmd);
864: while (kbstate != KB_IDLE)
865: sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN);
866: kbstate = KB_SINGLE;
867: timeout = KBTIMEOUT;
868: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL))
869: ;
870: if (!timeout)
871: printf("kb: command timeout\n");
872: else {
873: outb(KBDATA, cmd);
874: while (kbstate != KB_IDLE)
875: sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN);
876: }
877: spl(s);
878: }
879:
880: /*
881: * ship a two byte command to the keyboard
882: */
883: kb_cmd2(cmd, arg)
884: unsigned cmd, arg;
885: {
886: register int timeout;
887: register int s;
888:
889: s = sphi();
890: KBDEBUG3(" kb_cmd2(%x, %x)", cmd, arg);
891: while (kbstate != KB_IDLE)
892: sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN);
893: kbstate = KB_DOUBLE_1;
894: cmd2 = arg;
895: prev_cmd = cmd;
896: timeout = KBTIMEOUT;
897: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL))
898: ;
899: if (!timeout)
900: printf("kb: command timeout\n");
901: else {
902: outb(KBDATA, cmd);
903: while (kbstate != KB_IDLE)
904: sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN);
905: }
906: spl(s);
907: }
908:
909: /* End of nkb.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.