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