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