1 /* 2 * Kernel Debugger Architecture Dependent Console I/O handler 3 * 4 * This file is subject to the terms and conditions of the GNU General Public 5 * License. 6 * 7 * Copyright (c) 1999-2006 Silicon Graphics, Inc. All Rights Reserved. 8 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved. 9 */ 10 11 #include <linux/kdb.h> 12 #include <linux/keyboard.h> 13 #include <linux/ctype.h> 14 #include <linux/io.h> 15 16 #include "kdb_private.h" 17 18 /* Keyboard Controller Registers on normal PCs. */ 19 20 #define KBD_STATUS_REG 0x64 /* Status register (R) */ 21 #define KBD_DATA_REG 0x60 /* Keyboard data register (R/W) */ 22 23 /* Status Register Bits */ 24 25 #define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */ 26 #define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */ 27 28 static int kbd_exists; 29 static int kbd_last_ret; 30 31 /* 32 * Check if the keyboard controller has a keypress for us. 33 * Some parts (Enter Release, LED change) are still blocking polled here, 34 * but hopefully they are all short. 35 */ 36 int kdb_get_kbd_char(void) 37 { 38 int scancode, scanstatus; 39 static int shift_lock; /* CAPS LOCK state (0-off, 1-on) */ 40 static int shift_key; /* Shift next keypress */ 41 static int ctrl_key; 42 u_short keychar; 43 44 if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) || 45 (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) { 46 kbd_exists = 0; 47 return -1; 48 } 49 kbd_exists = 1; 50 51 if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) 52 return -1; 53 54 /* 55 * Fetch the scancode 56 */ 57 scancode = inb(KBD_DATA_REG); 58 scanstatus = inb(KBD_STATUS_REG); 59 60 /* 61 * Ignore mouse events. 62 */ 63 if (scanstatus & KBD_STAT_MOUSE_OBF) 64 return -1; 65 66 /* 67 * Ignore release, trigger on make 68 * (except for shift keys, where we want to 69 * keep the shift state so long as the key is 70 * held down). 71 */ 72 73 if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) { 74 /* 75 * Next key may use shift table 76 */ 77 if ((scancode & 0x80) == 0) 78 shift_key = 1; 79 else 80 shift_key = 0; 81 return -1; 82 } 83 84 if ((scancode&0x7f) == 0x1d) { 85 /* 86 * Left ctrl key 87 */ 88 if ((scancode & 0x80) == 0) 89 ctrl_key = 1; 90 else 91 ctrl_key = 0; 92 return -1; 93 } 94 95 if ((scancode & 0x80) != 0) { 96 if (scancode == 0x9c) 97 kbd_last_ret = 0; 98 return -1; 99 } 100 101 scancode &= 0x7f; 102 103 /* 104 * Translate scancode 105 */ 106 107 if (scancode == 0x3a) { 108 /* 109 * Toggle caps lock 110 */ 111 shift_lock ^= 1; 112 113 #ifdef KDB_BLINK_LED 114 kdb_toggleled(0x4); 115 #endif 116 return -1; 117 } 118 119 if (scancode == 0x0e) { 120 /* 121 * Backspace 122 */ 123 return 8; 124 } 125 126 /* Special Key */ 127 switch (scancode) { 128 case 0xF: /* Tab */ 129 return 9; 130 case 0x53: /* Del */ 131 return 4; 132 case 0x47: /* Home */ 133 return 1; 134 case 0x4F: /* End */ 135 return 5; 136 case 0x4B: /* Left */ 137 return 2; 138 case 0x48: /* Up */ 139 return 16; 140 case 0x50: /* Down */ 141 return 14; 142 case 0x4D: /* Right */ 143 return 6; 144 } 145 146 if (scancode == 0xe0) 147 return -1; 148 149 /* 150 * For Japanese 86/106 keyboards 151 * See comment in drivers/char/pc_keyb.c. 152 * - Masahiro Adegawa 153 */ 154 if (scancode == 0x73) 155 scancode = 0x59; 156 else if (scancode == 0x7d) 157 scancode = 0x7c; 158 159 if (!shift_lock && !shift_key && !ctrl_key) { 160 keychar = plain_map[scancode]; 161 } else if ((shift_lock || shift_key) && key_maps[1]) { 162 keychar = key_maps[1][scancode]; 163 } else if (ctrl_key && key_maps[4]) { 164 keychar = key_maps[4][scancode]; 165 } else { 166 keychar = 0x0020; 167 kdb_printf("Unknown state/scancode (%d)\n", scancode); 168 } 169 keychar &= 0x0fff; 170 if (keychar == '\t') 171 keychar = ' '; 172 switch (KTYP(keychar)) { 173 case KT_LETTER: 174 case KT_LATIN: 175 if (isprint(keychar)) 176 break; /* printable characters */ 177 fallthrough; 178 case KT_SPEC: 179 if (keychar == K_ENTER) 180 break; 181 fallthrough; 182 default: 183 return -1; /* ignore unprintables */ 184 } 185 186 if (scancode == 0x1c) { 187 kbd_last_ret = 1; 188 return 13; 189 } 190 191 return keychar & 0xff; 192 } 193 EXPORT_SYMBOL_GPL(kdb_get_kbd_char); 194 195 /* 196 * Best effort cleanup of ENTER break codes on leaving KDB. Called on 197 * exiting KDB, when we know we processed an ENTER or KP ENTER scan 198 * code. 199 */ 200 void kdb_kbd_cleanup_state(void) 201 { 202 int scancode, scanstatus; 203 204 /* 205 * Nothing to clean up, since either 206 * ENTER was never pressed, or has already 207 * gotten cleaned up. 208 */ 209 if (!kbd_last_ret) 210 return; 211 212 kbd_last_ret = 0; 213 /* 214 * Enter key. Need to absorb the break code here, lest it gets 215 * leaked out if we exit KDB as the result of processing 'g'. 216 * 217 * This has several interesting implications: 218 * + Need to handle KP ENTER, which has break code 0xe0 0x9c. 219 * + Need to handle repeat ENTER and repeat KP ENTER. Repeats 220 * only get a break code at the end of the repeated 221 * sequence. This means we can't propagate the repeated key 222 * press, and must swallow it away. 223 * + Need to handle possible PS/2 mouse input. 224 * + Need to handle mashed keys. 225 */ 226 227 while (1) { 228 while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) 229 cpu_relax(); 230 231 /* 232 * Fetch the scancode. 233 */ 234 scancode = inb(KBD_DATA_REG); 235 scanstatus = inb(KBD_STATUS_REG); 236 237 /* 238 * Skip mouse input. 239 */ 240 if (scanstatus & KBD_STAT_MOUSE_OBF) 241 continue; 242 243 /* 244 * If we see 0xe0, this is either a break code for KP 245 * ENTER, or a repeat make for KP ENTER. Either way, 246 * since the second byte is equivalent to an ENTER, 247 * skip the 0xe0 and try again. 248 * 249 * If we see 0x1c, this must be a repeat ENTER or KP 250 * ENTER (and we swallowed 0xe0 before). Try again. 251 * 252 * We can also see make and break codes for other keys 253 * mashed before or after pressing ENTER. Thus, if we 254 * see anything other than 0x9c, we have to try again. 255 * 256 * Note, if you held some key as ENTER was depressed, 257 * that break code would get leaked out. 258 */ 259 if (scancode != 0x9c) 260 continue; 261 262 return; 263 } 264 } 265