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