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