![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / pexpert / i386|
Return to kd.c CVS log | Up to [Apple XNU] / XNU / pexpert / i386 |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: */ ! 27: ! 28: /* ! 29: * Olivetti Mach Console driver v0.0 ! 30: * Copyright Ing. C. Olivetti & C. S.p.A. 1988, 1989 ! 31: * All rights reserved. ! 32: * ! 33: */ ! 34: /* ! 35: * Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc., ! 36: * Cupertino, California. ! 37: * ! 38: * All Rights Reserved ! 39: * ! 40: * Permission to use, copy, modify, and distribute this software and ! 41: * its documentation for any purpose and without fee is hereby ! 42: * granted, provided that the above copyright notice appears in all ! 43: * copies and that both the copyright notice and this permission notice ! 44: * appear in supporting documentation, and that the name of Olivetti ! 45: * not be used in advertising or publicity pertaining to distribution ! 46: * of the software without specific, written prior permission. ! 47: * ! 48: * OLIVETTI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 49: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, ! 50: * IN NO EVENT SHALL OLIVETTI BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 51: * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 52: * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 53: * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUR OF OR IN CONNECTION ! 54: * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 55: * ! 56: * ! 57: * Copyright 1988, 1989 by Intel Corporation, Santa Clara, California. ! 58: * ! 59: * All Rights Reserved ! 60: * ! 61: * Permission to use, copy, modify, and distribute this software and ! 62: * its documentation for any purpose and without fee is hereby ! 63: * granted, provided that the above copyright notice appears in all ! 64: * copies and that both the copyright notice and this permission notice ! 65: * appear in supporting documentation, and that the name of Intel ! 66: * not be used in advertising or publicity pertaining to distribution ! 67: * of the software without specific, written prior permission. ! 68: * ! 69: * INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 70: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, ! 71: * IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 72: * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 73: * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 74: * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION ! 75: * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 76: */ ! 77: ! 78: /* $ Header: $ */ ! 79: ! 80: #include <string.h> ! 81: #include "kd.h" ! 82: ! 83: #include <mach/i386/vm_param.h> ! 84: ! 85: #define at386_io_lock_state() ! 86: #define at386_io_lock(op) (TRUE) ! 87: #define at386_io_unlock() ! 88: ! 89: ! 90: typedef unsigned short i386_ioport_t; ! 91: ! 92: /* read a byte */ ! 93: extern unsigned char inb( ! 94: i386_ioport_t port); ! 95: /* write a longword */ ! 96: extern void outb( ! 97: i386_ioport_t port, ! 98: unsigned char datum); ! 99: ! 100: extern __inline__ unsigned char inb( ! 101: i386_ioport_t port) ! 102: { ! 103: unsigned char datum; ! 104: __asm__ volatile("inb %1, %0" : "=a" (datum) : "d" (port)); ! 105: return(datum); ! 106: } ! 107: ! 108: extern __inline__ void outb( ! 109: i386_ioport_t port, ! 110: unsigned char datum) ! 111: { ! 112: __asm__ volatile("outb %0, %1" : : "a" (datum), "d" (port)); ! 113: } ! 114: ! 115: /* Forward */ ! 116: ! 117: extern void kd_sendcmd(unsigned char ch); ! 118: extern void kdreboot(void); ! 119: extern int kd_dogetc(int wait); ! 120: extern void kd_handle_ack(void); ! 121: extern void kd_resend(void); ! 122: extern int do_modifier( ! 123: int state, ! 124: Scancode c, ! 125: int up); ! 126: extern int kdcheckmagic( ! 127: Scancode sc, ! 128: int * regs); ! 129: extern int kdstate2idx( ! 130: int state, ! 131: int extended); ! 132: extern void kdinit(void); ! 133: extern void kd_belloff(void); ! 134: extern void kd_bellon(void); ! 135: extern void kd_senddata(unsigned char c); ! 136: extern unsigned char kd_getdata(void); ! 137: extern unsigned char kd_cmdreg_read(void); ! 138: extern void set_kd_state( ! 139: int newstate); ! 140: extern unsigned char state2leds( ! 141: int state); ! 142: extern void kd_setleds1( ! 143: unsigned char val); ! 144: extern void kd_setleds2(void); ! 145: extern void cnsetleds( ! 146: unsigned char val); ! 147: extern int kd_kbd_magic( ! 148: int scancode); ! 149: ! 150: extern int cngetc(void); ! 151: extern int cnmaygetc(void); ! 152: extern void kdreboot(void); ! 153: extern int kd_dogetc(int wait); ! 154: ! 155: /* reboot on CTL-ALT-DEL ? */ ! 156: extern int rebootflag; ! 157: /* enter kernel debugger on CTR-ALT-d ? */ ! 158: int kbdkdbflag = 1; ! 159: /* allow keyboard mouse ? */ ! 160: int kbdmouseflag = 0; ! 161: ! 162: /* ! 163: * kd_state shows the state of the modifier keys (ctrl, caps lock, ! 164: * etc.) It should normally be changed by calling set_kd_state(), so ! 165: * that the keyboard status LEDs are updated correctly. ! 166: */ ! 167: int kd_state = KS_NORMAL; ! 168: int kb_mode = KB_ASCII; /* event/ascii */ ! 169: ! 170: int kd_kbd_mouse = 0; ! 171: int kd_kbd_magic_scale = 6; ! 172: int kd_kbd_magic_button = 0; ! 173: ! 174: /* ! 175: * Some keyboard commands work by sending a command, waiting for an ! 176: * ack (handled by kdintr), then sending data, which generates a ! 177: * second ack. If we are in the middle of such a sequence, kd_ack ! 178: * shows what the ack is for. ! 179: * ! 180: * When a byte is sent to the keyboard, it is kept around in last_sent ! 181: * in case it needs to be resent. ! 182: * ! 183: * The rest of the variables here hold the data required to complete ! 184: * the sequence. ! 185: * ! 186: * XXX - the System V driver keeps a command queue, I guess in case we ! 187: * want to start a command while another is in progress. Is this ! 188: * something we should worry about? ! 189: */ ! 190: enum why_ack {NOT_WAITING, SET_LEDS, DATA_ACK}; ! 191: enum why_ack kd_ack = NOT_WAITING; ! 192: ! 193: unsigned char last_sent = 0; ! 194: ! 195: unsigned char kd_nextled = 0; ! 196: ! 197: /* ! 198: * We don't provide any mutex protection for this flag because we know ! 199: * that this module will have been initialized by the time multiple ! 200: * threads are running. ! 201: */ ! 202: int kd_initialized = FALSE; /* driver initialized? */ ! 203: int kd_extended = FALSE; ! 204: ! 205: /* ! 206: * This array maps scancodes to Ascii characters (or character ! 207: * sequences). ! 208: * Each row corresponds to one key. There are NUMOUTPUT bytes per key ! 209: * state. The states are ordered: Normal, SHIFT, CTRL, ALT, ! 210: * SHIFT/ALT. ! 211: */ ! 212: unsigned char key_map[NUMKEYS][WIDTH_KMAP] = { ! 213: {NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, ! 214: {K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC}, ! 215: {K_ONE,NC,NC, K_BANG,NC,NC, K_ONE,NC,NC, 0x1b,0x4e,0x31, 0x1b,0x4e,0x21}, ! 216: {K_TWO,NC,NC, K_ATSN,NC,NC, K_NUL,NC,NC, 0x1b,0x4e,0x32, 0x1b,0x4e,0x40}, ! 217: {K_THREE,NC,NC, K_POUND,NC,NC, K_THREE,NC,NC, 0x1b,0x4e,0x33, 0x1b,0x4e,0x23}, ! 218: {K_FOUR,NC,NC, K_DOLLAR,NC,NC, K_FOUR,NC,NC, 0x1b,0x4e,0x34, 0x1b,0x4e,0x24}, ! 219: {K_FIVE,NC,NC, K_PERC,NC,NC, K_FIVE,NC,NC, 0x1b,0x4e,0x35, 0x1b,0x4e,0x25}, ! 220: {K_SIX,NC,NC, K_CARET,NC,NC, K_RS,NC,NC, 0x1b,0x4e,0x36, 0x1b,0x4e,0x5e}, ! 221: {K_SEVEN,NC,NC, K_AMPER,NC,NC, K_SEVEN,NC,NC, 0x1b,0x4e,0x37, 0x1b,0x4e,0x26}, ! 222: {K_EIGHT,NC,NC, K_ASTER,NC,NC, K_EIGHT,NC,NC, 0x1b,0x4e,0x38, 0x1b,0x4e,0x2a}, ! 223: {K_NINE,NC,NC, K_LPAREN,NC,NC, K_NINE,NC,NC, 0x1b,0x4e,0x39,0x1b,0x4e,0x28}, ! 224: {K_ZERO,NC,NC, K_RPAREN,NC,NC, K_ZERO,NC,NC, 0x1b,0x4e,0x30,0x1b,0x4e,0x29}, ! 225: {K_MINUS,NC,NC, K_UNDSC,NC,NC, K_US,NC,NC, 0x1b,0x4e,0x2d, 0x1b,0x4e,0x5f}, ! 226: {K_EQL,NC,NC, K_PLUS,NC,NC, K_EQL,NC,NC, 0x1b,0x4e,0x3d, 0x1b,0x4e,0x2b}, ! 227: {K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC}, ! 228: {K_HT,NC,NC, K_GS,NC,NC, K_HT,NC,NC, K_HT,NC,NC, K_GS,NC,NC}, ! 229: {K_q,NC,NC, K_Q,NC,NC, K_DC1,NC,NC, 0x1b,0x4e,0x71, 0x1b,0x4e,0x51}, ! 230: {K_w,NC,NC, K_W,NC,NC, K_ETB,NC,NC, 0x1b,0x4e,0x77, 0x1b,0x4e,0x57}, ! 231: {K_e,NC,NC, K_E,NC,NC, K_ENQ,NC,NC, 0x1b,0x4e,0x65, 0x1b,0x4e,0x45}, ! 232: {K_r,NC,NC, K_R,NC,NC, K_DC2,NC,NC, 0x1b,0x4e,0x72, 0x1b,0x4e,0x52}, ! 233: {K_t,NC,NC, K_T,NC,NC, K_DC4,NC,NC, 0x1b,0x4e,0x74, 0x1b,0x4e,0x54}, ! 234: {K_y,NC,NC, K_Y,NC,NC, K_EM,NC,NC, 0x1b,0x4e,0x79, 0x1b,0x4e,0x59}, ! 235: {K_u,NC,NC, K_U,NC,NC, K_NAK,NC,NC, 0x1b,0x4e,0x75, 0x1b,0x4e,0x55}, ! 236: {K_i,NC,NC, K_I,NC,NC, K_HT,NC,NC, 0x1b,0x4e,0x69, 0x1b,0x4e,0x49}, ! 237: {K_o,NC,NC, K_O,NC,NC, K_SI,NC,NC, 0x1b,0x4e,0x6f, 0x1b,0x4e,0x4f}, ! 238: {K_p,NC,NC, K_P,NC,NC, K_DLE,NC,NC, 0x1b,0x4e,0x70, 0x1b,0x4e,0x50}, ! 239: {K_LBRKT,NC,NC, K_LBRACE,NC,NC, K_ESC,NC,NC, 0x1b,0x4e,0x5b, 0x1b,0x4e,0x7b}, ! 240: {K_RBRKT,NC,NC, K_RBRACE,NC,NC, K_GS,NC,NC, 0x1b,0x4e,0x5d, 0x1b,0x4e,0x7d}, ! 241: {K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC}, ! 242: {K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, ! 243: K_SCAN,K_CTLSC,NC}, ! 244: {K_a,NC,NC, K_A,NC,NC, K_SOH,NC,NC, 0x1b,0x4e,0x61, 0x1b,0x4e,0x41}, ! 245: {K_s,NC,NC, K_S,NC,NC, K_DC3,NC,NC, 0x1b,0x4e,0x73, 0x1b,0x4e,0x53}, ! 246: {K_d,NC,NC, K_D,NC,NC, K_EOT,NC,NC, 0x1b,0x4e,0x65, 0x1b,0x4e,0x45}, ! 247: {K_f,NC,NC, K_F,NC,NC, K_ACK,NC,NC, 0x1b,0x4e,0x66, 0x1b,0x4e,0x46}, ! 248: {K_g,NC,NC, K_G,NC,NC, K_BEL,NC,NC, 0x1b,0x4e,0x67, 0x1b,0x4e,0x47}, ! 249: {K_h,NC,NC, K_H,NC,NC, K_BS,NC,NC, 0x1b,0x4e,0x68, 0x1b,0x4e,0x48}, ! 250: {K_j,NC,NC, K_J,NC,NC, K_LF,NC,NC, 0x1b,0x4e,0x6a, 0x1b,0x4e,0x4a}, ! 251: {K_k,NC,NC, K_K,NC,NC, K_VT,NC,NC, 0x1b,0x4e,0x6b, 0x1b,0x4e,0x4b}, ! 252: {K_l,NC,NC, K_L,NC,NC, K_FF,NC,NC, 0x1b,0x4e,0x6c, 0x1b,0x4e,0x4c}, ! 253: {K_SEMI,NC,NC, K_COLON,NC,NC, K_SEMI,NC,NC, 0x1b,0x4e,0x3b, 0x1b,0x4e,0x3a}, ! 254: {K_SQUOTE,NC,NC,K_DQUOTE,NC,NC,K_SQUOTE,NC,NC,0x1b,0x4e,0x27,0x1b,0x4e,0x22}, ! 255: {K_GRAV,NC,NC, K_TILDE,NC,NC, K_RS,NC,NC, 0x1b,0x4e,0x60, 0x1b,0x4e,0x7e}, ! 256: {K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, ! 257: K_SCAN,K_LSHSC,NC}, ! 258: {K_BSLSH,NC,NC, K_PIPE,NC,NC, K_FS,NC,NC, 0x1b,0x4e,0x5c, 0x1b,0x4e,0x7c}, ! 259: {K_z,NC,NC, K_Z,NC,NC, K_SUB,NC,NC, 0x1b,0x4e,0x7a, 0x1b,0x4e,0x5a}, ! 260: {K_x,NC,NC, K_X,NC,NC, K_CAN,NC,NC, 0x1b,0x4e,0x78, 0x1b,0x4e,0x58}, ! 261: {K_c,NC,NC, K_C,NC,NC, K_ETX,NC,NC, 0x1b,0x4e,0x63, 0x1b,0x4e,0x43}, ! 262: {K_v,NC,NC, K_V,NC,NC, K_SYN,NC,NC, 0x1b,0x4e,0x76, 0x1b,0x4e,0x56}, ! 263: {K_b,NC,NC, K_B,NC,NC, K_STX,NC,NC, 0x1b,0x4e,0x62, 0x1b,0x4e,0x42}, ! 264: {K_n,NC,NC, K_N,NC,NC, K_SO,NC,NC, 0x1b,0x4e,0x6e, 0x1b,0x4e,0x4e}, ! 265: {K_m,NC,NC, K_M,NC,NC, K_CR,NC,NC, 0x1b,0x4e,0x6d, 0x1b,0x4e,0x4d}, ! 266: {K_COMMA,NC,NC, K_LTHN,NC,NC, K_COMMA,NC,NC, 0x1b,0x4e,0x2c, 0x1b,0x4e,0x3c}, ! 267: {K_PERIOD,NC,NC, K_GTHN,NC,NC, K_PERIOD,NC,NC,0x1b,0x4e,0x2e,0x1b,0x4e,0x3e}, ! 268: {K_SLASH,NC,NC, K_QUES,NC,NC, K_SLASH,NC,NC, 0x1b,0x4e,0x2f, 0x1b,0x4e,0x3f}, ! 269: {K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, ! 270: K_SCAN,K_RSHSC,NC}, ! 271: {K_ASTER,NC,NC, K_ASTER,NC,NC, K_ASTER,NC,NC, 0x1b,0x4e,0x2a,0x1b,0x4e,0x2a}, ! 272: {K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, ! 273: K_SCAN,K_ALTSC,NC}, ! 274: {K_SPACE,NC,NC, K_SPACE,NC,NC, K_NUL,NC,NC, K_SPACE,NC,NC, K_SPACE,NC,NC}, ! 275: {K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, ! 276: K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC}, ! 277: {K_F1, K_F1S, K_F1, K_F1, K_F1S}, ! 278: {K_F2, K_F2S, K_F2, K_F2, K_F2S}, ! 279: {K_F3, K_F3S, K_F3, K_F3, K_F3S}, ! 280: {K_F4, K_F4S, K_F4, K_F4, K_F4S}, ! 281: {K_F5, K_F5S, K_F5, K_F5, K_F5S}, ! 282: {K_F6, K_F6S, K_F6, K_F6, K_F6S}, ! 283: {K_F7, K_F7S, K_F7, K_F7, K_F7S}, ! 284: {K_F8, K_F8S, K_F8, K_F8, K_F8S}, ! 285: {K_F9, K_F9S, K_F9, K_F9, K_F9S}, ! 286: {K_F10, K_F10S, K_F10, K_F10, K_F10S}, ! 287: {K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, ! 288: K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC}, ! 289: {K_SCRL, K_NUL,NC,NC, K_SCRL, K_SCRL, K_NUL,NC,NC}, ! 290: {K_HOME, K_SEVEN,NC,NC, K_HOME, K_HOME, 0x1b,0x4e,0x37}, ! 291: {K_UA, K_EIGHT,NC,NC, K_UA, K_UA, 0x1b,0x4e,0x38}, ! 292: {K_PUP, K_NINE,NC,NC, K_PUP, K_PUP, 0x1b,0x4e,0x39}, ! 293: {0x1b,0x5b,0x53, K_MINUS,NC,NC, 0x1b,0x5b,0x53,0x1b,0x5b,0x53,0x1b,0x4e,0x2d}, ! 294: {K_LA, K_FOUR,NC,NC, K_LA, K_LA, 0x1b,0x4e,0x34}, ! 295: {0x1b,0x5b,0x47,K_FIVE,NC,NC,0x1b,0x5b,0x47, 0x1b,0x5b,0x47, 0x1b,0x4e,0x35}, ! 296: {K_RA, K_SIX,NC,NC, K_RA, K_RA, 0x1b,0x4e,0x36}, ! 297: {0x1b,0x5b,0x54,K_PLUS,NC,NC, 0x1b,0x5b,0x54, 0x1b,0x5b,0x54, 0x1b,0x4e,0x2b}, ! 298: {K_END, K_ONE,NC,NC, K_END, K_END, 0x1b,0x4e,0x31}, ! 299: {K_DA, K_TWO,NC,NC, K_DA, K_DA, 0x1b,0x4e,0x32}, ! 300: {K_PDN, K_THREE,NC,NC, K_PDN, K_PDN, 0x1b,0x4e,0x33}, ! 301: {K_INS, K_ZERO,NC,NC, K_INS, K_INS, 0x1b,0x4e,0x30}, ! 302: {K_DEL,NC,NC, K_PERIOD,NC,NC, K_DEL,NC,NC, K_DEL,NC,NC, 0x1b,0x4e,0x2e}, ! 303: {NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, ! 304: {NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, ! 305: {NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, ! 306: {K_F11, K_F11S, K_F11, K_F11, K_F11S}, ! 307: {K_F12, K_F12S, K_F12, K_F12, K_F12S} ! 308: }; ! 309: ! 310: extern void cnputc(unsigned char ch); ! 311: ! 312: /* ! 313: * Switch for poll vs. interrupt. ! 314: */ ! 315: int kd_pollc = 0; ! 316: ! 317: int (*cgetc)( ! 318: int wait) = kd_dogetc; ! 319: /* get a char. from console */ ! 320: void (*cputc)( ! 321: char ch) = cnputc; ! 322: /* put a char. to console */ ! 323: ! 324: /* ! 325: * cngetc: ! 326: * ! 327: * Get one character using polling, rather than interrupts. Used ! 328: * by the kernel debugger. Note that Caps Lock is ignored. ! 329: * Normally this routine is called with interrupts already ! 330: * disabled, but there is code in place so that it will be more ! 331: * likely to work even if interrupts are turned on. ! 332: */ ! 333: ! 334: int ! 335: cngetc(void) ! 336: { ! 337: int ret; ! 338: ! 339: ret = (*cgetc)(TRUE); ! 340: ! 341: return ret; ! 342: } ! 343: ! 344: int ! 345: cnmaygetc(void) ! 346: { ! 347: int ret; ! 348: ! 349: ret = (*cgetc)(FALSE); ! 350: ! 351: return ret; ! 352: } ! 353: ! 354: int ! 355: kd_dogetc( ! 356: int wait) ! 357: { ! 358: unsigned char c; ! 359: unsigned char scancode; ! 360: unsigned int char_idx; ! 361: int up; ! 362: ! 363: kdinit(); ! 364: kd_extended = FALSE; ! 365: ! 366: for ( ; ; ) { ! 367: while (!(inb(K_STATUS) & K_OBUF_FUL)) ! 368: if (!wait) ! 369: return (-1); ! 370: up = FALSE; ! 371: /* ! 372: * We'd come here for mouse events in debugger, if ! 373: * the mouse were on. ! 374: */ ! 375: if ((inb(K_STATUS) & 0x20) == 0x20) { ! 376: printf("M%xP", inb(K_RDWR)); ! 377: continue; ! 378: } ! 379: scancode = inb(K_RDWR); ! 380: /* ! 381: * Handle extend modifier and ! 382: * ack/resend, otherwise we may never receive ! 383: * a key. ! 384: */ ! 385: if (scancode == K_EXTEND) { ! 386: kd_extended = TRUE; ! 387: continue; ! 388: } else if (scancode == K_RESEND) { ! 389: /* printf("kd_getc: resend"); */ ! 390: kd_resend(); ! 391: continue; ! 392: } else if (scancode == K_ACKSC) { ! 393: /* printf("kd_getc: handle_ack"); */ ! 394: kd_handle_ack(); ! 395: continue; ! 396: } ! 397: if (scancode & K_UP) { ! 398: up = TRUE; ! 399: scancode &= ~K_UP; ! 400: } ! 401: if (kd_kbd_mouse) ! 402: kd_kbd_magic(scancode); ! 403: if (scancode < NUMKEYS) { ! 404: /* Lookup in map, then process. */ ! 405: char_idx = kdstate2idx(kd_state, kd_extended); ! 406: c = key_map[scancode][char_idx]; ! 407: if (c == K_SCAN) { ! 408: c = key_map[scancode][++char_idx]; ! 409: kd_state = do_modifier(kd_state, c, up); ! 410: #ifdef notdef ! 411: cnsetleds(state2leds(kd_state)); ! 412: #endif ! 413: } else if (!up) { ! 414: /* regular key-down */ ! 415: if (c == K_CR) ! 416: c = K_LF; ! 417: #ifdef notdef ! 418: splx(o_pri); ! 419: #endif ! 420: return(c & 0177); ! 421: } ! 422: } ! 423: } ! 424: } ! 425: ! 426: ! 427: int old_kb_mode; ! 428: ! 429: #if MACH_KDB ! 430: #define poll_spl() db_splhigh() /* prevent race w/ kdintr() */ ! 431: #define poll_splx(s) db_splx(s) ! 432: #else /* MACH_KDB */ ! 433: #define poll_spl() SPLKD() ! 434: #define poll_splx(s) splx(s) ! 435: #endif /* MACH_KDB */ ! 436: ! 437: ! 438: void ! 439: cnpollc( ! 440: int on) ! 441: { ! 442: int old_spl; /* spl we're called at... */ ! 443: ! 444: if (cpu_number()) { ! 445: return; ! 446: } ! 447: if (on) { ! 448: old_spl = poll_spl(); ! 449: ! 450: old_kb_mode = kb_mode; ! 451: kb_mode = KB_ASCII; ! 452: poll_splx(old_spl); ! 453: ! 454: kd_pollc++; ! 455: } else { ! 456: --kd_pollc; ! 457: ! 458: old_spl = poll_spl(); ! 459: kb_mode = old_kb_mode; ! 460: poll_splx(old_spl); ! 461: ! 462: ! 463: } ! 464: } ! 465: ! 466: /* ! 467: * kd_handle_ack: ! 468: * ! 469: * For pending commands, complete the command. For data bytes, ! 470: * drop the ack on the floor. ! 471: */ ! 472: ! 473: void ! 474: kd_handle_ack(void) ! 475: { ! 476: switch (kd_ack) { ! 477: case SET_LEDS: ! 478: kd_setleds2(); ! 479: kd_ack = DATA_ACK; ! 480: break; ! 481: case DATA_ACK: ! 482: kd_ack = NOT_WAITING; ! 483: break; ! 484: case NOT_WAITING: ! 485: printf("unexpected ACK from keyboard\n"); ! 486: break; ! 487: default: ! 488: panic("bogus kd_ack\n"); ! 489: break; ! 490: } ! 491: } ! 492: ! 493: /* ! 494: * kd_resend: ! 495: * ! 496: * Resend a missed keyboard command or data byte. ! 497: */ ! 498: ! 499: void ! 500: kd_resend(void) ! 501: { ! 502: if (kd_ack == NOT_WAITING) ! 503: printf("unexpected RESEND from keyboard\n"); ! 504: else ! 505: kd_senddata(last_sent); ! 506: } ! 507: ! 508: ! 509: /* ! 510: * do_modifier: ! 511: * ! 512: * Change keyboard state according to which modifier key and ! 513: * whether it went down or up. ! 514: * ! 515: * input: the current state, the key, and the key's direction. ! 516: * The key can be any key, not just a modifier key. ! 517: * ! 518: * output: the new state ! 519: */ ! 520: ! 521: int ! 522: do_modifier( ! 523: int state, ! 524: Scancode c, ! 525: int up) ! 526: { ! 527: switch (c) { ! 528: case (K_ALTSC): ! 529: if (up) ! 530: state &= ~KS_ALTED; ! 531: else ! 532: state |= KS_ALTED; ! 533: kd_extended = FALSE; ! 534: break; ! 535: #ifndef ORC ! 536: case (K_CLCKSC): ! 537: #endif /* ORC */ ! 538: case (K_CTLSC): ! 539: if (up) ! 540: state &= ~KS_CTLED; ! 541: else ! 542: state |= KS_CTLED; ! 543: kd_extended = FALSE; ! 544: break; ! 545: #ifdef ORC ! 546: case (K_CLCKSC): ! 547: if (!up) ! 548: state ^= KS_CLKED; ! 549: break; ! 550: #endif /* ORC */ ! 551: case (K_NLCKSC): ! 552: if (!up) ! 553: state ^= KS_NLKED; ! 554: break; ! 555: case (K_LSHSC): ! 556: case (K_RSHSC): ! 557: if (up) ! 558: state &= ~KS_SHIFTED; ! 559: else ! 560: state |= KS_SHIFTED; ! 561: kd_extended = FALSE; ! 562: break; ! 563: } ! 564: ! 565: return(state); ! 566: } ! 567: ! 568: ! 569: /* ! 570: * kdcheckmagic: ! 571: * ! 572: * Check for magic keystrokes for invoking the debugger or ! 573: * rebooting or ... ! 574: * ! 575: * input: an unprocessed scancode ! 576: * ! 577: * output: TRUE if a magic key combination was recognized and ! 578: * processed. FALSE otherwise. ! 579: * ! 580: * side effects: ! 581: * various actions possible, depending on which keys are ! 582: * pressed. If the debugger is called, steps are taken ! 583: * to ensure that the system doesn't think the magic keys ! 584: * are still held down. ! 585: */ ! 586: ! 587: int ! 588: kdcheckmagic( ! 589: Scancode scancode, ! 590: int *regs) ! 591: { ! 592: static int magic_state = KS_NORMAL; /* like kd_state */ ! 593: int up = FALSE; ! 594: extern int rebootflag; ! 595: ! 596: if (scancode == 0x46 && kbdmouseflag) /* scroll lock */ ! 597: { ! 598: kd_kbd_mouse = !kd_kbd_mouse; ! 599: kd_kbd_magic_button = 0; ! 600: return(TRUE); ! 601: } ! 602: if (scancode & K_UP) { ! 603: up = TRUE; ! 604: scancode &= ~K_UP; ! 605: } ! 606: magic_state = do_modifier(magic_state, scancode, up); ! 607: ! 608: if ((magic_state&(KS_CTLED|KS_ALTED)) == (KS_CTLED|KS_ALTED)) { ! 609: switch (scancode) { ! 610: #if MACH_KDB ! 611: case K_dSC: /* ctl-alt-d */ ! 612: if (!kbdkdbflag) ! 613: return(FALSE); ! 614: ! 615: kdb_kintr(); /* invoke debugger */ ! 616: ! 617: /* Returned from debugger, so reset kbd state. */ ! 618: (void)SPLKD(); ! 619: magic_state = KS_NORMAL; ! 620: if (kb_mode == KB_ASCII) ! 621: kd_state = KS_NORMAL; ! 622: /* setting leds kills kbd */ ! 623: ! 624: return(TRUE); ! 625: break; ! 626: #endif /* MACH_KDB */ ! 627: case K_DELSC: /* ctl-alt-del */ ! 628: /* if rebootflag is on, reboot the system */ ! 629: if (rebootflag) ! 630: kdreboot(); ! 631: break; ! 632: } ! 633: } ! 634: return(FALSE); ! 635: } ! 636: ! 637: ! 638: /* ! 639: * kdstate2idx: ! 640: * ! 641: * Return the value for the 2nd index into key_map that ! 642: * corresponds to the given state. ! 643: */ ! 644: ! 645: int ! 646: kdstate2idx( ! 647: int state, /* bit vector, not a state index */ ! 648: int extended) ! 649: { ! 650: int state_idx = NORM_STATE; ! 651: ! 652: if ((!extended) && state != KS_NORMAL) { ! 653: if ((state&(KS_SHIFTED|KS_ALTED)) == (KS_SHIFTED|KS_ALTED)) ! 654: state_idx = SHIFT_ALT; ! 655: else if (state&KS_SHIFTED) ! 656: state_idx = SHIFT_STATE; ! 657: else if (state&KS_ALTED) ! 658: state_idx = ALT_STATE; ! 659: else if (state&KS_CTLED) ! 660: state_idx = CTRL_STATE; ! 661: } ! 662: ! 663: return (CHARIDX(state_idx)); ! 664: } ! 665: ! 666: /* ! 667: * kdinit: ! 668: * ! 669: * This code initializes the structures and sets up the port registers ! 670: * for the console driver. ! 671: * ! 672: * Each bitmap-based graphics card is likely to require a unique ! 673: * way to determine the card's presence. The driver runs through ! 674: * each "special" card that it knows about and uses the first one ! 675: * that it finds. If it doesn't find any, it assumes that an ! 676: * EGA-like card is installed. ! 677: * ! 678: * input : None. Interrupts are assumed to be disabled ! 679: * output : Driver is initialized ! 680: * ! 681: */ ! 682: ! 683: void ! 684: kdinit(void) ! 685: { ! 686: unsigned char k_comm; /* keyboard command byte */ ! 687: unsigned char kd_stat; ! 688: ! 689: if (kd_initialized) ! 690: return; ! 691: kd_initialized = TRUE; ! 692: ! 693: /* get rid of any garbage in output buffer */ ! 694: if (inb(K_STATUS) & K_OBUF_FUL) ! 695: (void)inb(K_RDWR); ! 696: ! 697: cnsetleds(kd_state = KS_NORMAL); ! 698: ! 699: kd_sendcmd(KC_CMD_READ); /* ask for the ctlr command byte */ ! 700: k_comm = kd_getdata(); ! 701: k_comm &= ~K_CB_DISBLE; /* clear keyboard disable bit */ ! 702: k_comm |= K_CB_ENBLIRQ; /* enable interrupt */ ! 703: kd_sendcmd(KC_CMD_WRITE); /* write new ctlr command byte */ ! 704: kd_senddata(k_comm); ! 705: ! 706: /* set_kd_state(KS_NORMAL); does only HALF of set-leds sequence - ! 707: leaves kbd dead */ ! 708: ! 709: /* get rid of any garbage in output buffer */ ! 710: (void)inb(K_RDWR); ! 711: } ! 712: ! 713: /* ! 714: * kd_belloff: ! 715: * ! 716: * This routine shuts the bell off, by sending the appropriate code ! 717: * to the speaker port. ! 718: * ! 719: * input : None ! 720: * output : bell is turned off ! 721: * ! 722: */ ! 723: ! 724: void ! 725: kd_belloff(void) ! 726: { ! 727: unsigned char status; ! 728: ! 729: status = (inb(K_PORTB) & ~(K_SPKRDATA | K_ENABLETMR2)); ! 730: outb(K_PORTB, status); ! 731: } ! 732: ! 733: ! 734: /* ! 735: * kd_bellon: ! 736: * ! 737: * This routine turns the bell on. ! 738: * ! 739: * input : None ! 740: * output : bell is turned on ! 741: * ! 742: */ ! 743: ! 744: void ! 745: kd_bellon(void) ! 746: { ! 747: unsigned char status; ! 748: ! 749: /* program timer 2 */ ! 750: outb(K_TMRCTL, K_SELTMR2 | K_RDLDTWORD | K_TSQRWAVE | K_TBINARY); ! 751: outb(K_TMR2, 1500 & 0xff); /* LSB */ ! 752: outb(K_TMR2, (int)1500 >> 8); /* MSB */ ! 753: ! 754: /* start speaker - why must we turn on K_SPKRDATA? */ ! 755: status = (inb(K_PORTB)| K_ENABLETMR2 | K_SPKRDATA); ! 756: outb(K_PORTB, status); ! 757: return; ! 758: } ! 759: ! 760: /* ! 761: * kd_senddata: ! 762: * ! 763: * This function sends a byte to the keyboard RDWR port, but ! 764: * first waits until the input/output data buffer is clear before ! 765: * sending the data. Note that this byte can be either data or a ! 766: * keyboard command. ! 767: * ! 768: */ ! 769: ! 770: void ! 771: kd_senddata( ! 772: unsigned char ch) ! 773: { ! 774: while (inb(K_STATUS) & K_IBUF_FUL); ! 775: outb(K_RDWR, ch); ! 776: last_sent = ch; ! 777: } ! 778: ! 779: /* ! 780: * kd_sendcmd: ! 781: * ! 782: * This function sends a command byte to the keyboard command ! 783: * port, but first waits until the input/output data buffer is ! 784: * clear before sending the data. ! 785: * ! 786: */ ! 787: ! 788: void ! 789: kd_sendcmd( ! 790: unsigned char ch) ! 791: { ! 792: while (inb(K_STATUS) & K_IBUF_FUL); ! 793: outb(K_CMD, ch); ! 794: } ! 795: ! 796: ! 797: /* ! 798: * kd_getdata: ! 799: * ! 800: * This function returns a data byte from the keyboard RDWR port, ! 801: * after waiting until the port is flagged as having something to ! 802: * read. ! 803: */ ! 804: ! 805: unsigned char ! 806: kd_getdata(void) ! 807: { ! 808: while ((inb(K_STATUS) & K_OBUF_FUL) == 0); ! 809: return(inb(K_RDWR)); ! 810: } ! 811: ! 812: unsigned char ! 813: kd_cmdreg_read(void) ! 814: { ! 815: int ch=KC_CMD_READ; ! 816: ! 817: while (inb(K_STATUS) & (K_IBUF_FUL | K_OBUF_FUL)); ! 818: outb(K_CMD, ch); ! 819: ! 820: while ((inb(K_STATUS) & K_OBUF_FUL) == 0); ! 821: return(inb(K_RDWR)); ! 822: } ! 823: ! 824: void ! 825: kd_cmdreg_write( ! 826: unsigned char val) ! 827: { ! 828: int ch=KC_CMD_WRITE; ! 829: ! 830: while (inb(K_STATUS) & K_IBUF_FUL); ! 831: outb(K_CMD, ch); ! 832: ! 833: while (inb(K_STATUS) & K_IBUF_FUL); ! 834: outb(K_RDWR, val); ! 835: } ! 836: ! 837: int kd_mouse_write_no_ack = 0; ! 838: ! 839: int ! 840: kd_mouse_write( ! 841: unsigned char val) ! 842: { ! 843: int ch=0xd4; /* output byte to aux device (i.e. mouse) */ ! 844: int ret = 0; ! 845: ! 846: while (inb(K_STATUS) & K_IBUF_FUL); ! 847: outb(K_CMD, ch); ! 848: ! 849: while (inb(K_STATUS) & K_IBUF_FUL); ! 850: outb(K_RDWR, val); ! 851: ! 852: if (kd_mouse_write_no_ack) goto done; ! 853: ! 854: while ((inb(K_STATUS) & K_OBUF_FUL) == 0); ! 855: if ((inb(K_STATUS) & 0x20) == 0x20) { ! 856: switch (ret = inb(K_RDWR)) { ! 857: case 0xfa: ! 858: break; ! 859: case 0xfe: ! 860: case 0xfc: ! 861: default: ! 862: printf("kd_mouse_write: saw %x for %x\n", ! 863: ret, val); ! 864: } ! 865: } else { /* abort */ ! 866: printf("kd_mouse_write: sync error ??? on %x\n", val); ! 867: } ! 868: ! 869: done: ! 870: return ret; ! 871: } ! 872: ! 873: void ! 874: kd_mouse_read( ! 875: int no, ! 876: char *buf) ! 877: { ! 878: ! 879: while (no-- > 0) { ! 880: while ((inb(K_STATUS) & K_OBUF_FUL) == 0); ! 881: /* ! 882: * We may have seen a mouse event. ! 883: */ ! 884: if ((inb(K_STATUS) & 0x20) == 0x20) { ! 885: *buf++ = (unsigned char)inb(K_RDWR); ! 886: } else { /* abort */ ! 887: int junk = inb(K_RDWR); ! 888: printf("kd_mouse_read: sync error, received: 0x%x\n", ! 889: junk); ! 890: break; ! 891: } ! 892: } ! 893: } ! 894: ! 895: void ! 896: kd_mouse_drain(void) ! 897: { ! 898: int i; ! 899: while(inb(K_STATUS) & K_IBUF_FUL); ! 900: while((i = inb(K_STATUS)) & K_OBUF_FUL) ! 901: printf("kbd: S = %x D = %x\n", i, inb(K_RDWR)); ! 902: } ! 903: ! 904: /* ! 905: * set_kd_state: ! 906: * ! 907: * Set kd_state and update the keyboard status LEDs. ! 908: */ ! 909: ! 910: void ! 911: set_kd_state( ! 912: int newstate) ! 913: { ! 914: kd_state = newstate; ! 915: kd_setleds1(state2leds(newstate)); ! 916: } ! 917: ! 918: /* ! 919: * state2leds: ! 920: * ! 921: * Return a byte containing LED settings for the keyboard, given ! 922: * a state vector. ! 923: */ ! 924: ! 925: unsigned char ! 926: state2leds( ! 927: int state) ! 928: { ! 929: unsigned char result = 0; ! 930: ! 931: if (state & KS_NLKED) ! 932: result |= K_LED_NUMLK; ! 933: if (state & KS_CLKED) ! 934: result |= K_LED_CAPSLK; ! 935: return(result); ! 936: } ! 937: ! 938: /* ! 939: * kd_setleds[12]: ! 940: * ! 941: * Set the keyboard LEDs according to the given byte. ! 942: */ ! 943: ! 944: void ! 945: kd_setleds1( ! 946: unsigned char val) ! 947: { ! 948: if (kd_ack != NOT_WAITING) { ! 949: printf("kd_setleds1: unexpected state (%d)\n", kd_ack); ! 950: return; ! 951: } ! 952: ! 953: kd_ack = SET_LEDS; ! 954: kd_nextled = val; ! 955: kd_senddata(K_CMD_LEDS); ! 956: } ! 957: ! 958: void ! 959: kd_setleds2(void) ! 960: { ! 961: kd_senddata(kd_nextled); ! 962: } ! 963: ! 964: ! 965: /* ! 966: * cnsetleds: ! 967: * ! 968: * like kd_setleds[12], but not interrupt-based. ! 969: * Currently disabled because cngetc ignores caps lock and num ! 970: * lock anyway. ! 971: */ ! 972: ! 973: void ! 974: cnsetleds( ! 975: unsigned char val) ! 976: { ! 977: kd_senddata(K_CMD_LEDS); ! 978: (void)kd_getdata(); /* XXX - assume is ACK */ ! 979: kd_senddata(val); ! 980: (void)kd_getdata(); /* XXX - assume is ACK */ ! 981: } ! 982: ! 983: void ! 984: kdreboot(void) ! 985: { ! 986: kd_sendcmd(0xFE); /* XXX - magic # */ ! 987: /* ! 988: * DRAT. We're still here. Let's try a "CPU shutdown", which consists ! 989: * of clearing the IDTR and causing an exception. It's in locore.s ! 990: */ ! 991: cpu_shutdown(); ! 992: /*NOTREACHED*/ ! 993: } ! 994: ! 995: int ! 996: kd_kbd_magic( ! 997: int scancode) ! 998: { ! 999: int new_button = 0; ! 1000: ! 1001: if (kd_kbd_mouse == 2) ! 1002: printf("sc = %x\n", scancode); ! 1003: ! 1004: switch (scancode) { ! 1005: /* f1 f2 f3 */ ! 1006: case 0x3d: ! 1007: new_button++; ! 1008: case 0x3c: ! 1009: new_button++; ! 1010: case 0x3b: ! 1011: new_button++; ! 1012: if (kd_kbd_magic_button && (new_button != kd_kbd_magic_button)) { ! 1013: /* down w/o up */ ! 1014: } ! 1015: /* normal */ ! 1016: if (kd_kbd_magic_button == new_button) { ! 1017: kd_kbd_magic_button = 0; ! 1018: } else { ! 1019: kd_kbd_magic_button = new_button; ! 1020: } ! 1021: break; ! 1022: default: ! 1023: return 0; ! 1024: } ! 1025: return 1; ! 1026: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.