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