![[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 / STREAMS / io.386|
Return to kb.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 ! root 1: /* ! 2: * io.386/kb.c ! 3: * ! 4: * non virtual terminal, nonloadable keyboard driver ! 5: * ! 6: * Revised: Fri Jul 30 08:08:03 1993 CDT ! 7: */ ! 8: ! 9: /* ! 10: * Functions in this module: ! 11: * isload() isuload() isopen() initkeys() ! 12: * isclose() isread() kbstate() isioctl() ! 13: * isfunction() ispoll() isrint() isspecial() ! 14: * ismmfunc() isin() isbatch() updleds() ! 15: * kbunscroll() ! 16: */ ! 17: ! 18: /**************************Included Files*****************************/ ! 19: ! 20: #include <sys/coherent.h> ! 21: #include <sys/con.h> ! 22: #include <sys/devices.h> ! 23: #include <sys/errno.h> ! 24: #include <sys/kb.h> ! 25: #include <sys/stat.h> ! 26: #include <sys/tty.h> ! 27: #include <signal.h> ! 28: #include <sys/sched.h> ! 29: #include <sys/silo.h> ! 30: ! 31: /****************************Hardware Defines*************************/ ! 32: ! 33: #define SPC 0376 /* Special encoding */ ! 34: #define XXX 0377 /* Non-character */ ! 35: #define KBDATA 0x60 /* Keyboard data */ ! 36: #define KBCTRL 0x61 /* Keyboard control */ ! 37: #define KBFLAG 0x80 /* Keyboard reset flag */ ! 38: #define LEDCMD 0xED /* status indicator command */ ! 39: #define KBACK 0xFA /* status indicator acknowledge */ ! 40: #define EXTENDED0 0xE0 /* extended key seq initiator */ ! 41: #define EXTENDED1 0xE1 /* extended key seq initiator */ ! 42: ! 43: #define KEYUP 0x80 /* Key up change */ ! 44: #define KEYSC 0x7F /* Key scan code mask */ ! 45: #define LSHIFT 0x2A-1 /* Left shift key */ ! 46: #define LSHIFTA 0x2B-1 /* Alternate left-shift key */ ! 47: #define RSHIFT 0x36-1 /* Right shift key */ ! 48: #define KB_CTRL_KEY 0x1D-1 /* Control key */ ! 49: ! 50: #define KB_ALT_KEY 0x38-1 /* Alt key or ALT GR */ ! 51: #define CAPLOCK 0x3A-1 /* Caps lock key */ ! 52: #define NUMLOCK 0x45-1 /* Numeric lock key */ ! 53: #define DELETE 0x53-1 /* Del, as in CTRL-ALT-DEL */ ! 54: #define BACKSP 0x0E-1 /* Back space */ ! 55: #define SCRLOCK 0x46-1 /* Scroll lock */ ! 56: ! 57: /* Shift flags */ ! 58: #define SRS 0x01 /* Right shift key on */ ! 59: #define SLS 0x02 /* Left shift key on */ ! 60: #define CTS 0x04 /* Ctrl key on */ ! 61: #define ALS 0x08 /* Alt key on */ ! 62: #define CPLS 0x10 /* Caps lock on */ ! 63: #define NMLS 0x20 /* Num lock on */ ! 64: #define AKPS 0x40 /* Alternate keypad shift */ ! 65: #define SHFT 0x80 /* Shift key flag */ ! 66: #define AGS 0x100 /* Alt Graphics on */ ! 67: ! 68: /* Function key information */ ! 69: #define NFKEY 50 /* Number of settable functions */ ! 70: #define NFCHAR 150 /* Number of characters settable */ ! 71: #define NFBUF (NFKEY*2+NFCHAR+1) /* Size of buffer */ ! 72: ! 73: /****************************** Data Defines ****************************/ ! 74: ! 75: #define ESCAPE_CHAR '\x1B' ! 76: #define ESCAPE_STRING "\x1B' ! 77: #define HEXFF_STRING "\xFF" ! 78: #define DELETE_STRING "\x7F" ! 79: ! 80: #define SS0 0 /* No shift */ ! 81: #define SS1 (SLS|SRS|CTS) /* Shift, Ctrl */ ! 82: #define SES (SLS|SRS) /* Shift */ ! 83: #define LET (SLS|SRS|CPLS|CTS) /* Shift, Caps, Ctrl */ ! 84: #define KEY (SLS|SRS|NMLS|AKPS) /* Shift, Num, Alt keypad */ ! 85: ! 86: /*************************** X Stuff *************************************/ ! 87: ! 88: /* ! 89: * special struct for the KDMAPDISP call ! 90: */ ! 91: ! 92: #define KDMAPDISP (('K' << 8) | 2) /* map display into user space */ ! 93: #define KDSKBMODE (('K' << 8) | 6) /* turn scan code xlate on/off */ ! 94: #define KDMEMDISP (('K' << 8) | 7) /* dump byte of virt/phys mem */ ! 95: #define KDENABIO (('K' << 8) | 60) /* enable IO */ ! 96: #define KIOCSOUND (('K' << 8) | 63) /* start sound generation */ ! 97: #define KDSETLED (('K' << 8) | 66) /* set leds */ ! 98: ! 99: #define TIMER_CTL 0x43 /* Timer control */ ! 100: #define TIMER_CNT 0x42 /* Timer counter */ ! 101: #define SPEAKER_CTL 0x61 /* Speaker control */ ! 102: ! 103: struct kd_memloc { ! 104: char *vaddr; /* virtual address to map to */ ! 105: char *physaddr; /* physical address to map to */ ! 106: long length; /* size in bytes to map */ ! 107: long ioflg; /* enable I/O addresses if non-zero */ ! 108: }; ! 109: ! 110: /************************** Tables *****************************/ ! 111: ! 112: /* ! 113: * Default function key strings (terminated by -1 [\377]) ! 114: */ ! 115: static char *deffuncs[] = { ! 116: /* Normal function keys */ ! 117: ESCAPE_STRING "[M" HEXFF_STRING, /* F1 */ ! 118: ESCAPE_STRING "[N" HEXFF_STRING, /* F2 */ ! 119: ESCAPE_STRING "[O" HEXFF_STRING, /* F3 */ ! 120: ESCAPE_STRING "[P" HEXFF_STRING, /* F4 */ ! 121: ESCAPE_STRING "[Q" HEXFF_STRING, /* F5 */ ! 122: ESCAPE_STRING "[R" HEXFF_STRING, /* F6 */ ! 123: ESCAPE_STRING "[S" HEXFF_STRING, /* F7 */ ! 124: ESCAPE_STRING "[T" HEXFF_STRING, /* F8 */ ! 125: ESCAPE_STRING "[U" HEXFF_STRING, /* F9 */ ! 126: ESCAPE_STRING "[V" HEXFF_STRING, /* F10 - historical value */ ! 127: ! 128: /* Shifted function keys - no f11, f12 on 83-key keyboard */ ! 129: ESCAPE_STRING "[Y" HEXFF_STRING, /* sF1 */ ! 130: ESCAPE_STRING "[Z" HEXFF_STRING, /* sF2 */ ! 131: ESCAPE_STRING "[a" HEXFF_STRING, /* sF3 */ ! 132: ESCAPE_STRING "[b" HEXFF_STRING, /* sF4 */ ! 133: ESCAPE_STRING "[c" HEXFF_STRING, /* sF5 */ ! 134: ESCAPE_STRING "[d" HEXFF_STRING, /* sF6 */ ! 135: ESCAPE_STRING "[e" HEXFF_STRING, /* sF7 */ ! 136: ESCAPE_STRING "[f" HEXFF_STRING, /* sF8 */ ! 137: ESCAPE_STRING "[g" HEXFF_STRING, /* sF9 */ ! 138: ESCAPE_STRING "[h" HEXFF_STRING, /* sF10 */ ! 139: ! 140: /* Ctrl-ed function keys */ ! 141: ESCAPE_STRING "[k" HEXFF_STRING, /* cF1 */ ! 142: ESCAPE_STRING "[l" HEXFF_STRING, /* cF2 */ ! 143: ESCAPE_STRING "[m" HEXFF_STRING, /* cF3 */ ! 144: ESCAPE_STRING "[n" HEXFF_STRING, /* cF4 */ ! 145: ESCAPE_STRING "[o" HEXFF_STRING, /* cF5 */ ! 146: ESCAPE_STRING "[p" HEXFF_STRING, /* cF6 */ ! 147: ESCAPE_STRING "[q" HEXFF_STRING, /* cF7 */ ! 148: ESCAPE_STRING "[r" HEXFF_STRING, /* cF8 */ ! 149: ESCAPE_STRING "[s" HEXFF_STRING, /* cF9 */ ! 150: ESCAPE_STRING "[t" HEXFF_STRING, /* cF10 */ ! 151: ! 152: /* Ctrl-shifted function keys */ ! 153: ESCAPE_STRING "[w" HEXFF_STRING, /* csF1 */ ! 154: ESCAPE_STRING "[x" HEXFF_STRING, /* csF2 */ ! 155: ESCAPE_STRING "[y" HEXFF_STRING, /* csF3 */ ! 156: ESCAPE_STRING "[z" HEXFF_STRING, /* csF4 */ ! 157: ESCAPE_STRING "[@" HEXFF_STRING, /* csF5 */ ! 158: ESCAPE_STRING "[[" HEXFF_STRING, /* csF6 */ ! 159: ESCAPE_STRING "[\\" HEXFF_STRING, /* csF7 */ ! 160: ESCAPE_STRING "[]" HEXFF_STRING, /* csF8 */ ! 161: ESCAPE_STRING "[^" HEXFF_STRING, /* csF9 */ ! 162: ESCAPE_STRING "[_" HEXFF_STRING, /* csF10 */ ! 163: ! 164: /* Alt keys -- use original 83-key settings since these ! 165: are not defined with a default for virtual terminals */ ! 166: ESCAPE_STRING "[1y" HEXFF_STRING, /* aF1 */ ! 167: ESCAPE_STRING "[2y" HEXFF_STRING, /* aF2 */ ! 168: ESCAPE_STRING "[3y" HEXFF_STRING, /* aF3 */ ! 169: ESCAPE_STRING "[4y" HEXFF_STRING, /* aF4 */ ! 170: ESCAPE_STRING "[5y" HEXFF_STRING, /* aF5 */ ! 171: ESCAPE_STRING "[6y" HEXFF_STRING, /* aF6 */ ! 172: ESCAPE_STRING "[7y" HEXFF_STRING, /* aF7 */ ! 173: ESCAPE_STRING "[8y" HEXFF_STRING, /* aF8 */ ! 174: ESCAPE_STRING "[9y" HEXFF_STRING, /* aF9 */ ! 175: ESCAPE_STRING "[0y" HEXFF_STRING /* aF10 */ ! 176: }; ! 177: ! 178: /* ! 179: * Handle special input sequences. ! 180: * The character passed is the key number. ! 181: * ! 182: * The keypad is translated by the following table, ! 183: * the first entry is the normal sequence, the second the shifted, ! 184: * and the third the alternate keypad sequence. ! 185: */ ! 186: static char *keypad[][3] = { ! 187: { ESCAPE_STRING "[H", "7", ESCAPE_STRING "?w" }, /* 71 */ ! 188: { ESCAPE_STRING "[A", "8", ESCAPE_STRING "?x" }, /* 72 */ ! 189: { ESCAPE_STRING "[I", "9", ESCAPE_STRING "?y" }, /* 73 */ ! 190: { ESCAPE_STRING "[D", "4", ESCAPE_STRING "?t" }, /* 75 */ ! 191: { ESCAPE_STRING "7", "5", ESCAPE_STRING "?u" }, /* 76 */ ! 192: { ESCAPE_STRING "[C", "6", ESCAPE_STRING "?v" }, /* 77 */ ! 193: { ESCAPE_STRING "[F", "1", ESCAPE_STRING "?q" }, /* 79 */ ! 194: { ESCAPE_STRING "[B", "2", ESCAPE_STRING "?r" }, /* 80 */ ! 195: { ESCAPE_STRING "[G", "3", ESCAPE_STRING "?s" }, /* 81 */ ! 196: { ESCAPE_STRING "[L", "0", ESCAPE_STRING "?p" }, /* 82 */ ! 197: { DELETE_STRING , ".", ESCAPE_STRING "?n" } /* 83 */ ! 198: }; ! 199: ! 200: /* ! 201: * French Tables for converting key code to ASCII. ! 202: * lmaptab specifies unshifted conversion, ! 203: * umaptab specifies shifted conversion, ! 204: * smaptab specifies the shift states which are active. ! 205: * An entry of XXX says the key is dead. ! 206: * An entry of SPC requires further processing. ! 207: * ! 208: * Key codes: ! 209: * ESC .. <- == 1 .. 14 ! 210: * -> .. \n == 15 .. 28 ! 211: * CTRL .. ` == 29 .. 41 ! 212: * ^Shift .. PrtSc == 42 .. 55 ! 213: * ALT .. CapsLock == 56 .. 58 ! 214: * F1 .. F10 == 59 .. 68 ! 215: * NumLock .. Del == 69 .. 83 ! 216: * ISO, F11, F12 == 86 .. 88 ! 217: */ ! 218: unsigned char fr_agmaptab[] ={ /* Alt Gr */ ! 219: XXX, XXX, '~', '#', '{', '[', '|', /* 1 - 7 */ ! 220: '`', '\\', '^', '@', ']', '}', XXX, XXX, /* 8 - 15 */ ! 221: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 16 - 23 */ ! 222: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 24 - 31 */ ! 223: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 32 - 39 */ ! 224: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 40 - 47 */ ! 225: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 48 - 55 */ ! 226: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 56 - 63 */ ! 227: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 64 - 71 */ ! 228: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 72 - 79 */ ! 229: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 80 - 87 */ ! 230: XXX /* 88 */ ! 231: }; ! 232: ! 233: static unsigned char fr_lmaptab[] ={ ! 234: ESCAPE_CHAR, '&','\202', '"', '\'', '(', '-', /* 1 - 7 */ ! 235: '\212','_','\207','\205',')', '=', '\b', '\t', /* 8 - 15 */ ! 236: 'a', 'z', 'e', 'r', 't', 'y', 'u', 'i', /* 16 - 23 */ ! 237: 'o', 'p','\260', '$', '\r', XXX, 'q', 's', /* 24 - 31 */ ! 238: 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', /* 32 - 39 */ ! 239: '\227','\375',XXX,'*', 'w', 'x', 'c', 'v', /* 40 - 47 */ ! 240: 'b', 'n', ',', ';', ':', SPC, XXX, SPC, /* 48 - 55 */ ! 241: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 242: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 243: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 244: SPC, SPC, SPC, SPC, XXX, XXX, '<', XXX, /* 80 - 87 */ ! 245: XXX /* 88 */ ! 246: }; ! 247: ! 248: static unsigned char fr_umaptab[] ={ ! 249: ESCAPE_CHAR, '1', '2', '3', '4', '5', '6', /* 1 - 7 */ ! 250: '7', '8', '9', '0','\370', '+', '\b', SPC, /* 8 - 15 */ ! 251: 'A', 'Z', 'E', 'R', 'T', 'Y', 'U', 'I', /* 16 - 23 */ ! 252: 'O', 'P','\261','\234','\r', XXX, 'Q', 'S', /* 24 - 31 */ ! 253: 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', /* 32 - 39 */ ! 254: '%','\300',XXX,'\346', 'W', 'X', 'C', 'V', /* 40 - 47 */ ! 255: 'B', 'N', '?', '.', '/', SPC, XXX, SPC, /* 48 - 55 */ ! 256: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 257: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 258: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 259: SPC, SPC, SPC, SPC, XXX, XXX, '>', XXX, /* 80 - 87 */ ! 260: XXX /* 88 */ ! 261: }; ! 262: ! 263: static unsigned char fr_smaptab[] ={ ! 264: SS0, SES, SS1, SES, SES, SES, SS1, /* 1 - 7 */ ! 265: SES, SES, SES, SES, SS1, SES, CTS, SES, /* 8 - 15 */ ! 266: LET, LET, LET, LET, LET, LET, LET, LET, /* 16 - 23 */ ! 267: LET, LET, SS1, SS1, CTS, SHFT, LET, LET, /* 24 - 31 */ ! 268: LET, LET, LET, LET, LET, LET, LET, SES, /* 32 - 39 */ ! 269: SES, SS1, SHFT, SS1, LET, LET, LET, LET, /* 40 - 47 */ ! 270: LET, LET, LET, SES, SES, SES, SHFT, SES, /* 48 - 55 */ ! 271: SHFT, SS1, SHFT, SS1, SS1, SS1, SS1, SS1, /* 56 - 63 */ ! 272: SS1, SS1, SS1, SS1, SS1, SHFT, KEY, KEY, /* 64 - 71 */ ! 273: KEY, KEY, SS0, KEY, KEY, KEY, SS0, KEY, /* 72 - 79 */ ! 274: KEY, KEY, KEY, KEY, SS0, SS0, SES, SS0, /* 80 - 87 */ ! 275: SS0 ! 276: }; ! 277: /* ! 278: * Tables for converting key code to ASCII. ! 279: * lmaptab specifies unshifted conversion, ! 280: * umaptab specifies shifted conversion, ! 281: * smaptab specifies the shift states which are active. ! 282: * An entry of XXX says the key is dead. ! 283: * An entry of SPC requires further processing. ! 284: * ! 285: * Key codes: ! 286: * ESC .. <- == 1 .. 14 ! 287: * -> .. \n == 15 .. 28 ! 288: * CTRL .. ` == 29 .. 41 ! 289: * ^Shift .. PrtSc == 42 .. 55 ! 290: * ALT .. CapsLock == 56 .. 58 ! 291: * F1 .. F10 == 59 .. 68 ! 292: * NumLock .. Del == 69 .. 83 ! 293: */ ! 294: static unsigned char us_lmaptab[] ={ ! 295: ESCAPE_CHAR, '1', '2', '3', '4', '5', '6', /* 1 - 7 */ ! 296: '7', '8', '9', '0', '-', '=', '\b', '\t', /* 8 - 15 */ ! 297: 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', /* 16 - 23 */ ! 298: 'o', 'p', '[', ']', '\r', XXX, 'a', 's', /* 24 - 31 */ ! 299: 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', /* 32 - 39 */ ! 300: '\'', '`', XXX, '\\', 'z', 'x', 'c', 'v', /* 40 - 47 */ ! 301: 'b', 'n', 'm', ',', '.', '/', XXX, '*', /* 48 - 55 */ ! 302: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 303: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 304: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 305: SPC, SPC, SPC, SPC /* 80 - 83 */ ! 306: }; ! 307: ! 308: static unsigned char us_umaptab[] ={ ! 309: ESCAPE_CHAR, '!', '@', '#', '$', '%', '^', /* 1 - 7 */ ! 310: '&', '*', '(', ')', '_', '+', '\b', SPC, /* 8 - 15 */ ! 311: 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', /* 16 - 23 */ ! 312: 'O', 'P', '{', '}', '\r', XXX, 'A', 'S', /* 24 - 31 */ ! 313: 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', /* 32 - 39 */ ! 314: '"', '~', XXX, '|', 'Z', 'X', 'C', 'V', /* 40 - 47 */ ! 315: 'B', 'N', 'M', '<', '>', '?', XXX, '*', /* 48 - 55 */ ! 316: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 317: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 318: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 319: SPC, SPC, SPC, SPC /* 80 - 83 */ ! 320: }; ! 321: ! 322: static unsigned char us_smaptab[] ={ ! 323: SS0, SES, SS1, SES, SES, SES, SS1, /* 1 - 7 */ ! 324: SES, SES, SES, SES, SS1, SES, CTS, SES, /* 8 - 15 */ ! 325: LET, LET, LET, LET, LET, LET, LET, LET, /* 16 - 23 */ ! 326: LET, LET, SS1, SS1, CTS, SHFT, LET, LET, /* 24 - 31 */ ! 327: LET, LET, LET, LET, LET, LET, LET, SES, /* 32 - 39 */ ! 328: SES, SS1, SHFT, SS1, LET, LET, LET, LET, /* 40 - 47 */ ! 329: LET, LET, LET, SES, SES, SES, SHFT, SES, /* 48 - 55 */ ! 330: SHFT, SS1, SHFT, SS1, SS1, SS1, SS1, SS1, /* 56 - 63 */ ! 331: SS1, SS1, SS1, SS1, SS1, SHFT, KEY, KEY, /* 64 - 71 */ ! 332: KEY, KEY, SS0, KEY, KEY, KEY, SS0, KEY, /* 72 - 79 */ ! 333: KEY, KEY, KEY, KEY /* 80 - 83 */ ! 334: }; ! 335: ! 336: /* ! 337: * German Tables for converting key code to ASCII. ! 338: * lmaptab specifies unshifted conversion, ! 339: * umaptab specifies shifted conversion, ! 340: * smaptab specifies the shift states which are active. ! 341: * An entry of XXX says the key is dead. ! 342: * An entry of SPC requires further processing. ! 343: * ! 344: * Key codes: ! 345: * ESC .. <- == 1 .. 14 ! 346: * -> .. \n == 15 .. 28 ! 347: * CTRL .. ` == 29 .. 41 ! 348: * ^Shift .. PrtSc == 42 .. 55 ! 349: * ALT .. CapsLock == 56 .. 58 ! 350: * F1 .. F10 == 59 .. 68 ! 351: * NumLock .. Del == 69 .. 83 ! 352: * ISO, F11, F12 == 86 .. 88 ! 353: */ ! 354: unsigned char de_agmaptab[] ={ /* Alt Gr */ ! 355: XXX, XXX,'\375','\374',XXX, XXX, XXX, /* 1 - 7 */ ! 356: '{', '[', ']', '}', '\\', XXX, XXX, XXX, /* 8 - 15 */ ! 357: '@', XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 16 - 23 */ ! 358: XXX, XXX, XXX, '~', XXX, XXX, XXX, XXX, /* 24 - 31 */ ! 359: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 32 - 39 */ ! 360: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 40 - 47 */ ! 361: XXX, XXX,'\346', XXX, XXX, XXX, XXX, XXX, /* 48 - 55 */ ! 362: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 56 - 63 */ ! 363: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 64 - 71 */ ! 364: XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, /* 72 - 79 */ ! 365: XXX, XXX, XXX, XXX, XXX, XXX, '|', XXX, /* 80 - 87 */ ! 366: XXX /* 88 */ ! 367: }; ! 368: ! 369: static unsigned char de_lmaptab[] ={ ! 370: ESCAPE_CHAR, '1', '2', '3', '4', '5', '6', /* 1 - 7 */ ! 371: '7', '8', '9', '0','\341','\'', '\b', '\t', /* 8 - 15 */ ! 372: 'q', 'w', 'e', 'r', 't', 'z', 'u', 'i', /* 16 - 23 */ ! 373: 'o', 'p','\201', '+', '\r', XXX, 'a', 's', /* 24 - 31 */ ! 374: 'd', 'f', 'g', 'h', 'j', 'k', 'l','\224', /* 32 - 39 */ ! 375: '\204','^', XXX, '#', 'y', 'x', 'c', 'v', /* 40 - 47 */ ! 376: 'b', 'n', 'm', ',', '.', SPC, XXX, SPC, /* 48 - 55 */ ! 377: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 378: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 379: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 380: SPC, SPC, SPC, SPC, XXX, XXX, '<', XXX, /* 80 - 87 */ ! 381: XXX /* 88 */ ! 382: }; ! 383: ! 384: static unsigned char de_umaptab[] ={ ! 385: ESCAPE_CHAR, '!', '"','\025', '$', '%', '&', /* 1 - 7 */ ! 386: '/', '(', ')', '=', '?', '`', '\b', SPC, /* 8 - 15 */ ! 387: 'Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', /* 16 - 23 */ ! 388: 'O', 'P','\232', '*', '\r', XXX, 'A', 'S', /* 24 - 31 */ ! 389: 'D', 'F', 'G', 'H', 'J', 'K', 'L','\231', /* 32 - 39 */ ! 390: '\216','\370',XXX,'\'', 'Y', 'X', 'C', 'V', /* 40 - 47 */ ! 391: 'B', 'N', 'M', ';', ':', SPC, XXX, SPC, /* 48 - 55 */ ! 392: XXX, ' ', XXX, SPC, SPC, SPC, SPC, SPC, /* 56 - 63 */ ! 393: SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC, /* 64 - 71 */ ! 394: SPC, SPC, '-', SPC, SPC, SPC, '+', SPC, /* 72 - 79 */ ! 395: SPC, SPC, SPC, SPC, XXX, XXX, '>', XXX, /* 80 - 87 */ ! 396: XXX /* 88 */ ! 397: }; ! 398: ! 399: static unsigned char de_smaptab[] ={ ! 400: SS0, SES, SS1, SES, SES, SES, SS1, /* 1 - 7 */ ! 401: SES, SES, SES, SES, SS1, SES, CTS, SES, /* 8 - 15 */ ! 402: LET, LET, LET, LET, LET, LET, LET, LET, /* 16 - 23 */ ! 403: LET, LET, SS1, SS1, CTS, SHFT, LET, LET, /* 24 - 31 */ ! 404: LET, LET, LET, LET, LET, LET, LET, SES, /* 32 - 39 */ ! 405: SES, SS1, SHFT, SS1, LET, LET, LET, LET, /* 40 - 47 */ ! 406: LET, LET, LET, SES, SES, SES, SHFT, SES, /* 48 - 55 */ ! 407: SHFT, SS1, SHFT, SS1, SS1, SS1, SS1, SS1, /* 56 - 63 */ ! 408: SS1, SS1, SS1, SS1, SS1, SHFT, KEY, KEY, /* 64 - 71 */ ! 409: KEY, KEY, SS0, KEY, KEY, KEY, SS0, KEY, /* 72 - 79 */ ! 410: KEY, KEY, KEY, KEY, SS0, SS0, SES, SS0, /* 80 - 87 */ ! 411: SS0 ! 412: }; ! 413: ! 414: ! 415: ! 416: /****************************** Functions *******************************/ ! 417: ! 418: int isrint(); ! 419: int istime(); ! 420: void isbatch(); ! 421: int mmstart(); ! 422: int isopen(); ! 423: int isclose(); ! 424: int isread(); ! 425: int mmwrite(); ! 426: int isioctl(); ! 427: void mmwatch(); ! 428: int isload(); ! 429: int isuload(); ! 430: int ispoll(); ! 431: int nulldev(); ! 432: int nonedev(); ! 433: ! 434: /************************** Configuration table *********************/ ! 435: ! 436: CON kbcon ={ ! 437: DFCHR|DFPOL, /* Flags */ ! 438: KB_MAJOR, /* Major index */ ! 439: isopen, /* Open */ ! 440: isclose, /* Close */ ! 441: nulldev, /* Block */ ! 442: isread, /* Read */ ! 443: mmwrite, /* Write */ ! 444: isioctl, /* Ioctl */ ! 445: nulldev, /* Powerfail */ ! 446: mmwatch, /* Timeout */ ! 447: isload, /* Load */ ! 448: isuload, /* Unload */ ! 449: ispoll /* Poll */ ! 450: }; ! 451: ! 452: /*********************** State variables / Patchables ***************/ ! 453: int islock; /* Keyboard locked flag */ ! 454: int isbusy; /* Raw input conversion busy */ ! 455: ! 456: static short shift; /* Overall shift state */ ! 457: static char scroll_lock; /* Scroll lock state */ ! 458: static char lshift_state = LSHIFT; /* Left shift alternate state */ ! 459: static char isfbuf[NFBUF]; /* Function key values */ ! 460: static char *isfval[NFKEY]; /* Function key string pointers */ ! 461: static int ledcmd; /* LED update command flag */ ! 462: static int extended; /* extended key scan count */ ! 463: static char extmode; /* use extended mode for this key */ ! 464: static char ext0seen; /* 0xE0 prefix seen */ ! 465: static int xlate = 1; /* scan code translation flag */ ! 466: ! 467: /* Configurable variables - see ker/conf/console/Space.c */ ! 468: extern int kb_lang; ! 469: ! 470: int isturbo = 0; ! 471: static int X11led; ! 472: static TIM tp; ! 473: ! 474: TTY istty = { ! 475: {0}, ! 476: {0}, ! 477: 0, ! 478: mmstart, ! 479: NULL, ! 480: 0, ! 481: 0 ! 482: }; ! 483: static silo_t in_silo; ! 484: static unsigned char *lmaptab, *umaptab, *smaptab, *agmaptab; ! 485: ! 486: /***************************** Code *****************************/ ! 487: ! 488: /* ! 489: * Load entry point. ! 490: * Do reset the keyboard because it gets terribly munged ! 491: * if you type during the boot. ! 492: */ ! 493: isload() ! 494: { ! 495: register short i;/* was: int i .. the loop below is hardly portable */ ! 496: ! 497: /* ! 498: * Set up keyboard tables ! 499: */ ! 500: ! 501: switch(kb_lang) { ! 502: case kb_lang_fr: ! 503: agmaptab = fr_agmaptab; ! 504: lmaptab = fr_lmaptab; ! 505: umaptab = fr_umaptab; ! 506: smaptab = fr_smaptab; ! 507: break; ! 508: case kb_lang_de: ! 509: agmaptab = de_agmaptab; ! 510: lmaptab = de_lmaptab; ! 511: umaptab = de_umaptab; ! 512: smaptab = de_smaptab; ! 513: break; ! 514: default: ! 515: agmaptab = 0; ! 516: lmaptab = us_lmaptab; ! 517: umaptab = us_umaptab; ! 518: smaptab = us_smaptab; ! 519: break; ! 520: } /* switch */ ! 521: ! 522: /* ! 523: * Reset keyboard if NOT an XT turbo. ! 524: */ ! 525: if ( ! isturbo ) { ! 526: outb(KBCTRL, 0x0C); /* Clock low */ ! 527: for (i = 10582; --i >= 0; ); /* For 20ms */ ! 528: outb(KBCTRL, 0xCC); /* Clock high */ ! 529: for (i = 0; --i != 0; ) ! 530: ; ! 531: i = inb(KBDATA); ! 532: outb(KBCTRL, 0xCC); /* Clear keyboard */ ! 533: outb(KBCTRL, 0x4D); /* Enable keyboard */ ! 534: } ! 535: ! 536: /* ! 537: * Enable mmwatch() invocation every second. ! 538: */ ! 539: drvl[KB_MAJOR].d_time = 1; ! 540: ! 541: /* ! 542: * Seize keyboard interrupt. ! 543: */ ! 544: setivec(1, isrint); ! 545: ! 546: /* ! 547: * Initialize video display. ! 548: */ ! 549: mmstart( &istty ); ! 550: } ! 551: ! 552: /* ! 553: * Unload entry point. ! 554: */ ! 555: isuload() ! 556: { ! 557: clrivec(1); ! 558: } ! 559: ! 560: ! 561: /* ! 562: * Open routine. ! 563: */ ! 564: isopen(dev, mode) ! 565: dev_t dev; ! 566: unsigned int mode; ! 567: { ! 568: register int s; ! 569: ! 570: if (minor(dev) != 0) { ! 571: u.u_error = ENXIO; ! 572: return; ! 573: } ! 574: if ((istty.t_flags&T_EXCL)!=0 && super()==0) { ! 575: u.u_error = ENODEV; ! 576: return; ! 577: } ! 578: ttsetgrp(&istty, dev, mode); ! 579: ! 580: s = sphi(); ! 581: if (istty.t_open++ == 0) ! 582: { initkeys(); /* init function keys */ ! 583: istty.t_flags = T_CARR; /* indicate "carrier" */ ! 584: ttopen(&istty); ! 585: } ! 586: spl(s); ! 587: updleds(); /* update keyboard status LEDS */ ! 588: } ! 589: ! 590: /* Init function keys */ ! 591: initkeys() ! 592: { register int i; ! 593: register char *cp1, *cp2; ! 594: ! 595: for (i=0; i<NFKEY; i++) ! 596: isfval[i] = 0; /* clear function key buffer */ ! 597: cp2 = isfbuf; /* pointer to key buffer */ ! 598: for (i=0; i<NFKEY; i++) ! 599: { isfval[i] = cp2; /* save pointer to key string */ ! 600: cp1 = deffuncs[i]; /* get init string pointer */ ! 601: while ((*cp2++ = *cp1++) != -1) /* copy key data */ ! 602: if (cp2 >= &isfbuf[NFBUF-3]) /* overflow? */ ! 603: return; ! 604: } ! 605: } ! 606: ! 607: /* ! 608: * Close a tty. ! 609: */ ! 610: isclose(dev) ! 611: { ! 612: register int s; ! 613: ! 614: s = sphi(); ! 615: if (--istty.t_open == 0) ! 616: { s = sphi(); ! 617: ttclose(&istty); ! 618: spl(s); ! 619: } ! 620: } ! 621: ! 622: /* ! 623: * Read routine. ! 624: */ ! 625: isread(dev, iop) ! 626: dev_t dev; ! 627: IO *iop; ! 628: { ! 629: ttread(&istty, iop, 0); ! 630: if (istty.t_oq.cq_cc) ! 631: mmtime(&istty); ! 632: } ! 633: ! 634: /* ! 635: * Ioctl routine. ! 636: */ ! 637: int ! 638: kbstate(action) ! 639: int action; ! 640: { ! 641: int i; ! 642: if (action == 1) { ! 643: timeout(&tp,20,kbstate,2); ! 644: outb(KBCTRL, 0xCC); /* Clock high */ ! 645: } ! 646: if (action == 2) { ! 647: i = inb(KBDATA); ! 648: outb(KBCTRL, 0xCC); /* Clear keyboard */ ! 649: outb(KBCTRL, 0x4D); /* Enable keyboard */ ! 650: } ! 651: } ! 652: ! 653: isioctl(dev, com, vec) ! 654: dev_t dev; ! 655: struct sgttyb *vec; ! 656: { ! 657: register int s; ! 658: ! 659: switch(com) { ! 660: #define KDDEBUG 0 ! 661: #if KDDEBUG ! 662: case KDMEMDISP: ! 663: { ! 664: struct kd_memloc* mem; ! 665: unsigned char ub, pb; ! 666: mem = vec; ! 667: pxcopy( mem->physaddr, &pb, 1, SEG_386_KD ); ! 668: ub = getubd( mem->vaddr ); ! 669: printf( "User's byte %x(%x), Physical byte %x, Addresses %x %x\n", ! 670: mem->ioflg, ub, pb, mem->vaddr, mem->physaddr ); ! 671: goto ioc_done;; ! 672: } ! 673: #endif ! 674: case KDMAPDISP: ! 675: { ! 676: struct kd_memloc* mem; ! 677: mem = vec; ! 678: #if KDDEBUG ! 679: printf( "mapPhysUser(%x, %x, %x) = %d\n", ! 680: mem->vaddr, mem->physaddr, mem->length, ! 681: #endif ! 682: mapPhysUser(mem->vaddr, mem->physaddr, mem->length) ! 683: #if KDDEBUG ! 684: ) ! 685: #endif ! 686: ; ! 687: } ! 688: case KDENABIO: ! 689: { ! 690: int i; ! 691: for (i = 0 ; i < 64 ; i++ ) ! 692: iomapAnd(0,i); ! 693: goto ioc_done;; ! 694: } ! 695: case KIOCSOUND: ! 696: { ! 697: if (vec) { ! 698: outb(TIMER_CTL, 0xB6); ! 699: outb(TIMER_CNT, (int)vec&0xFF); ! 700: outb(TIMER_CNT, (int)vec>>8); ! 701: outb(SPEAKER_CTL, inb(SPEAKER_CTL) | 03); /* Turn speaker on */ ! 702: } ! 703: else ! 704: outb(SPEAKER_CTL, inb(SPEAKER_CTL) & ~03 ); /* speaker off */ ! 705: goto ioc_done;; ! 706: } ! 707: case KDSKBMODE: ! 708: { ! 709: outb(KBCTRL, 0x0C); /* Clock low */ ! 710: timeout(&tp,3,kbstate,1); /* wait about 20-30ms */ ! 711: xlate = (int)vec; ! 712: goto ioc_done;; ! 713: } ! 714: case KDSETLED: ! 715: { ! 716: X11led = (int)vec; ! 717: updleds(); ! 718: goto ioc_done;; ! 719: } ! 720: ! 721: case TIOCSETF: ! 722: case TIOCGETF: ! 723: isfunction(com, (char *)vec); ! 724: goto ioc_done;; ! 725: case TIOCSHIFT: /* switch left-SHIFT and "\" */ ! 726: lshift_state = LSHIFTA; /* alternate values */ ! 727: lmaptab[41] = '\\'; ! 728: lmaptab[42] = XXX; ! 729: umaptab[41] = '|'; ! 730: umaptab[42] = XXX; ! 731: smaptab[41] = SS1; ! 732: smaptab[42] = SHFT; ! 733: goto ioc_done;; ! 734: case TIOCCSHIFT: /* normal (default) left-SHIFT and "\" */ ! 735: lshift_state = LSHIFT; /* normal values */ ! 736: lmaptab[41] = XXX; ! 737: lmaptab[42] = '\\'; ! 738: umaptab[41] = XXX; ! 739: umaptab[42] = '|'; ! 740: smaptab[41] = SHFT; ! 741: smaptab[42] = SS1; ! 742: goto ioc_done;; ! 743: } ! 744: s = sphi(); ! 745: ttioctl(&istty, com, vec); ! 746: spl(s); ! 747: ! 748: ioc_done: ! 749: return; ! 750: } ! 751: ! 752: /* ! 753: * Set and receive the function keys. ! 754: */ ! 755: isfunction(c, v) ! 756: int c; ! 757: char *v; ! 758: { ! 759: register char *cp; ! 760: register int i; ! 761: ! 762: if (c == TIOCGETF) { ! 763: for (cp = isfbuf; cp < &isfbuf[NFBUF]; cp++) ! 764: putubd(v++, *cp); ! 765: } else { ! 766: for (i=0; i<NFKEY; i++) /* zap current settings */ ! 767: isfval[i] = 0; ! 768: cp = isfbuf; /* pointer to key buffer */ ! 769: for (i=0; i<NFKEY; i++) { ! 770: isfval[i] = cp; /* save pointer to key string */ ! 771: while ((*cp++ = getubd(v++)) != -1) /* copy key data */ ! 772: if (cp >= &isfbuf[NFBUF-3]) /* overflow? */ ! 773: return; ! 774: } ! 775: } ! 776: } ! 777: ! 778: ! 779: /* ! 780: * Poll routine. ! 781: */ ! 782: ispoll( dev, ev, msec ) ! 783: dev_t dev; ! 784: int ev; ! 785: int msec; ! 786: { ! 787: return ttpoll(&istty, ev, msec); ! 788: } ! 789: ! 790: /* ! 791: * Receive interrupt. ! 792: */ ! 793: isrint() ! 794: { ! 795: register int c; ! 796: register int s; ! 797: register int r; ! 798: int savests; ! 799: int update_leds = 0; ! 800: ! 801: /* ! 802: * Schedule raw input handler if not already active. ! 803: */ ! 804: if ( isbusy == 0 ) { ! 805: isbusy = 1; ! 806: defer( isbatch, &istty ); ! 807: } ! 808: ! 809: /* ! 810: * Pull character from the data ! 811: * port. Pulse the KBFLAG in the control ! 812: * port to reset the data buffer. ! 813: */ ! 814: r = inb(KBDATA) & 0xFF; ! 815: c = inb(KBCTRL); ! 816: outb(KBCTRL, c|KBFLAG); ! 817: outb(KBCTRL, c); ! 818: if (!xlate) { ! 819: if (ledcmd) { ! 820: ledcmd = 0; ! 821: if (r == KBACK) { /* output to status LEDS */ ! 822: outb(KBDATA, X11led); ! 823: return; ! 824: } ! 825: } ! 826: isin(r); ! 827: return; ! 828: } ! 829: ! 830: #if KBDEBUG ! 831: printf("kbd: %d\n", r); /* print scan code/direction */ ! 832: #endif ! 833: if (ledcmd) { ! 834: ledcmd = 0; ! 835: if (r == KBACK) { /* output to status LEDS */ ! 836: c = scroll_lock & 1; ! 837: if (shift & NMLS) ! 838: c |= 2; ! 839: if (shift & CPLS) ! 840: c |= 4; ! 841: outb(KBDATA, c); ! 842: } ! 843: return; ! 844: } ! 845: if (extended > 0) { /* if multi-character seq, */ ! 846: --extended; /* ... ignore this char */ ! 847: return; ! 848: } ! 849: switch (r) { ! 850: case EXTENDED0: /* 0xE0 prefix found */ ! 851: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) { ! 852: ext0seen = 1; ! 853: return; ! 854: } ! 855: break; ! 856: case EXTENDED1: /* ignore extended sequences */ ! 857: extended = 5; ! 858: return; ! 859: case 0xFF: /* Overrun */ ! 860: return; ! 861: } ! 862: ! 863: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) { ! 864: if (ext0seen) { ! 865: ext0seen = 0; ! 866: extmode = 1; ! 867: } else ! 868: extmode = 0; ! 869: } ! 870: ! 871: c = (r & KEYSC) - 1; ! 872: /* ! 873: * Check for reset. ! 874: */ ! 875: if ((r&KEYUP) == 0 && c == DELETE && (shift&(CTS|ALS)) == (CTS|ALS)) ! 876: boot(); ! 877: ! 878: /* ! 879: * Track "shift" keys. ! 880: */ ! 881: s = smaptab[c]; ! 882: if (s&SHFT) { ! 883: if (r&KEYUP) { /* "shift" released */ ! 884: if (c == RSHIFT) ! 885: shift &= ~SRS; ! 886: else if (c == lshift_state) ! 887: shift &= ~SLS; ! 888: else if (c == KB_CTRL_KEY) ! 889: shift &= ~CTS; ! 890: else if (c == KB_ALT_KEY) { ! 891: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) ! 892: shift &= extmode ? ~AGS : ~ALS; ! 893: else ! 894: shift &= ~ALS; ! 895: } ! 896: } else { /* "shift" pressed */ ! 897: if (c == lshift_state) ! 898: shift |= SLS; ! 899: else if (c == RSHIFT) ! 900: shift |= SRS; ! 901: else if (c == KB_CTRL_KEY) ! 902: shift |= CTS; ! 903: else if (c == KB_ALT_KEY) { ! 904: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) ! 905: shift |= extmode ? AGS : ALS; ! 906: else ! 907: shift |= ALS; ! 908: } ! 909: else if (c == CAPLOCK) { ! 910: shift ^= CPLS; /* toggle cap lock */ ! 911: updleds(); ! 912: } else if (c == NUMLOCK) { ! 913: shift ^= NMLS; /* toggle num lock */ ! 914: updleds(); ! 915: } ! 916: } ! 917: return; ! 918: } ! 919: ! 920: /* ! 921: * No other key up codes of interest. ! 922: */ ! 923: if (r&KEYUP) ! 924: return; ! 925: ! 926: /* ! 927: * If the tty is not open the character is ! 928: * just tossed away. ! 929: */ ! 930: if (istty.t_open == 0) ! 931: return; ! 932: ! 933: /* ! 934: * Map character, based on the ! 935: * current state of the shift, control, alt graphics, ! 936: * meta (ALT) and lock flags. ! 937: */ ! 938: if ((shift & AGS) && (kb_lang == kb_lang_fr || kb_lang == kb_lang_de)) /* Alt Graphics ? */ ! 939: c = agmaptab[c]; ! 940: else if (shift & CTS) { ! 941: if (s == CTS) /* Map Ctrl (BS | NL) */ ! 942: c = (c == BACKSP) ? 0x7F : 0x0A; ! 943: else if (s==SS1 || s==LET) { ! 944: if((c = umaptab[c]) != SPC) /* Normal Ctrl map */ ! 945: c &= 0x1F; /* Clear bits 5-6 */ ! 946: } else ! 947: return; /* Ignore this char */ ! 948: } else if (s &= shift) { ! 949: if (shift & SES) { /* if shift on */ ! 950: if (s & (CPLS|NMLS)) /* if caps/num lock */ ! 951: c = lmaptab[c]; /* use unshifted */ ! 952: else ! 953: c = umaptab[c]; /* use shifted */ ! 954: } else { /* if shift not on */ ! 955: if (s & (CPLS|NMLS)) /* if caps/num lock */ ! 956: c = umaptab[c]; /* use shifted */ ! 957: else ! 958: c = lmaptab[c]; /* use unshifted */ ! 959: } ! 960: } else ! 961: c = lmaptab[c]; /* use unshifted */ ! 962: ! 963: /* ! 964: * Act on character. ! 965: */ ! 966: if (c == XXX) ! 967: return; /* char to ignore */ ! 968: ! 969: if (c != SPC) { /* not special char? */ ! 970: if (shift & ALS) /* ALT (meta bit)? */ ! 971: c |= 0x80; /* set meta */ ! 972: isin(c); /* send the char */ ! 973: } else ! 974: update_leds += isspecial(r); /* special chars */ ! 975: if (update_leds) { ! 976: savests = sphi(); ! 977: outb(KBDATA, LEDCMD); ! 978: ledcmd = 1; ! 979: spl(savests); ! 980: } ! 981: } ! 982: ! 983: isspecial(c) ! 984: int c; ! 985: { ! 986: register char *cp; ! 987: register int s; ! 988: int update_leds = 0; ! 989: ! 990: cp = 0; ! 991: ! 992: switch (c) { ! 993: case 15: /* cursor back tab */ ! 994: cp = ESCAPE_STRING "[Z"; ! 995: break; ! 996: case 53: ! 997: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) { ! 998: if (extmode) ! 999: cp = "/"; ! 1000: else ! 1001: if (shift & SES) ! 1002: cp = "\025"; ! 1003: else ! 1004: cp = "!"; ! 1005: } ! 1006: break; ! 1007: case 55: /* ignore PrtScr */ ! 1008: if(kb_lang == kb_lang_fr || kb_lang == kb_lang_de) { ! 1009: if (!extmode) ! 1010: cp = "*"; ! 1011: } ! 1012: break; ! 1013: case 59: case 60: case 61: case 62: case 63: /* Function keys */ ! 1014: case 64: case 65: case 66: case 67: case 68: ! 1015: /* offset to function string */ ! 1016: if ( shift & ALS ) ! 1017: cp = isfval[c-19]; /* alt-Fx */ ! 1018: else { if( (shift & (SES)) && (shift & CTS)) /*ctl-shift-Fx*/ ! 1019: cp = isfval[c-29]; ! 1020: else { if(shift & CTS) /* ctl-Fx */ ! 1021: cp = isfval[c-39]; ! 1022: else { if(shift & (SES)) /* shift-Fx */ ! 1023: cp = isfval[c-49]; ! 1024: else cp = isfval[c-59]; /* Fx */ ! 1025: }}} ! 1026: break; ! 1027: ! 1028: case 70: /* Scroll Lock -- stop/start output */ ! 1029: { ! 1030: static char cbuf[2]; ! 1031: ! 1032: cp = &cbuf[0]; /* working buffer */ ! 1033: if (!(istty.t_sgttyb.sg_flags&RAWIN)) { /* not if in RAW mode */ ! 1034: ++update_leds; ! 1035: if (istty.t_flags & T_STOP) { /* output stopped? */ ! 1036: cbuf[0] = istty.t_tchars.t_startc; /* start it */ ! 1037: scroll_lock = 0; ! 1038: } else { ! 1039: cbuf[0] = istty.t_tchars.t_stopc; /* stop output */ ! 1040: scroll_lock = 1; ! 1041: } ! 1042: } ! 1043: break; ! 1044: } ! 1045: ! 1046: case 79: /* 1/End */ ! 1047: case 80: /* 2/DOWN */ ! 1048: case 81: /* 3/PgDn */ ! 1049: case 82: /* 0/Ins */ ! 1050: case 83: /* ./Del */ ! 1051: --c; /* adjust code */ ! 1052: case 75: /* 4/LEFT */ ! 1053: case 76: /* 5 */ ! 1054: case 77: /* 6/RIGHT */ ! 1055: --c; /* adjust code */ ! 1056: case 71: /* 7/Home/Clear */ ! 1057: case 72: /* 8/UP */ ! 1058: case 73: /* 9/PgUp */ ! 1059: s = 0; /* start off with normal keypad */ ! 1060: if (shift & NMLS) /* num lock? */ ! 1061: s = 1; /* set shift pad */ ! 1062: if (shift & SES) /* shift? */ ! 1063: s ^= 1; /* toggle shift pad */ ! 1064: if (shift & AKPS) /* alternate pad? */ ! 1065: s = 2; /* set alternate pad */ ! 1066: if (extmode) /* not from keypad? */ ! 1067: s = 0; /* force normal sequence */ ! 1068: cp = keypad[c-71][s]; /* get keypad value */ ! 1069: break; ! 1070: } ! 1071: if (cp) /* send string */ ! 1072: while ((* cp != 0) && (* cp != -1)) ! 1073: isin (* cp ++ & 0xFF); ! 1074: return update_leds; ! 1075: } ! 1076: ! 1077: /** ! 1078: * ! 1079: * void ! 1080: * ismmfunc( c ) -- process keyboard related output escape sequences ! 1081: * char c; ! 1082: */ ! 1083: void ! 1084: ismmfunc(c) ! 1085: register int c; ! 1086: { ! 1087: switch (c) { ! 1088: case 't': /* Enter numlock */ ! 1089: shift |= NMLS; ! 1090: updleds(); /* update LED status */ ! 1091: break; ! 1092: case 'u': /* Leave numlock */ ! 1093: shift &= ~NMLS; ! 1094: updleds(); /* update LED status */ ! 1095: break; ! 1096: case '=': /* Enter alternate keypad */ ! 1097: shift |= AKPS; ! 1098: break; ! 1099: case '>': /* Exit alternate keypad */ ! 1100: shift &= ~AKPS; ! 1101: break; ! 1102: case 'c': /* Reset terminal */ ! 1103: islock = 0; ! 1104: shift = 0; ! 1105: initkeys(); ! 1106: updleds(); /* update LED status */ ! 1107: break; ! 1108: } ! 1109: } ! 1110: ! 1111: /** ! 1112: * ! 1113: * void ! 1114: * isin( c ) -- append character to raw input silo ! 1115: * char c; ! 1116: */ ! 1117: static ! 1118: isin( c ) ! 1119: register int c; ! 1120: { ! 1121: int cache_it = 1; ! 1122: TTY * tp = &istty; ! 1123: ! 1124: /* ! 1125: * If using software incoming flow control, process and ! 1126: * discard t_stopc and t_startc. ! 1127: */ ! 1128: if (_IS_IXON_MODE (tp)) { ! 1129: if (_IS_START_CHAR (tp, c) || ! 1130: (_IS_IXANY_MODE (tp) && (tp->t_flags & T_STOP) != 0)) { ! 1131: tp->t_flags &= ~(T_STOP | T_XSTOP); ! 1132: ttstart(tp); ! 1133: cache_it = 0; ! 1134: } else if (_IS_STOP_CHAR (tp, c)) { ! 1135: if ((tp->t_flags&T_STOP) == 0) ! 1136: tp->t_flags |= (T_STOP | T_XSTOP); ! 1137: cache_it = 0; ! 1138: } ! 1139: } ! 1140: ! 1141: /* ! 1142: * Cache received character. ! 1143: */ ! 1144: if (cache_it) { ! 1145: in_silo.si_buf[ in_silo.si_ix ] = c; ! 1146: ! 1147: if ( ++in_silo.si_ix >= sizeof(in_silo.si_buf) ) ! 1148: in_silo.si_ix = 0; ! 1149: } ! 1150: } ! 1151: ! 1152: /** ! 1153: * ! 1154: * void ! 1155: * isbatch() -- raw input conversion routine ! 1156: * ! 1157: * Action: Enable the video display. ! 1158: * Canonize the raw input silo. ! 1159: * ! 1160: * Notes: isbatch() was scheduled as a deferred process by isrint(). ! 1161: */ ! 1162: static void ! 1163: isbatch( tp ) ! 1164: register TTY * tp; ! 1165: { ! 1166: register int c; ! 1167: static int lastc; ! 1168: ! 1169: /* ! 1170: * Ensure video display is enabled. ! 1171: */ ! 1172: mm_von(); ! 1173: ! 1174: isbusy = 0; ! 1175: ! 1176: /* ! 1177: * Process all cached characters. ! 1178: */ ! 1179: while ( in_silo.si_ix != in_silo.si_ox ) { ! 1180: ! 1181: /* ! 1182: * Get next cached char. ! 1183: */ ! 1184: c = in_silo.si_buf[ in_silo.si_ox ]; ! 1185: ! 1186: if ( in_silo.si_ox >= sizeof(in_silo.si_buf) - 1 ) ! 1187: in_silo.si_ox = 0; ! 1188: else ! 1189: in_silo.si_ox++; ! 1190: ! 1191: if (islock == 0 || _IS_INTERRUPT_CHAR (tp, c) || ! 1192: _IS_QUIT_CHAR (tp, c)) { ! 1193: ttin (tp, c); ! 1194: } else if (c == 'b' && lastc == ESCAPE_CHAR) { ! 1195: islock = 0; ! 1196: ttin (tp, lastc); ! 1197: ttin (tp, c); ! 1198: } else if (c == 'c' && lastc == ESCAPE_CHAR) { ! 1199: ttin (tp, lastc); ! 1200: ttin (tp, c); ! 1201: } else ! 1202: putchar ('\a'); ! 1203: ! 1204: lastc = c; ! 1205: } ! 1206: } ! 1207: ! 1208: /* ! 1209: * update the keyboard status LEDS ! 1210: */ ! 1211: updleds() ! 1212: { ! 1213: int s; ! 1214: ! 1215: s = sphi(); ! 1216: outb(KBDATA, LEDCMD); ! 1217: ledcmd = 1; ! 1218: spl(s); ! 1219: } ! 1220: ! 1221: /* ! 1222: * unlock the scroll in case an interrupt character is received ! 1223: */ ! 1224: kbunscroll() ! 1225: { ! 1226: scroll_lock = 0; ! 1227: updleds(); ! 1228: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.