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