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