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