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