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