![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kb_d.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 / PS2_KERNEL / io.286|
Return to kb_d.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.286 |
1.1 root 1: /*
2: * Keyboard/display driver for German keyboard.
3: * Coherent, IBM PC/XT and AT (286 and 386).
4: */
5: #include <sys/coherent.h>
6: #include <sys/i8086.h>
7: #include <sys/con.h>
8: #include <sys/devices.h>
9: #include <errno.h>
10: #include <sys/stat.h>
11: #include <sys/tty.h>
12: #include <signal.h>
13: #include <sys/sched.h>
14: #include <sys/silo.h>
15:
16: #define SPC 0376 /* Special encoding */
17: #define XXX 0377 /* Non-character */
18: #define KBDATA 0x60 /* Keyboard data */
19: #define KBCTRL 0x61 /* Keyboard control */
20: #define KBFLAG 0x80 /* Keyboard reset flag */
21: #define LEDCMD 0xED /* status indicator command */
22: #define KBACK 0xFA /* status indicator acknowledge */
23: #define EXTENDED0 0xE0 /* extended key seq initiator */
24: #define EXTENDED1 0xE1 /* extended key seq initiator */
25:
26: #define KEYUP 0x80 /* Key up change */
27: #define KEYSC 0x7F /* Key scan code mask */
28: #define LSHIFT 0x2A-1 /* Left shift key */
29: #define LSHIFTA 0x2B-1 /* Alternate left-shift key */
30: #define RSHIFT 0x36-1 /* Right shift key */
31: #define CTRL 0x1D-1 /* Control key */
32: /*-- #define CAPLOCK 0x1D-1 --*/ /* Control key */
33: #define ALT 0x38-1 /* ALT key or ALT GR */
34: #define CAPLOCK 0x3A-1 /* Caps lock key */
35: /*-- #define CTRL 0x3A-1 --*/ /* Caps lock key */
36: #define NUMLOCK 0x45-1 /* Numeric lock key */
37: #define DELETE 0x53-1 /* Del, as in CTRL-ALT-DEL */
38: #define BACKSP 0x0E-1 /* Back space */
39: #define SCRLOCK 0x46-1 /* Scroll lock */
40:
41: /* Shift flags */
42: #define SRS 0x01 /* Right shift key on */
43: #define SLS 0x02 /* Left shift key on */
44: #define CTS 0x04 /* Ctrl key on */
45: #define ALS 0x08 /* Alt key on */
46: #define CPLS 0x10 /* Caps lock on */
47: #define NMLS 0x20 /* Num lock on */
48: #define AKPS 0x40 /* Alternate keypad shift */
49: #define SHFT 0x80 /* Shift key flag */
50: #define AGS 0x100 /* Alt Graphics on */
51:
52: /* Function key information */
53: #define NFKEY 20 /* Number of settable functions */
54: #define NFCHAR 150 /* Number of characters settable */
55: #define NFBUF (NFKEY*2+NFCHAR+1) /* Size of buffer */
56:
57: /*
58: * Functions.
59: */
60: int isrint();
61: int istime();
62: void isbatch();
63: int mmstart();
64: int isopen();
65: int isclose();
66: int isread();
67: int mmwrite();
68: int isioctl();
69: void mmwatch();
70: int isload();
71: int isuload();
72: int ispoll();
73: int nulldev();
74: int nonedev();
75:
76: /*
77: * Configuration table.
78: */
79: CON iscon ={
80: DFCHR|DFPOL, /* Flags */
81: KB_MAJOR, /* Major index */
82: isopen, /* Open */
83: isclose, /* Close */
84: nulldev, /* Block */
85: isread, /* Read */
86: mmwrite, /* Write */
87: isioctl, /* Ioctl */
88: nulldev, /* Powerfail */
89: mmwatch, /* Timeout */
90: isload, /* Load */
91: isuload, /* Unload */
92: ispoll /* Poll */
93: };
94:
95: /*
96: * Flag indicating turbo machine.
97: */
98: int isturbo = 0;
99:
100: /*
101: * Terminal structure.
102: */
103: TTY istty = {
104: {0}, {0}, 0, mmstart, NULL, 0, 0
105: };
106: silo_t in_silo;
107:
108: /*
109: * State variables.
110: */
111: int islock; /* Keyboard locked flag */
112: int isbusy; /* Raw input conversion busy */
113: static int shift; /* Overall shift state */
114: static char scroll; /* Scroll lock state */
115: static char lshift = LSHIFT; /* Left shift alternate state */
116: static char isfbuf[NFBUF]; /* Function key values */
117: static char *isfval[NFKEY]; /* Function key string pointers */
118: static int ledcmd; /* LED update command flag */
119: static char extended; /* extended key scan count */
120: static char extmode; /* use extended mode for this key */
121: static char ext0seen; /* 0xE0 prefix seen */
122:
123: /*
124: * Tables for converting key code to ASCII.
125: * lmaptab specifies unshifted conversion,
126: * umaptab specifies shifted conversion,
127: * smaptab specifies the shift states which are active.
128: * An entry of XXX says the key is dead.
129: * An entry of SPC requires further processing.
130: *
131: * Key codes:
132: * ESC .. <- == 1 .. 14
133: * -> .. \n == 15 .. 28
134: * CTRL .. ` == 29 .. 41
135: * ^Shift .. PrtSc == 42 .. 55
136: * ALT .. CapsLock == 56 .. 58
137: * F1 .. F10 == 59 .. 68
138: * NumLock .. Del == 69 .. 83
139: * ISO, F11, F12 == 86 .. 88
140: */
141: unsigned char agmaptab[] ={ /* Alt Gr */
142: XXX, XXX,'\375','\374',XXX, XXX, XXX, /* 1 - 7 */
143: '{', '[', ']', '}', '\\', XXX, XXX, XXX, /* 8 - 15 */
144: '@', XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 16 - 23 */
145: XXX, XXX, XXX, '~', XXX, XXX, XXX, XXX, /* 24 - 31 */
146: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 32 - 39 */
147: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 40 - 47 */
148: XXX, XXX,'\346', XXX, XXX, XXX, XXX, XXX, /* 48 - 55 */
149: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 56 - 63 */
150: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 64 - 71 */
151: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 72 - 79 */
152: XXX, XXX, XXX, XXX, XXX, XXX, '|', XXX, /* 80 - 87 */
153: XXX /* 88 */
154: };
155:
156: static unsigned char lmaptab[] ={
157: '\33', '1', '2', '3', '4', '5', '6', /* 1 - 7 */
158: '7', '8', '9', '0','\341','\'', '\b', '\t', /* 8 - 15 */
159: 'q', 'w', 'e', 'r', 't', 'z', 'u', 'i', /* 16 - 23 */
160: 'o', 'p','\201', '+', '\r', XXX, 'a', 's', /* 24 - 31 */
161: 'd', 'f', 'g', 'h', 'j', 'k', 'l','\224', /* 32 - 39 */
162: '\204','^', XXX, '#', 'y', 'x', 'c', 'v', /* 40 - 47 */
163: 'b', 'n', 'm', ',', '.', SPC, XXX, SPC, /* 48 - 55 */
164: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */
165: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */
166: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */
167: SPC, SPC, SPC, SPC, XXX, XXX, '<', XXX, /* 80 - 87 */
168: XXX /* 88 */
169: };
170:
171: static unsigned char umaptab[] ={
172: '\33', '!', '"','\025', '$', '%', '&', /* 1 - 7 */
173: '/', '(', ')', '=', '?', '`', '\b', SPC, /* 8 - 15 */
174: 'Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', /* 16 - 23 */
175: 'O', 'P','\232', '*', '\r', XXX, 'A', 'S', /* 24 - 31 */
176: 'D', 'F', 'G', 'H', 'J', 'K', 'L','\231', /* 32 - 39 */
177: '\216','\370',XXX,'\'', 'Y', 'X', 'C', 'V', /* 40 - 47 */
178: 'B', 'N', 'M', ';', ':', SPC, XXX, SPC, /* 48 - 55 */
179: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */
180: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */
181: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */
182: SPC, SPC, SPC, SPC, XXX, XXX, '>', XXX, /* 80 - 87 */
183: XXX /* 88 */
184: };
185:
186: #define SS0 0 /* No shift */
187: #define SS1 (SLS|SRS|CTS) /* Shift, Ctrl */
188: #define SES (SLS|SRS) /* Shift */
189: #define LET (SLS|SRS|CPLS|CTS) /* Shift, Caps, Ctrl */
190: #define KEY (SLS|SRS|NMLS|AKPS) /* Shift, Num, Alt keypad */
191:
192: static unsigned char smaptab[] ={
193: SS0, SES, SS1, SES, SES, SES, SS1, /* 1 - 7 */
194: SES, SES, SES, SES, SS1, SES, CTS, SES, /* 8 - 15 */
195: LET, LET, LET, LET, LET, LET, LET, LET, /* 16 - 23 */
196: LET, LET, SS1, SS1, CTS, SHFT, LET, LET, /* 24 - 31 */
197: LET, LET, LET, LET, LET, LET, LET, SES, /* 32 - 39 */
198: SES, SS1, SHFT, SS1, LET, LET, LET, LET, /* 40 - 47 */
199: LET, LET, LET, SES, SES, SES, SHFT, SES, /* 48 - 55 */
200: SHFT, SS1, SHFT, SS0, SS0, SS0, SS0, SS0, /* 56 - 63 */
201: SS0, SS0, SS0, SS0, SS0, SHFT, KEY, KEY, /* 64 - 71 */
202: KEY, KEY, SS0, KEY, KEY, KEY, SS0, KEY, /* 72 - 79 */
203: KEY, KEY, KEY, KEY, SS0, SS0, SES, SS0, /* 80 - 87 */
204: SS0
205: };
206:
207: /*
208: * Load entry point.
209: * Do reset the keyboard because it gets terribly munged
210: * if you type during the boot.
211: */
212: isload()
213: {
214: register int i;
215:
216: /*
217: * Reset keyboard if NOT an XT turbo.
218: */
219: if (! isturbo) {
220: outb(KBCTRL, 0x0C); /* Clock low */
221: for (i = 10582; --i >= 0;); /* For 20ms */
222: outb(KBCTRL, 0xCC); /* Clock high */
223: for (i = 0; --i != 0;)
224: ;
225: i = inb(KBDATA);
226: outb(KBCTRL, 0xCC); /* Clear keyboard */
227: outb(KBCTRL, 0x4D); /* Enable keyboard */
228: }
229:
230: /*
231: * Enable mmwatch() invocation every second.
232: */
233: drvl[KB_MAJOR].d_time = 1;
234:
235: /*
236: * Seize keyboard interrupt.
237: */
238: setivec(1, isrint);
239:
240: /*
241: * Initiailize video display.
242: */
243: mmstart(&istty);
244: }
245:
246: /*
247: * Unload entry point.
248: */
249: isuload()
250: {
251: clrivec(1);
252: }
253:
254: /*
255: * Default function key strings (terminated by -1 [\377])
256: */
257: static char *deffuncs[] = {
258: "\33[1x\377", /* F1 */
259: "\33[2x\377", /* F2 */
260: "\33[3x\377", /* F3 */
261: "\33[4x\377", /* F4 */
262: "\33[5x\377", /* F5 */
263: "\33[6x\377", /* F6 */
264: "\33[7x\377", /* F7 */
265: "\33[8x\377", /* F8 */
266: "\33[9x\377", /* F9 */
267: "\33[0x\377", /* F10 - historical value */
268: "\33[1y\377", /* F11 */
269: "\33[2y\377", /* F12 */
270: "\33[3y\377", /* F13 */
271: "\33[4y\377", /* F14 */
272: "\33[5y\377", /* F15 */
273: "\33[6y\377", /* F16 */
274: "\33[7y\377", /* F17 */
275: "\33[8y\377", /* F18 */
276: "\33[9y\377", /* F19 */
277: "\33[0y\377" /* F20 */
278: };
279:
280: /*
281: * Open routine.
282: */
283: isopen(dev)
284: dev_t dev;
285: {
286: register int s;
287:
288: if (minor(dev) != 0) {
289: u.u_error = ENXIO;
290: return;
291: }
292: if ((istty.t_flags&T_EXCL)!=0 && super()==0) {
293: u.u_error = ENODEV;
294: return;
295: }
296: ttsetgrp(&istty, dev);
297:
298: s = sphi();
299: if (istty.t_open++ == 0)
300: { initkeys(); /* init function keys */
301: istty.t_flags = T_CARR; /* indicate "carrier" */
302: ttopen(&istty);
303: }
304: spl(s);
305: updleds(); /* update keyboard status LEDS */
306: }
307:
308: /* Init function keys */
309: initkeys()
310: { register int i;
311: register char *cp1, *cp2;
312:
313: for (i=0; i<NFKEY; i++)
314: isfval[i] = 0; /* clear function key buffer */
315: cp2 = isfbuf; /* pointer to key buffer */
316: for (i=0; i<NFKEY; i++)
317: { isfval[i] = cp2; /* save pointer to key string */
318: cp1 = deffuncs[i]; /* get init string pointer */
319: while ((*cp2++ = *cp1++) != -1) /* copy key data */
320: if (cp2 >= &isfbuf[NFBUF-3]) /* overflow? */
321: return;
322: }
323: }
324:
325: /*
326: * Close a tty.
327: */
328: isclose(dev)
329: {
330: register int s;
331:
332: s = sphi();
333: if (--istty.t_open == 0)
334: { s = sphi();
335: ttclose(&istty);
336: spl(s);
337: }
338: }
339:
340: /*
341: * Read routine.
342: */
343: isread(dev, iop)
344: dev_t dev;
345: IO *iop;
346: {
347: ttread(&istty, iop, 0);
348: if (istty.t_oq.cq_cc)
349: mmtime(&istty);
350: }
351:
352: /*
353: * Ioctl routine.
354: */
355: isioctl(dev, com, vec)
356: dev_t dev;
357: struct sgttyb *vec;
358: {
359: register int s;
360:
361: switch(com) {
362: case TIOCSETF:
363: case TIOCGETF:
364: isfunction(com, (char *)vec);
365: return;
366: case TIOCSHIFT: /* switch left-SHIFT and "\" */
367: lshift = LSHIFTA; /* alternate values */
368: lmaptab[41] = '\\';
369: lmaptab[42] = XXX;
370: umaptab[41] = '|';
371: umaptab[42] = XXX;
372: smaptab[41] = SS1;
373: smaptab[42] = SHFT;
374: return;
375: case TIOCCSHIFT: /* normal (default) left-SHIFT and "\" */
376: lshift = LSHIFT; /* normal values */
377: lmaptab[41] = XXX;
378: lmaptab[42] = '\\';
379: umaptab[41] = XXX;
380: umaptab[42] = '|';
381: smaptab[41] = SHFT;
382: smaptab[42] = SS1;
383: return;
384: }
385: s = sphi();
386: ttioctl(&istty, com, vec);
387: spl(s);
388: }
389:
390: /*
391: * Set and receive the function keys.
392: */
393: isfunction(c, v)
394: int c;
395: char *v;
396: {
397: register char *cp;
398: register int i;
399:
400: if (c == TIOCGETF) {
401: for (cp = isfbuf; cp < &isfbuf[NFBUF]; cp++)
402: putubd(v++, *cp);
403: } else {
404: for (i=0; i<NFKEY; i++) /* zap current settings */
405: isfval[i] = 0;
406: cp = isfbuf; /* pointer to key buffer */
407: for (i=0; i<NFKEY; i++) {
408: isfval[i] = cp; /* save pointer to key string */
409: while ((*cp++ = getubd(v++)) != -1) /* copy key data */
410: if (cp >= &isfbuf[NFBUF-3]) /* overflow? */
411: return;
412: }
413: }
414: }
415:
416:
417: /*
418: * Poll routine.
419: */
420: ispoll(dev, ev, msec)
421: dev_t dev;
422: int ev;
423: int msec;
424: {
425: /*
426: * Priority polls not supported.
427: */
428: ev &= ~POLLPRI;
429:
430: /*
431: * Input poll failure.
432: */
433: if ((ev & POLLIN) && (istty.t_iq.cq_cc == 0)) {
434:
435: if (msec != 0)
436: pollopen(&istty.t_ipolls);
437:
438: /*
439: * Second look AFTER enabling monitor, avoiding interrupt race.
440: */
441: if (istty.t_iq.cq_cc == 0)
442: ev &= ~POLLIN;
443: }
444:
445: return ev;
446: }
447:
448: /*
449: * Receive interrupt.
450: */
451: isrint()
452: {
453: register int c;
454: register int s;
455: register int r;
456: int savests;
457: int update_leds = 0;
458:
459: /*
460: * Schedule raw input handler if not already active.
461: */
462: if (isbusy == 0) {
463: defer(isbatch, &istty);
464: isbusy = 1;
465: }
466:
467: /*
468: * Pull character from the data
469: * port. Pulse the KBFLAG in the control
470: * port to reset the data buffer.
471: */
472: r = inb(KBDATA) & 0xFF;
473: c = inb(KBCTRL);
474: outb(KBCTRL, c|KBFLAG);
475: outb(KBCTRL, c);
476: #if 0
477: printf("kbd: %x %s\n", r&0x7F, (r&KEYUP) ? "up" : "down");
478: #endif
479: if (ledcmd) {
480: ledcmd = 0;
481: if (r == KBACK) { /* output to status LEDS */
482: c = scroll & 1;
483: if (shift & NMLS)
484: c |= 2;
485: if (shift & CPLS)
486: c |= 4;
487: outb(KBDATA, c);
488: }
489: return;
490: }
491: if (extended > 0) { /* if multi-character seq, */
492: --extended; /* ... ignore this char */
493: return;
494: }
495:
496: switch (r) {
497: case EXTENDED0: /* 0xE0 prefix found */
498: ext0seen = 1;
499: return;
500: case EXTENDED1: /* ignore extended sequences */
501: extended = 5;
502: return;
503: case 0xFF: /* Overrun */
504: return;
505: }
506:
507: if (ext0seen) {
508: ext0seen = 0;
509: extmode = 1;
510: } else
511: extmode = 0;
512:
513: c = (r & KEYSC) - 1; /* bias to internal format */
514:
515: /*
516: * Check for reset.
517: */
518: if ((r&KEYUP) == 0 && c == DELETE && (shift&(CTS|ALS)) == (CTS|ALS))
519: boot();
520:
521: /*
522: * Track "shift" keys.
523: */
524: s = smaptab[c];
525: if (s&SHFT) {
526: if (r&KEYUP) { /* "shift" released */
527: if (c == RSHIFT)
528: shift &= ~SRS;
529: else if (c == lshift)
530: shift &= ~SLS;
531: else if (c == CTRL)
532: shift &= ~CTS;
533: else if (c == ALT)
534: shift &= extmode ? ~AGS : ~ALS;
535: } else { /* "shift" pressed */
536: if (c == lshift)
537: shift |= SLS;
538: else if (c == RSHIFT)
539: shift |= SRS;
540: else if (c == CTRL)
541: shift |= CTS;
542: else if (c == ALT)
543: shift |= extmode ? AGS : ALS;
544: else if (c == CAPLOCK) {
545: shift ^= CPLS; /* toggle cap lock */
546: updleds();
547: } else if (c == NUMLOCK) {
548: shift ^= NMLS; /* toggle num lock */
549: updleds();
550: }
551: }
552: return;
553: }
554:
555: /*
556: * No other key up codes of interest.
557: */
558: if (r&KEYUP)
559: return;
560:
561: /*
562: * If the tty is not open the character is
563: * just tossed away.
564: */
565: if (istty.t_open == 0)
566: return;
567:
568: /*
569: * Map character, based on the
570: * current state of the shift, control, alt graphics,
571: * meta (ALT) and lock flags.
572: */
573: if (shift & AGS) /* Alt Graphics ? */
574: c = agmaptab[c];
575: else if (shift & CTS) {
576: if (s == CTS) /* Map Ctrl (BS | NL) */
577: c = (c == BACKSP) ? 0x7F : 0x0A;
578: else if (s==SS1 || s==LET) /* Normal Ctrl map */
579: c = umaptab[c]&0x1F; /* Clear bits 5-6 */
580: else
581: return; /* Ignore this char */
582: } else if (s &= shift) {
583: if (shift & SES) { /* if shift on */
584: if (s & (CPLS|NMLS)) /* if caps/num lock */
585: c = lmaptab[c]; /* use unshifted */
586: else
587: c = umaptab[c]; /* use shifted */
588: } else { /* if shift not on */
589: if (s & (CPLS|NMLS)) /* if caps/num lock */
590: c = umaptab[c]; /* use shifted */
591: else
592: c = lmaptab[c]; /* use unshifted */
593: }
594: } else
595: c = lmaptab[c]; /* use unshifted */
596:
597: /*
598: * Act on character.
599: */
600: if (c == XXX)
601: return; /* char to ignore */
602:
603: if (c != SPC) { /* not special char? */
604: if (shift & ALS) /* ALT (meta bit)? */
605: c |= 0x80; /* set meta */
606: isin(c); /* send the char */
607: } else
608: update_leds += isspecial(r); /* special chars */
609: if (update_leds) {
610: savests = sphi();
611: outb(KBDATA, LEDCMD);
612: ledcmd = 1;
613: spl(savests);
614: }
615: }
616:
617: /*
618: * Handle special input sequences.
619: * The character passed is the key number.
620: *
621: * The keypad is translated by the following table,
622: * the first entry is the normal sequence, the second the shifted,
623: * and the third the alternate keypad sequence.
624: */
625: static char *keypad[][3] = {
626: { "\33[H", "7", "\33?w" }, /* 71 */
627: { "\33[A", "8", "\33?x" }, /* 72 */
628: { "\33[V", "9", "\33?y" }, /* 73 */
629: { "\33[D", "4", "\33?t" }, /* 75 */
630: { "\0337", "5", "\33?u" }, /* 76 */
631: { "\33[C", "6", "\33?v" }, /* 77 */
632: { "\33[24H","1", "\33?q" }, /* 79 */
633: { "\33[B", "2", "\33?r" }, /* 80 */
634: { "\33[U", "3", "\33?s" }, /* 81 */
635: { "\33[@", "0", "\33?p" }, /* 82 */
636: { "\33[P", ".", "\33?n" } /* 83 */
637: };
638:
639: isspecial(c)
640: int c;
641: {
642: register char *cp;
643: register int s;
644: int update_leds = 0;
645:
646: cp = 0;
647:
648: switch (c) {
649: case 15: /* cursor back tab */
650: cp = "\033[Z";
651: break;
652: case 53:
653: if (extmode)
654: cp = "/";
655: else if (shift & SES)
656: cp = "_";
657: else
658: cp = "-";
659: break;
660: case 55: /* ignore PrtScr */
661: if (!extmode)
662: cp = "*";
663: break;
664: case 59: case 60: case 61: case 62: case 63: /* Function keys */
665: case 64: case 65: case 66: case 67: case 68:
666: /* offset to function string */
667: if (shift & ALS)
668: cp = isfval[c-49];
669: else
670: cp = isfval[c-59];
671: break;
672:
673: case 70: /* Scroll Lock -- stop/start output */
674: {
675: static char cbuf[2];
676:
677: cp = &cbuf[0]; /* working buffer */
678: if (!(istty.t_sgttyb.sg_flags&RAWIN)) { /* not if in RAW mode */
679: ++update_leds;
680: if (istty.t_flags & T_STOP) { /* output stopped? */
681: cbuf[0] = istty.t_tchars.t_startc; /* start it */
682: scroll = 0;
683: } else {
684: cbuf[0] = istty.t_tchars.t_stopc; /* stop output */
685: scroll = 1;
686: }
687: }
688: break;
689: }
690:
691: case 79: /* 1/End */
692: case 80: /* 2/DOWN */
693: case 81: /* 3/PgDn */
694: case 82: /* 0/Ins */
695: case 83: /* ./Del */
696: --c; /* adjust code */
697: case 75: /* 4/LEFT */
698: case 76: /* 5 */
699: case 77: /* 6/RIGHT */
700: --c; /* adjust code */
701: case 71: /* 7/Home/Clear */
702: case 72: /* 8/UP */
703: case 73: /* 9/PgUp */
704: s = 0; /* start off with normal keypad */
705: if (shift & NMLS) /* num lock? */
706: s = 1; /* set shift pad */
707: if (shift & SES) /* shift? */
708: s ^= 1; /* toggle shift pad */
709: if (shift & AKPS) /* alternate pad? */
710: s = 2; /* set alternate pad */
711: if (extmode) /* not from keypad? */
712: s = 0; /* force normal sequence */
713: cp = keypad[c-71][s]; /* get keypad value */
714: break;
715: }
716: if (cp) /* send string */
717: while ((*cp != 0) && (*cp != -1))
718: isin(*cp++ & 0377);
719: return update_leds;
720: }
721:
722: /**
723: *
724: * void
725: * ismmfunc(c) -- process keyboard related output escape sequences
726: * char c;
727: */
728: void
729: ismmfunc(c)
730: register int c;
731: {
732: switch (c) {
733: case 't': /* Enter numlock */
734: shift |= NMLS;
735: updleds(); /* update LED status */
736: break;
737: case 'u': /* Leave numlock */
738: shift &= ~NMLS;
739: updleds(); /* update LED status */
740: break;
741: case '=': /* Enter alternate keypad */
742: shift |= AKPS;
743: break;
744: case '>': /* Exit alternate keypad */
745: shift &= ~AKPS;
746: break;
747: case 'c': /* Reset terminal */
748: islock = 0;
749: shift = 0;
750: initkeys();
751: updleds(); /* update LED status */
752: break;
753: }
754: }
755:
756: /**
757: *
758: * void
759: * isin(c) -- append character to raw input silo
760: * char c;
761: */
762: static
763: isin(c)
764: register int c;
765: {
766: int cache_it = 1;
767: TTY * tp = &istty;
768:
769: /*
770: * If using software incoming flow control, process and
771: * discard t_stopc and t_startc.
772: */
773: if (!ISRIN) {
774: if (ISSTOP) {
775: if ((tp->t_flags&T_STOP) == 0)
776: tp->t_flags |= T_STOP;
777: cache_it = 0;
778: }
779: if (ISSTART) {
780: tp->t_flags &= ~T_STOP;
781: ttstart(tp);
782: cache_it = 0;
783: }
784: }
785:
786: /*
787: * Cache received character.
788: */
789: if (cache_it) {
790: in_silo.si_buf[ in_silo.si_ix ] = c;
791:
792: if (++in_silo.si_ix >= sizeof(in_silo.si_buf))
793: in_silo.si_ix = 0;
794: }
795: }
796:
797: /**
798: *
799: * void
800: * isbatch() -- raw input conversion routine
801: *
802: * Action: Enable the video display.
803: * Canonize the raw input silo.
804: *
805: * Notes: isbatch() was scheduled as a deferred process by isrint().
806: */
807: static void
808: isbatch(tp)
809: register TTY * tp;
810: {
811: register int c;
812: static int lastc;
813:
814: /*
815: * Ensure video display is enabled.
816: */
817: mm_von();
818:
819: isbusy = 0;
820:
821: /*
822: * Process all cached characters.
823: */
824: while (in_silo.si_ix != in_silo.si_ox) {
825:
826: /*
827: * Get next cached char.
828: */
829: c = in_silo.si_buf[ in_silo.si_ox ];
830:
831: if (in_silo.si_ox >= sizeof(in_silo.si_buf) - 1)
832: in_silo.si_ox = 0;
833: else
834: in_silo.si_ox++;
835:
836: if ((islock == 0) || ISINTR || ISQUIT) {
837: ttin(tp, c);
838: }
839:
840: else if ((c == 'b') && (lastc == '\033')) {
841: islock = 0;
842: ttin(tp, lastc);
843: ttin(tp, c);
844: }
845:
846: else if ((c == 'c') && (lastc == '\033')) {
847: ttin(tp, lastc);
848: ttin(tp, c);
849: }
850:
851: else
852: putchar('\007');
853:
854: lastc = c;
855: }
856: }
857:
858: /*
859: * update the keyboard status LEDS
860: */
861: updleds()
862: {
863: int s;
864:
865: s = sphi();
866: outb(KBDATA, LEDCMD);
867: ledcmd = 1;
868: spl(s);
869: }
870:
871: /*
872: * unlock the scroll in case an interrupt character is received
873: */
874: kbunscroll()
875: {
876: scroll = 0;
877: updleds();
878: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.