![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nkb.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.386|
Return to nkb.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386 |
1.1 ! root 1: /* ! 2: * User configurable AT keyboard/display driver. ! 3: * 286/386 AT COHERENT ! 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 <errno.h> ! 13: #include <sys/stat.h> ! 14: #include <sys/tty.h> ! 15: #include <signal.h> ! 16: #include <sys/seg.h> ! 17: #include <sys/sched.h> ! 18: #include <sys/kb.h> ! 19: #include <sys/devices.h> ! 20: #include <sys/silo.h> ! 21: ! 22: #define ISVEC 1 /* Keyboard interrupt vector */ ! 23: ! 24: #if DEBUG ! 25: #define KBDEBUG(x) printf(x) /* debugging output */ ! 26: #define KBDEBUG2(x,y) printf(x,y) /* debugging output */ ! 27: #define KBDEBUG3(x,y,z) printf(x,y,z) /* debugging output */ ! 28: #else ! 29: #define KBDEBUG(x) /* no output */ ! 30: #define KBDEBUG2(x,y) /* no output */ ! 31: #define KBDEBUG3(x,y,z) /* no output */ ! 32: #endif ! 33: ! 34: /* ! 35: * values for kbstate ! 36: */ ! 37: #define KB_IDLE 0 /* nothing going on right now */ ! 38: #define KB_SINGLE 1 /* sent a single byte cmd to the kbd */ ! 39: #define KB_DOUBLE_1 2 /* sent 1st byte of 2-byte cmd to kbd */ ! 40: #define KB_DOUBLE_2 3 /* sent 2nd byte of 2-byte cmd to kbd */ ! 41: ! 42: /* ! 43: * patchable params for non-standard keyboards ! 44: */ ! 45: int KBDATA = 0x60; /* Keyboard data */ ! 46: int KBCTRL = 0x61; /* Keyboard control */ ! 47: int KBSTS_CMD = 0x64; /* Keyboard status/command */ ! 48: int KBFLAG = 0x80; /* Keyboard reset flag */ ! 49: int KBBOOT = 1; /* 0: disallow reboot from keyboard */ ! 50: int KBTIMEOUT = 10000; /* shouldn't need this much */ ! 51: int KBCMDBYTE = 0x05; /* no translation */ ! 52: ! 53: /* ! 54: * KBSTATUS bits ! 55: */ ! 56: #define STS_OBUF_FULL 0x01 /* kbd output buffer full */ ! 57: #define STS_IBUF_FULL 0x02 /* kbd input buffer full */ ! 58: #define STS_SYSTEM 0x04 ! 59: #define STS_CMD_DATA 0x08 /* 1: command or status */ ! 60: #define STS_INHIBIT 0x10 /* 0: keyboard inhibited */ ! 61: #define STS_AUX_OBUF_FULL 0x20 ! 62: #define STS_TIMEOUT 0x40 /* general timeout */ ! 63: #define STS_PAR_ERR 0x80 /* parity error */ ! 64: ! 65: /* ! 66: * The following are magic commands which read from or write to the ! 67: * controller command byte. These get output to the KBSTS_CMD port. ! 68: */ ! 69: #define C_READ_CMD 0x20 /* read controller command byte */ ! 70: #define C_WRITE_CMD 0x60 /* write controller command byte */ ! 71: #define C_TRANSLATE 0x40 /* translate enable bit in cmd byte */ ! 72: ! 73: /* ! 74: * Globals: ! 75: * The 286 keyboard mapping table is too large to fit into kernel data space, ! 76: * so we need to allocate a segment to it. 386 is easy. ! 77: * The function keys tend to be small and tend to change substantially ! 78: * more often than the mapping table, so we keep them in the kernel data space. ! 79: */ ! 80: static unsigned shift; /* state of all shift/lock keys */ ! 81: static unsigned char **funkeyp = 0; /* ptr to array of func. keys ptrs */ ! 82: static FNKEY *fnkeys = 0; /* pointer to structure of values */ ! 83: static unsigned fklength; /* length of k_fnval field in fnkeys */ ! 84: static unsigned prev_cmd; /* previous command sent to KBD */ ! 85: static unsigned cmd2; /* 2nd byte of command to KBD */ ! 86: static unsigned sh_index; /* shift/lock state index */ ! 87: #ifdef _I386 ! 88: static KBTBL kb[MAX_KEYS]; /* keyboard table */ ! 89: #else ! 90: static SEG *kbsegp; /* keyboard table segment */ ! 91: #endif ! 92: ! 93: /* ! 94: * State variables. ! 95: */ ! 96: int islock; /* Keyboard locked flag */ ! 97: int isbusy; /* Raw input conversion busy */ ! 98: static char table_loaded; /* true == keyboard table resident */ ! 99: static char fk_loaded; /* true == function keys resident */ ! 100: static int kbstate = KB_IDLE; /* current keyboard state */ ! 101: ! 102: /* ! 103: * Functions. ! 104: */ ! 105: int isrint(); ! 106: int istime(); ! 107: void isbatch(); ! 108: int mmstart(); ! 109: int isopen(); ! 110: int isclose(); ! 111: int isread(); ! 112: int mmwrite(); ! 113: int isioctl(); ! 114: void mmwatch(); ! 115: int isload(); ! 116: int isuload(); ! 117: int ispoll(); ! 118: int nulldev(); ! 119: int nonedev(); ! 120: int updleds(); ! 121: ! 122: static int isioctl0(); ! 123: ! 124: /* ! 125: * Configuration table. ! 126: */ ! 127: CON iscon ={ ! 128: DFCHR|DFPOL, /* Flags */ ! 129: KB_MAJOR, /* Major index */ ! 130: isopen, /* Open */ ! 131: isclose, /* Close */ ! 132: nulldev, /* Block */ ! 133: isread, /* Read */ ! 134: mmwrite, /* Write */ ! 135: #ifdef _I386 ! 136: isioctl0, /* Ioctl */ ! 137: #else ! 138: isioctl, /* Ioctl */ ! 139: #endif ! 140: nulldev, /* Powerfail */ ! 141: mmwatch, /* Timeout */ ! 142: isload, /* Load */ ! 143: isuload, /* Unload */ ! 144: ispoll /* Poll */ ! 145: }; ! 146: ! 147: /* ! 148: * Terminal structure. ! 149: */ ! 150: TTY istty = { ! 151: {0}, {0}, 0, mmstart, NULL, 0, 0 ! 152: }; ! 153: ! 154: static silo_t in_silo; ! 155: ! 156: /* ! 157: * Load entry point. ! 158: */ ! 159: isload() ! 160: { ! 161: kbstate = KB_IDLE; ! 162: table_loaded = 0; /* no keyboard table yet */ ! 163: fk_loaded = 0; /* no Fn keys yet */ ! 164: ! 165: /* ! 166: * Enable mmwatch() invocation every second. ! 167: */ ! 168: drvl[KB_MAJOR].d_time = 1; ! 169: ! 170: /* ! 171: * Seize keyboard interrupt. ! 172: */ ! 173: setivec(ISVEC, isrint); ! 174: ! 175: /* ! 176: * Initiailize video display. ! 177: */ ! 178: mmstart(&istty); ! 179: ! 180: #ifndef _I386 ! 181: /* ! 182: * Allocate a 286 segment to store the in-core keyboard table. ! 183: * This would be a lot more convenient in kernel data space, ! 184: * but small model COHERENT doesn't have that luxury. ! 185: */ ! 186: kbsegp = salloc((fsize_t)MAX_TABLE_SIZE, SFSYST|SFNSWP|SFHIGH); ! 187: if (kbsegp == (SEG *)0) ! 188: printf("kb: unable to allocate keyboard table segment\n"); ! 189: #endif ! 190: fklength = 0; ! 191: KBDEBUG("Exiting kbload()\n"); ! 192: } ! 193: ! 194: /* ! 195: * Unload entry point. ! 196: */ ! 197: isuload() ! 198: { ! 199: if (kbstate != KB_IDLE) ! 200: printf("kb: keyboard busy during unload\n"); ! 201: clrivec(ISVEC); ! 202: #ifndef _I386 ! 203: if (kbsegp != (SEG *)0) { ! 204: table_loaded = 0; ! 205: sfree(kbsegp); ! 206: } ! 207: #endif ! 208: } ! 209: ! 210: /* ! 211: * Open routine. ! 212: */ ! 213: isopen(dev, mode) ! 214: dev_t dev; ! 215: unsigned int mode; ! 216: { ! 217: register int s; ! 218: ! 219: KBDEBUG(" kbopen()"); ! 220: if (minor(dev) != 0) { ! 221: u.u_error = ENXIO; ! 222: return; ! 223: } ! 224: if ((istty.t_flags&T_EXCL) != 0 && !super()) { ! 225: u.u_error = ENODEV; ! 226: return; ! 227: } ! 228: ttsetgrp(&istty, dev, mode); ! 229: ! 230: s = sphi(); ! 231: if (istty.t_open++ == 0) { ! 232: istty.t_flags = T_CARR; /* indicate "carrier" */ ! 233: ttopen(&istty); ! 234: } ! 235: spl(s); ! 236: #if 0 ! 237: updleds(); /* update keyboard status LEDS */ ! 238: #endif ! 239: } ! 240: ! 241: /* ! 242: * Close a tty. ! 243: */ ! 244: isclose(dev) ! 245: { ! 246: register int s; ! 247: ! 248: s = sphi(); ! 249: if (--istty.t_open == 0) { ! 250: ttclose(&istty); ! 251: } ! 252: spl(s); ! 253: } ! 254: ! 255: /* ! 256: * Read routine. ! 257: */ ! 258: isread(dev, iop) ! 259: dev_t dev; ! 260: IO *iop; ! 261: { ! 262: ttread(&istty, iop, 0); ! 263: if (istty.t_oq.cq_cc) ! 264: mmtime(&istty); ! 265: } ! 266: ! 267: /* ! 268: * Ioctl routine. ! 269: * nb: archaic TIOCSHIFT and TIOCCSHIFT no longer needed/supported. ! 270: */ ! 271: #ifdef _I386 ! 272: isioctl0(dev, com, vec) ! 273: dev_t dev; ! 274: struct sgttyb *vec; ! 275: { ! 276: tioc286(dev, com, vec, isioctl); ! 277: } ! 278: #endif ! 279: ! 280: isioctl(dev, com, vec) ! 281: dev_t dev; ! 282: struct sgttyb *vec; ! 283: { ! 284: register int s; ! 285: ! 286: switch (com) { ! 287: case TIOCSETF: ! 288: case TIOCGETF: ! 289: isfunction(com, (char *)vec); ! 290: break; ! 291: case TIOCSETKBT: ! 292: issettable(vec); ! 293: break; ! 294: case TIOCGETKBT: ! 295: isgettable(vec); ! 296: break; ! 297: default: /* pass to TTY driver */ ! 298: s = sphi(); ! 299: ttioctl(&istty, com, vec); ! 300: spl(s); ! 301: break; ! 302: } ! 303: } ! 304: ! 305: /* ! 306: * Set the in-core keyboard mapping table. ! 307: * The table is sorted by scan code prior to calling ioctl(). ! 308: * All unused table entries (holes in the scan code map) have ! 309: * a zero for the k_key field. ! 310: * This makes key lookup at interrupt time fast by using the scan code ! 311: * as an index into the table. ! 312: */ ! 313: issettable(vec) ! 314: char *vec; ! 315: { ! 316: register unsigned i; ! 317: register int s; ! 318: int timeout; ! 319: static KBTBL this_key; /* current key from kbd table */ ! 320: unsigned int cmd_byte; ! 321: #ifndef _I386 ! 322: register faddr_t faddr; /* address of keyboard table */ ! 323: #endif ! 324: ! 325: KBDEBUG(" TIOCSETKBT"); ! 326: kb_cmd2(K_SCANCODE_CMD, 3); /* select set 3 */ ! 327: kb_cmd(K_ALL_TMB_CMD); /* default: TMB for all keys */ ! 328: #ifndef _I386 ! 329: faddr = kbsegp->s_faddr; ! 330: #endif ! 331: for (i = 0; i < MAX_KEYS; ++i) { ! 332: ukcopy(vec, &this_key, sizeof(this_key)); ! 333: #ifdef _I386 ! 334: kb[i] = this_key; /* store away */ ! 335: #else ! 336: kfcopy(&this_key, faddr, sizeof(this_key)); ! 337: faddr += sizeof(this_key); ! 338: #endif ! 339: vec += sizeof(this_key); ! 340: if (this_key.k_key != i && this_key.k_key != 0) { ! 341: printf("kb: incorrect or unsorted table entry %d\n", i); ! 342: #ifdef _I386 ! 343: u.u_error = EINVAL; ! 344: #else ! 345: u.u_error = EBADFMT; ! 346: #endif ! 347: return; ! 348: } ! 349: if (this_key.k_key != i) ! 350: continue; /* no key */ ! 351: switch (this_key.k_flags&TMODE) { ! 352: case T: /* typematic */ ! 353: kb_cmd2(K_KEY_T_CMD, i); ! 354: break; ! 355: case M: /* make only */ ! 356: kb_cmd2(K_KEY_M_CMD, i); ! 357: break; ! 358: case MB: /* make/break */ ! 359: kb_cmd2(K_KEY_MB_CMD, i); ! 360: break; ! 361: case TMB: /* typematic make/break */ ! 362: break; /* this is the default */ ! 363: default: ! 364: printf("kb: bad key mode\n"); ! 365: } ! 366: } ! 367: updleds(); ! 368: kb_cmd2(K_SCANCODE_CMD, 3); /* select set 3 */ ! 369: kb_cmd(K_ENABLE_CMD); /* start scanning */ ! 370: /* ! 371: * The following code disables translation from the on-board ! 372: * keyboard/aux controller. Without disabling translation, the ! 373: * received scan codes still look like code set 1 codes even ! 374: * though we put the keyboard controller in scan code set 3. ! 375: * Yes, this is progress.... ! 376: */ ! 377: #if 0 ! 378: while (inb(KBSTS_CMD) & STS_IBUF_FULL) ! 379: ; ! 380: outb(KBSTS_CMD, C_READ_CMD); /* read controller cmd byte */ ! 381: while (!(inb(KBSTS_CMD) & STS_OBUF_FULL)) ! 382: ; ! 383: cmd_byte = inb(KBDATA); ! 384: KBDEBUG2(" cmd_byte=%x", cmd_byte); ! 385: #endif ! 386: timeout = KBTIMEOUT; ! 387: s = sphi(); ! 388: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0) ! 389: ; ! 390: outb(KBSTS_CMD, C_WRITE_CMD); /* write controller cmd byte */ ! 391: for (timeout = 50; --timeout > 0;) ! 392: ; ! 393: timeout = KBTIMEOUT; ! 394: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0) ! 395: ; ! 396: outb(KBDATA, KBCMDBYTE); /* turn off translation */ ! 397: timeout = KBTIMEOUT; ! 398: while ((inb(KBSTS_CMD) & STS_IBUF_FULL) && --timeout > 0) ! 399: ; ! 400: spl(s); ! 401: #if DEBUG ! 402: kb_cmd2(K_SCANCODE_CMD, 0); /* query s.c. mode */ ! 403: #endif ! 404: ++table_loaded; ! 405: } ! 406: ! 407: /* ! 408: * Get the in-core keyboard mapping table and pass it to the user. ! 409: */ ! 410: isgettable(vec) ! 411: char *vec; ! 412: { ! 413: #ifdef _I386 ! 414: KBDEBUG(" TIOCGETKBT"); ! 415: kucopy(kb, vec, sizeof(kb)); ! 416: #else ! 417: register unsigned i; ! 418: register faddr_t faddr; /* address of keyboard table */ ! 419: static KBTBL this_key; /* current key from kbd table */ ! 420: ! 421: KBDEBUG(" TIOCGETKBT"); ! 422: faddr = kbsegp->s_faddr; ! 423: for (i = 0; i < MAX_KEYS; ++i) { ! 424: fkcopy(faddr, &this_key, sizeof(this_key)); ! 425: kucopy(&this_key, vec, sizeof(this_key)); ! 426: faddr += sizeof(this_key); ! 427: vec += sizeof(this_key); ! 428: } ! 429: #endif ! 430: } ! 431: ! 432: ! 433: /* ! 434: * Set and receive the function keys. ! 435: */ ! 436: isfunction(c, v) ! 437: int c; ! 438: FNKEY *v; ! 439: { ! 440: register unsigned char *cp; ! 441: register unsigned i; ! 442: unsigned char numkeys = 0; ! 443: ! 444: if (c == TIOCGETF) { ! 445: KBDEBUG(" TIOCGETF"); ! 446: if (!fk_loaded) ! 447: u.u_error = EINVAL; ! 448: else ! 449: kucopy(fnkeys, v, fklength); /* copy ours to user */ ! 450: } else { /* TIOCSETF */ ! 451: /* ! 452: * If we had a previous function key arena, free it up. ! 453: * Since we don't know how large the function key arena will ! 454: * be, we must size it in the user data space prior to ! 455: * (re)kalloc()'ing it. This is ugly, but a helluva lot better ! 456: * than the old driver which used a hard coded limit of 150! ! 457: */ ! 458: KBDEBUG(" TIOCSETF"); ! 459: fk_loaded = 0; ! 460: if (fnkeys != (FNKEY *)0) ! 461: kfree(fnkeys); /* free old arena */ ! 462: if (funkeyp != NULL) ! 463: kfree(funkeyp); /* free old ptr array */ ! 464: ukcopy(&v->k_nfkeys, &numkeys, sizeof(numkeys)); ! 465: fklength = sizeof(FNKEY); ! 466: cp = v->k_fnval; ! 467: for (i = 0; i < numkeys; i++) { ! 468: do { ! 469: ++fklength; ! 470: } while (getubd(cp++) != DELIM); ! 471: } ! 472: fnkeys = (FNKEY *)kalloc(fklength); ! 473: funkeyp = (unsigned char **)kalloc(numkeys * sizeof(char *)); ! 474: if (fnkeys == (FNKEY *)0 || funkeyp == NULL) { ! 475: if (fnkeys != (FNKEY *)0) { ! 476: kfree(fnkeys); ! 477: fnkeys = 0; ! 478: } ! 479: if (funkeyp != NULL) { ! 480: kfree(funkeyp); ! 481: funkeyp = 0; ! 482: } ! 483: u.u_error = ENOMEM; ! 484: return; ! 485: } ! 486: cp = fnkeys->k_fnval; /* point to Fn ... */ ! 487: v = v->k_fnval; /* ... key arena */ ! 488: for (i = 0; i < numkeys; i++) { ! 489: funkeyp[i] = cp; /* save pointer */ ! 490: while ((*cp++ = getubd(v++)) != DELIM) /* copy key */ ! 491: ; ! 492: } ! 493: fnkeys->k_nfkeys = numkeys; ! 494: fk_loaded = 1; ! 495: } ! 496: } ! 497: ! 498: ! 499: /* ! 500: * Poll routine. ! 501: */ ! 502: ispoll(dev, ev, msec) ! 503: dev_t dev; ! 504: int ev; ! 505: int msec; ! 506: { ! 507: return ttpoll(&istty, ev, msec); ! 508: } ! 509: ! 510: /* ! 511: * Receive interrupt. ! 512: */ ! 513: isrint() ! 514: { ! 515: register unsigned c; ! 516: register unsigned r; ! 517: static char keyup; ! 518: ! 519: /* ! 520: * Schedule raw input handler if not already active. ! 521: */ ! 522: if (!isbusy) { ! 523: defer(isbatch, &istty); ! 524: isbusy = 1; ! 525: } ! 526: ! 527: /* ! 528: * Pull character from the data ! 529: * port. Pulse the KBFLAG in the control ! 530: * port to reset the data buffer. ! 531: */ ! 532: r = inb(KBDATA) & 0xFF; ! 533: c = inb(KBCTRL); ! 534: outb(KBCTRL, c|KBFLAG); ! 535: outb(KBCTRL, c); ! 536: ! 537: /* ! 538: * check returned value from keyboard to see if it's a command ! 539: * or status back to us. If not, it we assume that it's a key code. ! 540: */ ! 541: KBDEBUG2(" intr(%x)", r); ! 542: switch (r) { ! 543: case K_BREAK: ! 544: keyup = 1; /* key going up */ ! 545: break; ! 546: case K_ECHO_R: ! 547: case K_BAT_OK: ! 548: break; /* very nice, but ignored */ ! 549: case K_BAT_BAD: ! 550: printf("kb: keyboard BAT failed\n"); ! 551: break; ! 552: case K_RESEND: ! 553: KBDEBUG("\nkb: request to resend command\n"); ! 554: outb(KBDATA, prev_cmd); ! 555: break; ! 556: case K_OVERRUN_23: ! 557: printf("kb: keyboard buffer overrun\n"); ! 558: break; ! 559: case K_ACK: ! 560: /* ! 561: * we received an ACKnowledgement from the keyboard. ! 562: * advance the state machine and continue. ! 563: */ ! 564: KBDEBUG(" ACK"); ! 565: switch (kbstate) { ! 566: case KB_IDLE: /* shouldn't happen */ ! 567: printf("kb: ACK while keyboard idle\n"); ! 568: break; ! 569: case KB_SINGLE: /* done with 1-byte command */ ! 570: case KB_DOUBLE_2: /* done w/ 2nd of 2-byte cmd */ ! 571: kbstate = KB_IDLE; ! 572: wakeup(&kbstate); ! 573: break; ! 574: case KB_DOUBLE_1: ! 575: kbstate = KB_DOUBLE_2; ! 576: outb(KBDATA, cmd2); ! 577: break; ! 578: default: ! 579: printf("kb: bad kbstate %d\n", kbstate); ! 580: break; ! 581: } ! 582: break; ! 583: default: ! 584: process_key(r, keyup); ! 585: keyup = 0; ! 586: } ! 587: } ! 588: ! 589: /* ! 590: * Process a key given its scan code and direction. ! 591: * ! 592: * In this table driven version of the keyboard driver, we trade off the ! 593: * code complexity associated with all the black magic that used to be ! 594: * performed on a per-key basis with the increased memory requirements ! 595: * associated with the table driven approach. ! 596: */ ! 597: process_key(key, up) ! 598: unsigned key; ! 599: int up; ! 600: { ! 601: register unsigned char *cp; ! 602: KBTBL key_vals; /* table values for this key */ ! 603: unsigned val; ! 604: unsigned char flags; ! 605: ! 606: KBDEBUG3(" proc(%x %s)", key, (up ? "up" : "down")); ! 607: if (!table_loaded) ! 608: return; /* throw away key */ ! 609: #ifdef _I386 ! 610: key_vals = kb[key]; ! 611: #else ! 612: fkcopy(kbsegp->s_faddr + (key * sizeof(KBTBL)), ! 613: &key_vals, sizeof(key_vals)); ! 614: #endif ! 615: if (key_vals.k_key != key) /* empty entry */ ! 616: return; ! 617: flags = key_vals.k_flags; ! 618: ! 619: if (flags & S) { /* some shift/lock key ? */ ! 620: switch (key_vals.k_val[BASE]) { ! 621: case caps: ! 622: case num: ! 623: if (!up) { ! 624: shift ^= (1 << key_vals.k_val[BASE]); ! 625: updleds2(); ! 626: } ! 627: break; ! 628: case scroll: ! 629: if (!up) { ! 630: shift ^= (1 << key_vals.k_val[BASE]); ! 631: updleds2(); ! 632: if (!(istty.t_sgttyb.sg_flags&RAWIN)) { ! 633: if (istty.t_flags & T_STOP) { ! 634: isin(istty.t_tchars.t_startc); ! 635: } else { ! 636: isin(istty.t_tchars.t_stopc); ! 637: } ! 638: } ! 639: } ! 640: break; ! 641: default: ! 642: if (up) ! 643: shift &= ~(1 << key_vals.k_val[BASE]); ! 644: else ! 645: shift |= (1 << key_vals.k_val[BASE]); ! 646: break; ! 647: } ! 648: /* ! 649: * Calculate the shift index based upon the state of ! 650: * the shift and lock keys. ! 651: */ ! 652: sh_index = BASE; /* default condition */ ! 653: if (shift & (1 << altgr)) ! 654: sh_index = ALT_GR; ! 655: else { ! 656: if (shift & ((1 << lalt)|(1 << ralt))) ! 657: sh_index |= ALT; ! 658: if (shift & ((1 << lctrl)|(1 << rctrl))) ! 659: sh_index |= CTRL; ! 660: if (shift & ((1 << lshift)|(1 << rshift))) ! 661: sh_index |= SHIFT; ! 662: } ! 663: return; ! 664: } /* if (flags & S) */ ! 665: ! 666: /* ! 667: * If the tty is not open or the key has no value in the current ! 668: * shift state, the key is just tossed away. ! 669: */ ! 670: if (up || !istty.t_open || key_vals.k_val[sh_index] == none) ! 671: return; ! 672: if (((flags & C) && (shift & (1 << caps))) ! 673: || ((flags & N) && (shift & (1 << num)))) ! 674: val = key_vals.k_val[sh_index^SHIFT]; ! 675: else ! 676: val = key_vals.k_val[sh_index]; ! 677: ! 678: /* ! 679: * Check for function key or special key implemented as ! 680: * a function key (reboot == f0, tab and back-tab, etc). ! 681: */ ! 682: if (flags & F) { ! 683: if (val == 0 && !up && KBBOOT) ! 684: boot(); ! 685: if (!fk_loaded || val >= fnkeys->k_nfkeys) ! 686: return; ! 687: if ((cp = funkeyp[val]) == NULL) /* has a value? */ ! 688: return; ! 689: while (*cp != DELIM) ! 690: isin(*cp++); /* queue up Fn key value */ ! 691: return; ! 692: } ! 693: ! 694: /* ! 695: * Normal key processing. ! 696: */ ! 697: isin(val); /* send the char */ ! 698: return; ! 699: } ! 700: ! 701: /** ! 702: * ! 703: * void ! 704: * ismmfunc(c) -- process keyboard related output escape sequences ! 705: * char c; ! 706: */ ! 707: void ! 708: ismmfunc(c) ! 709: register int c; ! 710: { ! 711: switch (c) { ! 712: case 't': /* Enter numlock */ ! 713: shift |= (1 << num); ! 714: updleds(); /* update LED status */ ! 715: break; ! 716: case 'u': /* Leave numlock */ ! 717: shift &= ~(1 << num); ! 718: updleds(); /* update LED status */ ! 719: break; ! 720: case '=': /* Enter alternate keypad -- ignored */ ! 721: case '>': /* Exit alternate keypad -- ignored */ ! 722: break; ! 723: case 'c': /* Reset terminal */ ! 724: islock = 0; ! 725: break; ! 726: } ! 727: } ! 728: ! 729: /** ! 730: * ! 731: * void ! 732: * isin(c) -- append character to raw input silo ! 733: * char c; ! 734: */ ! 735: static ! 736: isin(c) ! 737: register int c; ! 738: { ! 739: int cache_it = 1; ! 740: TTY * tp = &istty; ! 741: void ttstart(); ! 742: ! 743: /* ! 744: * If using software incoming flow control, process and ! 745: * discard t_stopc and t_startc. ! 746: */ ! 747: if (!ISRIN) { ! 748: if (ISSTOP) { ! 749: if ((tp->t_flags&T_STOP) == 0) ! 750: tp->t_flags |= T_STOP; ! 751: cache_it = 0; ! 752: } ! 753: if (ISSTART) { ! 754: tp->t_flags &= ~T_STOP; ! 755: defer(ttstart, tp); ! 756: cache_it = 0; ! 757: } ! 758: } ! 759: ! 760: /* ! 761: * Cache received character. ! 762: */ ! 763: if (cache_it) { ! 764: in_silo.si_buf[ in_silo.si_ix ] = c; ! 765: ! 766: if (++in_silo.si_ix >= sizeof(in_silo.si_buf)) ! 767: in_silo.si_ix = 0; ! 768: } ! 769: } ! 770: ! 771: /** ! 772: * ! 773: * void ! 774: * isbatch() -- raw input conversion routine ! 775: * ! 776: * Action: Enable the video display. ! 777: * Canonize the raw input silo. ! 778: * ! 779: * Notes: isbatch() was scheduled as a deferred process by isrint(). ! 780: */ ! 781: static void ! 782: isbatch(tp) ! 783: register TTY * tp; ! 784: { ! 785: register int c; ! 786: static int lastc; ! 787: ! 788: /* ! 789: * Ensure video display is enabled. ! 790: */ ! 791: mm_von(); ! 792: isbusy = 0; ! 793: ! 794: /* ! 795: * Process all cached characters. ! 796: */ ! 797: while (in_silo.si_ix != in_silo.si_ox) { ! 798: /* ! 799: * Get next cached char. ! 800: */ ! 801: c = in_silo.si_buf[ in_silo.si_ox ]; ! 802: ! 803: if (in_silo.si_ox >= sizeof(in_silo.si_buf) - 1) ! 804: in_silo.si_ox = 0; ! 805: else ! 806: in_silo.si_ox++; ! 807: ! 808: if ((islock == 0) || ISINTR || ISQUIT) { ! 809: ttin(tp, c); ! 810: } else if ((c == 'b') && (lastc == '\033')) { ! 811: islock = 0; ! 812: ttin(tp, lastc); ! 813: ttin(tp, c); ! 814: } else if ((c == 'c') && (lastc == '\033')) { ! 815: ttin(tp, lastc); ! 816: ttin(tp, c); ! 817: } else ! 818: putchar('\007'); ! 819: lastc = c; ! 820: } ! 821: } ! 822: ! 823: /* ! 824: * update the keyboard status LEDS. ! 825: * we chose the shift/lock key positions so this would be easy. ! 826: * this flavor of routine is called while processing a system call on ! 827: * behalf of the user. ! 828: */ ! 829: updleds() ! 830: { ! 831: kb_cmd2(K_LED_CMD, (shift >> 1) & 0x7); ! 832: } ! 833: ! 834: /* ! 835: * same as above, but callable from interrupt routines and other places ! 836: * which cannot sleep() waiting for the state machine to go idle. ! 837: */ ! 838: updleds2() ! 839: { ! 840: register int timeout; ! 841: register int s; ! 842: ! 843: timeout = KBTIMEOUT; ! 844: s = sphi(); ! 845: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL)) ! 846: ; ! 847: kbstate = KB_DOUBLE_1; ! 848: cmd2 = (shift >> 1) & 0x7; ! 849: prev_cmd = K_LED_CMD; ! 850: outb(KBDATA, K_LED_CMD); ! 851: spl(s); ! 852: } ! 853: ! 854: /* ! 855: * unlock the scroll in case an interrupt character is received ! 856: */ ! 857: kbunscroll() ! 858: { ! 859: shift &= ~(1 << scroll); ! 860: updleds(); ! 861: } ! 862: ! 863: /* ! 864: * ship a single byte command to the keyboard ! 865: */ ! 866: kb_cmd(cmd) ! 867: unsigned cmd; ! 868: { ! 869: register int timeout; ! 870: register int s; ! 871: ! 872: s = sphi(); ! 873: KBDEBUG2(" kb_cmd(%x)", cmd); ! 874: while (kbstate != KB_IDLE) { ! 875: v_sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN, "nkbcmd"); ! 876: /* The nkb driver is waiting for a command to complete. */ ! 877: } ! 878: kbstate = KB_SINGLE; ! 879: timeout = KBTIMEOUT; ! 880: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL)) ! 881: ; ! 882: if (!timeout) ! 883: printf("kb: command timeout\n"); ! 884: else { ! 885: outb(KBDATA, cmd); ! 886: while (kbstate != KB_IDLE) { ! 887: v_sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN, "nkbcmd..."); ! 888: /* The nkb driver is still waiting for a command to complete. */ ! 889: } ! 890: } ! 891: spl(s); ! 892: } ! 893: ! 894: /* ! 895: * ship a two byte command to the keyboard ! 896: */ ! 897: kb_cmd2(cmd, arg) ! 898: unsigned cmd, arg; ! 899: { ! 900: register int timeout; ! 901: register int s; ! 902: ! 903: s = sphi(); ! 904: KBDEBUG3(" kb_cmd2(%x, %x)", cmd, arg); ! 905: while (kbstate != KB_IDLE) { ! 906: v_sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN, "nkbcmd2"); ! 907: /* ! 908: * The nkb driver is waiting for a ! 909: * 2 byte command to complete. ! 910: */ ! 911: } ! 912: kbstate = KB_DOUBLE_1; ! 913: cmd2 = arg; ! 914: prev_cmd = cmd; ! 915: timeout = KBTIMEOUT; ! 916: while (--timeout > 0 && (inb(KBSTS_CMD) & STS_IBUF_FULL)) ! 917: ; ! 918: if (!timeout) ! 919: printf("kb: command timeout\n"); ! 920: else { ! 921: outb(KBDATA, cmd); ! 922: while (kbstate != KB_IDLE) { ! 923: v_sleep(&kbstate, CVTTIN, IVTTIN, SVTTIN, "nkbcmd2..."); ! 924: /* ! 925: * The nkb driver is still waiting for a ! 926: * 2 byte command to complete. ! 927: */ ! 928: } ! 929: } ! 930: spl(s); ! 931: } ! 932: ! 933: /* End of nkb.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.