1 /* 2 * Translate key codes into ASCII 3 * 4 * Copyright (c) 2011 The Chromium OS Authors. 5 * (C) Copyright 2004 DENX Software Engineering, Wolfgang Denk, wd@denx.de 6 * 7 * See file CREDITS for list of people who contributed to this 8 * project. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License as 12 * published by the Free Software Foundation; either version 2 of 13 * the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 23 * MA 02111-1307 USA 24 */ 25 26 #include <common.h> 27 #include <stdio_dev.h> 28 #include <input.h> 29 #include <linux/input.h> 30 31 enum { 32 /* These correspond to the lights on the keyboard */ 33 FLAG_NUM_LOCK = 1 << 0, 34 FLAG_CAPS_LOCK = 1 << 1, 35 FLAG_SCROLL_LOCK = 1 << 2, 36 37 /* Special flag ORed with key code to indicate release */ 38 KEY_RELEASE = 1 << 15, 39 KEY_MASK = 0xfff, 40 }; 41 42 /* 43 * These takes map key codes to ASCII. 0xff means no key, or special key. 44 * Three tables are provided - one for plain keys, one for when the shift 45 * 'modifier' key is pressed and one for when the ctrl modifier key is 46 * pressed. 47 */ 48 static const uchar kbd_plain_xlate[] = { 49 0xff, 0x1b, '1', '2', '3', '4', '5', '6', 50 '7', '8', '9', '0', '-', '=', '\b', '\t', /* 0x00 - 0x0f */ 51 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 52 'o', 'p', '[', ']', '\r', 0xff, 'a', 's', /* 0x10 - 0x1f */ 53 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', 54 '\'', '`', 0xff, '\\', 'z', 'x', 'c', 'v', /* 0x20 - 0x2f */ 55 'b', 'n', 'm', ',' , '.', '/', 0xff, 0xff, 0xff, 56 ' ', 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x30 - 0x3f */ 57 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, '7', 58 '8', '9', '-', '4', '5', '6', '+', '1', /* 0x40 - 0x4f */ 59 '2', '3', '0', '.', 0xff, 0xff, 0xff, 0xff, 60 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x50 - 0x5F */ 61 '\r', 0xff, 0xff 62 }; 63 64 static unsigned char kbd_shift_xlate[] = { 65 0xff, 0x1b, '!', '@', '#', '$', '%', '^', 66 '&', '*', '(', ')', '_', '+', '\b', '\t', /* 0x00 - 0x0f */ 67 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 68 'O', 'P', '{', '}', '\r', 0xff, 'A', 'S', /* 0x10 - 0x1f */ 69 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', 70 '"', '~', 0xff, '|', 'Z', 'X', 'C', 'V', /* 0x20 - 0x2f */ 71 'B', 'N', 'M', '<', '>', '?', 0xff, 0xff, 0xff, 72 ' ', 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x30 - 0x3f */ 73 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, '7', 74 '8', '9', '-', '4', '5', '6', '+', '1', /* 0x40 - 0x4f */ 75 '2', '3', '0', '.', 0xff, 0xff, 0xff, 0xff, 0xff, 76 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x50 - 0x5F */ 77 '\r', 0xff, 0xff 78 }; 79 80 static unsigned char kbd_ctrl_xlate[] = { 81 0xff, 0x1b, '1', 0x00, '3', '4', '5', 0x1E, 82 '7', '8', '9', '0', 0x1F, '=', '\b', '\t', /* 0x00 - 0x0f */ 83 0x11, 0x17, 0x05, 0x12, 0x14, 0x18, 0x15, 0x09, 84 0x0f, 0x10, 0x1b, 0x1d, '\n', 0xff, 0x01, 0x13, /* 0x10 - 0x1f */ 85 0x04, 0x06, 0x08, 0x09, 0x0a, 0x0b, 0x0c, ';', 86 '\'', '~', 0x00, 0x1c, 0x1a, 0x18, 0x03, 0x16, /* 0x20 - 0x2f */ 87 0x02, 0x0e, 0x0d, '<', '>', '?', 0xff, 0xff, 88 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x30 - 0x3f */ 89 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, '7', 90 '8', '9', '-', '4', '5', '6', '+', '1', /* 0x40 - 0x4f */ 91 '2', '3', '0', '.', 0xff, 0xff, 0xff, 0xff, 92 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x50 - 0x5F */ 93 '\r', 0xff, 0xff 94 }; 95 96 97 int input_queue_ascii(struct input_config *config, int ch) 98 { 99 if (config->fifo_in + 1 == INPUT_BUFFER_LEN) { 100 if (!config->fifo_out) 101 return -1; /* buffer full */ 102 else 103 config->fifo_in = 0; 104 } else { 105 if (config->fifo_in + 1 == config->fifo_out) 106 return -1; /* buffer full */ 107 config->fifo_in++; 108 } 109 config->fifo[config->fifo_in] = (uchar)ch; 110 111 return 0; 112 } 113 114 int input_tstc(struct input_config *config) 115 { 116 if (config->fifo_in == config->fifo_out && config->read_keys) { 117 if (!(*config->read_keys)(config)) 118 return 0; 119 } 120 return config->fifo_in != config->fifo_out; 121 } 122 123 int input_getc(struct input_config *config) 124 { 125 int err = 0; 126 127 while (config->fifo_in == config->fifo_out) { 128 if (config->read_keys) 129 err = (*config->read_keys)(config); 130 if (err) 131 return -1; 132 } 133 134 if (++config->fifo_out == INPUT_BUFFER_LEN) 135 config->fifo_out = 0; 136 137 return config->fifo[config->fifo_out]; 138 } 139 140 /** 141 * Process a modifier/special key press or release and decide which key 142 * translation array should be used as a result. 143 * 144 * TODO: Should keep track of modifier press/release 145 * 146 * @param config Input state 147 * @param key Key code to process 148 * @param release 0 if a press, 1 if a release 149 * @return pointer to keycode->ascii translation table that should be used 150 */ 151 static struct input_key_xlate *process_modifier(struct input_config *config, 152 int key, int release) 153 { 154 struct input_key_xlate *table; 155 int flip = -1; 156 int i; 157 158 /* Start with the main table, and see what modifiers change it */ 159 assert(config->num_tables > 0); 160 table = &config->table[0]; 161 for (i = 1; i < config->num_tables; i++) { 162 struct input_key_xlate *tab = &config->table[i]; 163 164 if (key == tab->left_keycode || key == tab->right_keycode) 165 table = tab; 166 } 167 168 /* Handle the lighted keys */ 169 if (!release) { 170 switch (key) { 171 case KEY_SCROLLLOCK: 172 flip = FLAG_SCROLL_LOCK; 173 break; 174 case KEY_NUMLOCK: 175 flip = FLAG_NUM_LOCK; 176 break; 177 case KEY_CAPSLOCK: 178 flip = FLAG_CAPS_LOCK; 179 break; 180 } 181 } 182 183 if (flip != -1) { 184 int leds = 0; 185 186 config->leds ^= flip; 187 if (config->flags & FLAG_NUM_LOCK) 188 leds |= INPUT_LED_NUM; 189 if (config->flags & FLAG_CAPS_LOCK) 190 leds |= INPUT_LED_CAPS; 191 if (config->flags & FLAG_SCROLL_LOCK) 192 leds |= INPUT_LED_SCROLL; 193 config->leds = leds; 194 } 195 196 return table; 197 } 198 199 /** 200 * Search an int array for a key value 201 * 202 * @param array Array to search 203 * @param count Number of elements in array 204 * @param key Key value to find 205 * @return element where value was first found, -1 if none 206 */ 207 static int array_search(int *array, int count, int key) 208 { 209 int i; 210 211 for (i = 0; i < count; i++) { 212 if (array[i] == key) 213 return i; 214 } 215 216 return -1; 217 } 218 219 /** 220 * Sort an array so that those elements that exist in the ordering are 221 * first in the array, and in the same order as the ordering. The algorithm 222 * is O(count * ocount) and designed for small arrays. 223 * 224 * TODO: Move this to common / lib? 225 * 226 * @param dest Array with elements to sort, also destination array 227 * @param count Number of elements to sort 228 * @param order Array containing ordering elements 229 * @param ocount Number of ordering elements 230 * @return number of elements in dest that are in order (these will be at the 231 * start of dest). 232 */ 233 static int sort_array_by_ordering(int *dest, int count, int *order, 234 int ocount) 235 { 236 int temp[count]; 237 int dest_count; 238 int same; /* number of elements which are the same */ 239 int i; 240 241 /* setup output items, copy items to be sorted into our temp area */ 242 memcpy(temp, dest, count * sizeof(*dest)); 243 dest_count = 0; 244 245 /* work through the ordering, move over the elements we agree on */ 246 for (i = 0; i < ocount; i++) { 247 if (array_search(temp, count, order[i]) != -1) 248 dest[dest_count++] = order[i]; 249 } 250 same = dest_count; 251 252 /* now move over the elements that are not in the ordering */ 253 for (i = 0; i < count; i++) { 254 if (array_search(order, ocount, temp[i]) == -1) 255 dest[dest_count++] = temp[i]; 256 } 257 assert(dest_count == count); 258 return same; 259 } 260 261 /** 262 * Check a list of key codes against the previous key scan 263 * 264 * Given a list of new key codes, we check how many of these are the same 265 * as last time. 266 * 267 * @param config Input state 268 * @param keycode List of key codes to examine 269 * @param num_keycodes Number of key codes 270 * @param same Returns number of key codes which are the same 271 */ 272 static int input_check_keycodes(struct input_config *config, 273 int keycode[], int num_keycodes, int *same) 274 { 275 /* Select the 'plain' xlate table to start with */ 276 if (!config->num_tables) { 277 debug("%s: No xlate tables: cannot decode keys\n", __func__); 278 return -1; 279 } 280 281 /* sort the keycodes into the same order as the previous ones */ 282 *same = sort_array_by_ordering(keycode, num_keycodes, 283 config->prev_keycodes, config->num_prev_keycodes); 284 285 memcpy(config->prev_keycodes, keycode, num_keycodes * sizeof(int)); 286 config->num_prev_keycodes = num_keycodes; 287 288 return *same != num_keycodes; 289 } 290 291 /** 292 * Convert a list of key codes into ASCII 293 * 294 * You must call input_check_keycodes() before this. It turns the keycode 295 * list into a list of ASCII characters which are ready to send to the 296 * input layer. 297 * 298 * Characters which were seen last time do not generate fresh ASCII output. 299 * 300 * @param config Input state 301 * @param keycode List of key codes to examine 302 * @param num_keycodes Number of key codes 303 * @param same Number of key codes which are the same 304 */ 305 static int input_keycodes_to_ascii(struct input_config *config, 306 int keycode[], int num_keycodes, char output_ch[], int same) 307 { 308 struct input_key_xlate *table; 309 int ch_count; 310 int i; 311 312 table = &config->table[0]; 313 314 /* deal with modifiers first */ 315 for (i = 0; i < num_keycodes; i++) { 316 int key = keycode[i] & KEY_MASK; 317 318 if (key >= table->num_entries || table->xlate[key] == 0xff) { 319 table = process_modifier(config, key, 320 keycode[i] & KEY_RELEASE); 321 } 322 } 323 324 /* now find normal keys */ 325 for (i = ch_count = 0; i < num_keycodes; i++) { 326 int key = keycode[i]; 327 328 if (key < table->num_entries && i >= same) { 329 int ch = table->xlate[key]; 330 331 /* If a normal key with an ASCII value, add it! */ 332 if (ch != 0xff) 333 output_ch[ch_count++] = (uchar)ch; 334 } 335 } 336 337 /* ok, so return keys */ 338 return ch_count; 339 } 340 341 int input_send_keycodes(struct input_config *config, 342 int keycode[], int num_keycodes) 343 { 344 char ch[num_keycodes]; 345 int count, i, same = 0; 346 int is_repeat = 0; 347 unsigned delay_ms; 348 349 config->modifiers = 0; 350 if (!input_check_keycodes(config, keycode, num_keycodes, &same)) { 351 /* 352 * Same as last time - is it time for another repeat? 353 * TODO(sjg@chromium.org) We drop repeats here and since 354 * the caller may not call in again for a while, our 355 * auto-repeat speed is not quite correct. We should 356 * insert another character if we later realise that we 357 * have missed a repeat slot. 358 */ 359 is_repeat = (int)get_timer(config->next_repeat_ms) >= 0; 360 if (!is_repeat) 361 return 0; 362 } 363 364 count = input_keycodes_to_ascii(config, keycode, num_keycodes, 365 ch, is_repeat ? 0 : same); 366 for (i = 0; i < count; i++) 367 input_queue_ascii(config, ch[i]); 368 delay_ms = is_repeat ? 369 config->repeat_rate_ms : 370 config->repeat_delay_ms; 371 372 config->next_repeat_ms = get_timer(0) + delay_ms; 373 return 0; 374 } 375 376 int input_add_table(struct input_config *config, int left_keycode, 377 int right_keycode, const uchar *xlate, int num_entries) 378 { 379 struct input_key_xlate *table; 380 381 if (config->num_tables == INPUT_MAX_MODIFIERS) { 382 debug("%s: Too many modifier tables\n", __func__); 383 return -1; 384 } 385 386 table = &config->table[config->num_tables++]; 387 table->left_keycode = left_keycode; 388 table->right_keycode = right_keycode; 389 table->xlate = xlate; 390 table->num_entries = num_entries; 391 392 return 0; 393 } 394 395 int input_init(struct input_config *config, int leds, int repeat_delay_ms, 396 int repeat_rate_ms) 397 { 398 memset(config, '\0', sizeof(*config)); 399 config->leds = leds; 400 config->repeat_delay_ms = repeat_delay_ms; 401 config->repeat_rate_ms = repeat_rate_ms; 402 if (input_add_table(config, -1, -1, 403 kbd_plain_xlate, ARRAY_SIZE(kbd_plain_xlate)) || 404 input_add_table(config, KEY_LEFTSHIFT, KEY_RIGHTSHIFT, 405 kbd_shift_xlate, ARRAY_SIZE(kbd_shift_xlate)) || 406 input_add_table(config, KEY_LEFTCTRL, KEY_RIGHTCTRL, 407 kbd_ctrl_xlate, ARRAY_SIZE(kbd_ctrl_xlate))) { 408 debug("%s: Could not add modifier tables\n", __func__); 409 return -1; 410 } 411 412 return 0; 413 } 414 415 int input_stdio_register(struct stdio_dev *dev) 416 { 417 int error; 418 419 error = stdio_register(dev); 420 421 /* check if this is the standard input device */ 422 if (!error && strcmp(getenv("stdin"), dev->name) == 0) { 423 /* reassign the console */ 424 if (OVERWRITE_CONSOLE || 425 console_assign(stdin, dev->name)) 426 return -1; 427 } 428 429 return 0; 430 } 431