keyboard.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387
  1. /*
  2. * linux/drivers/char/keyboard.c
  3. *
  4. * Written for linux by Johan Myreen as a translation from
  5. * the assembly version by Linus (with diacriticals added)
  6. *
  7. * Some additional features added by Christoph Niemann (ChN), March 1993
  8. *
  9. * Loadable keymaps by Risto Kankkunen, May 1993
  10. *
  11. * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
  12. * Added decr/incr_console, dynamic keymaps, Unicode support,
  13. * dynamic function/string keys, led setting, Sept 1994
  14. * `Sticky' modifier keys, 951006.
  15. *
  16. * 11-11-96: SAK should now work in the raw mode (Martin Mares)
  17. *
  18. * Modified to provide 'generic' keyboard support by Hamish Macdonald
  19. * Merge with the m68k keyboard driver and split-off of the PC low-level
  20. * parts by Geert Uytterhoeven, May 1997
  21. *
  22. * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
  23. * 30-07-98: Dead keys redone, aeb@cwi.nl.
  24. * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
  25. */
  26. #include <linux/module.h>
  27. #include <linux/sched.h>
  28. #include <linux/tty.h>
  29. #include <linux/tty_flip.h>
  30. #include <linux/mm.h>
  31. #include <linux/string.h>
  32. #include <linux/init.h>
  33. #include <linux/slab.h>
  34. #include <linux/irq.h>
  35. #include <linux/kbd_kern.h>
  36. #include <linux/kbd_diacr.h>
  37. #include <linux/vt_kern.h>
  38. #include <linux/sysrq.h>
  39. #include <linux/input.h>
  40. #include <linux/reboot.h>
  41. static void kbd_disconnect(struct input_handle *handle);
  42. extern void ctrl_alt_del(void);
  43. /*
  44. * Exported functions/variables
  45. */
  46. #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  47. /*
  48. * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  49. * This seems a good reason to start with NumLock off. On HIL keyboards
  50. * of PARISC machines however there is no NumLock key and everyone expects the keypad
  51. * to be used for numbers.
  52. */
  53. #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  54. #define KBD_DEFLEDS (1 << VC_NUMLOCK)
  55. #else
  56. #define KBD_DEFLEDS 0
  57. #endif
  58. #define KBD_DEFLOCK 0
  59. void compute_shiftstate(void);
  60. /*
  61. * Handler Tables.
  62. */
  63. #define K_HANDLERS\
  64. k_self, k_fn, k_spec, k_pad,\
  65. k_dead, k_cons, k_cur, k_shift,\
  66. k_meta, k_ascii, k_lock, k_lowercase,\
  67. k_slock, k_dead2, k_brl, k_ignore
  68. typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
  69. char up_flag);
  70. static k_handler_fn K_HANDLERS;
  71. static k_handler_fn *k_handler[16] = { K_HANDLERS };
  72. #define FN_HANDLERS\
  73. fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
  74. fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
  75. fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
  76. fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
  77. fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
  78. typedef void (fn_handler_fn)(struct vc_data *vc);
  79. static fn_handler_fn FN_HANDLERS;
  80. static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  81. /*
  82. * Variables exported for vt_ioctl.c
  83. */
  84. /* maximum values each key_handler can handle */
  85. const int max_vals[] = {
  86. 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
  87. NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
  88. 255, NR_LOCK - 1, 255, NR_BRL - 1
  89. };
  90. const int NR_TYPES = ARRAY_SIZE(max_vals);
  91. struct kbd_struct kbd_table[MAX_NR_CONSOLES];
  92. static struct kbd_struct *kbd = kbd_table;
  93. struct vt_spawn_console vt_spawn_con = {
  94. .lock = SPIN_LOCK_UNLOCKED,
  95. .pid = NULL,
  96. .sig = 0,
  97. };
  98. /*
  99. * Variables exported for vt.c
  100. */
  101. int shift_state = 0;
  102. /*
  103. * Internal Data.
  104. */
  105. static struct input_handler kbd_handler;
  106. static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
  107. static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
  108. static int dead_key_next;
  109. static int npadch = -1; /* -1 or number assembled on pad */
  110. static unsigned int diacr;
  111. static char rep; /* flag telling character repeat */
  112. static unsigned char ledstate = 0xff; /* undefined */
  113. static unsigned char ledioctl;
  114. static struct ledptr {
  115. unsigned int *addr;
  116. unsigned int mask;
  117. unsigned char valid:1;
  118. } ledptrs[3];
  119. /* Simple translation table for the SysRq keys */
  120. #ifdef CONFIG_MAGIC_SYSRQ
  121. unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
  122. "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
  123. "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
  124. "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
  125. "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
  126. "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
  127. "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
  128. "\r\000/"; /* 0x60 - 0x6f */
  129. static int sysrq_down;
  130. static int sysrq_alt_use;
  131. #endif
  132. static int sysrq_alt;
  133. /*
  134. * Translation of scancodes to keycodes. We set them on only the first attached
  135. * keyboard - for per-keyboard setting, /dev/input/event is more useful.
  136. */
  137. int getkeycode(unsigned int scancode)
  138. {
  139. struct list_head *node;
  140. struct input_dev *dev = NULL;
  141. list_for_each(node, &kbd_handler.h_list) {
  142. struct input_handle *handle = to_handle_h(node);
  143. if (handle->dev->keycodesize) {
  144. dev = handle->dev;
  145. break;
  146. }
  147. }
  148. if (!dev)
  149. return -ENODEV;
  150. if (scancode >= dev->keycodemax)
  151. return -EINVAL;
  152. return INPUT_KEYCODE(dev, scancode);
  153. }
  154. int setkeycode(unsigned int scancode, unsigned int keycode)
  155. {
  156. struct list_head *node;
  157. struct input_dev *dev = NULL;
  158. unsigned int i, oldkey;
  159. list_for_each(node, &kbd_handler.h_list) {
  160. struct input_handle *handle = to_handle_h(node);
  161. if (handle->dev->keycodesize) {
  162. dev = handle->dev;
  163. break;
  164. }
  165. }
  166. if (!dev)
  167. return -ENODEV;
  168. if (scancode >= dev->keycodemax)
  169. return -EINVAL;
  170. if (keycode < 0 || keycode > KEY_MAX)
  171. return -EINVAL;
  172. if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
  173. return -EINVAL;
  174. oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
  175. clear_bit(oldkey, dev->keybit);
  176. set_bit(keycode, dev->keybit);
  177. for (i = 0; i < dev->keycodemax; i++)
  178. if (INPUT_KEYCODE(dev,i) == oldkey)
  179. set_bit(oldkey, dev->keybit);
  180. return 0;
  181. }
  182. /*
  183. * Making beeps and bells.
  184. */
  185. static void kd_nosound(unsigned long ignored)
  186. {
  187. struct list_head *node;
  188. list_for_each(node, &kbd_handler.h_list) {
  189. struct input_handle *handle = to_handle_h(node);
  190. if (test_bit(EV_SND, handle->dev->evbit)) {
  191. if (test_bit(SND_TONE, handle->dev->sndbit))
  192. input_inject_event(handle, EV_SND, SND_TONE, 0);
  193. if (test_bit(SND_BELL, handle->dev->sndbit))
  194. input_inject_event(handle, EV_SND, SND_BELL, 0);
  195. }
  196. }
  197. }
  198. static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
  199. void kd_mksound(unsigned int hz, unsigned int ticks)
  200. {
  201. struct list_head *node;
  202. del_timer(&kd_mksound_timer);
  203. if (hz) {
  204. list_for_each_prev(node, &kbd_handler.h_list) {
  205. struct input_handle *handle = to_handle_h(node);
  206. if (test_bit(EV_SND, handle->dev->evbit)) {
  207. if (test_bit(SND_TONE, handle->dev->sndbit)) {
  208. input_inject_event(handle, EV_SND, SND_TONE, hz);
  209. break;
  210. }
  211. if (test_bit(SND_BELL, handle->dev->sndbit)) {
  212. input_inject_event(handle, EV_SND, SND_BELL, 1);
  213. break;
  214. }
  215. }
  216. }
  217. if (ticks)
  218. mod_timer(&kd_mksound_timer, jiffies + ticks);
  219. } else
  220. kd_nosound(0);
  221. }
  222. /*
  223. * Setting the keyboard rate.
  224. */
  225. int kbd_rate(struct kbd_repeat *rep)
  226. {
  227. struct list_head *node;
  228. unsigned int d = 0;
  229. unsigned int p = 0;
  230. list_for_each(node, &kbd_handler.h_list) {
  231. struct input_handle *handle = to_handle_h(node);
  232. struct input_dev *dev = handle->dev;
  233. if (test_bit(EV_REP, dev->evbit)) {
  234. if (rep->delay > 0)
  235. input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
  236. if (rep->period > 0)
  237. input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
  238. d = dev->rep[REP_DELAY];
  239. p = dev->rep[REP_PERIOD];
  240. }
  241. }
  242. rep->delay = d;
  243. rep->period = p;
  244. return 0;
  245. }
  246. /*
  247. * Helper Functions.
  248. */
  249. static void put_queue(struct vc_data *vc, int ch)
  250. {
  251. struct tty_struct *tty = vc->vc_tty;
  252. if (tty) {
  253. tty_insert_flip_char(tty, ch, 0);
  254. con_schedule_flip(tty);
  255. }
  256. }
  257. static void puts_queue(struct vc_data *vc, char *cp)
  258. {
  259. struct tty_struct *tty = vc->vc_tty;
  260. if (!tty)
  261. return;
  262. while (*cp) {
  263. tty_insert_flip_char(tty, *cp, 0);
  264. cp++;
  265. }
  266. con_schedule_flip(tty);
  267. }
  268. static void applkey(struct vc_data *vc, int key, char mode)
  269. {
  270. static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
  271. buf[1] = (mode ? 'O' : '[');
  272. buf[2] = key;
  273. puts_queue(vc, buf);
  274. }
  275. /*
  276. * Many other routines do put_queue, but I think either
  277. * they produce ASCII, or they produce some user-assigned
  278. * string, and in both cases we might assume that it is
  279. * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
  280. * but we need only 16 bits here
  281. */
  282. static void to_utf8(struct vc_data *vc, ushort c)
  283. {
  284. if (c < 0x80)
  285. /* 0******* */
  286. put_queue(vc, c);
  287. else if (c < 0x800) {
  288. /* 110***** 10****** */
  289. put_queue(vc, 0xc0 | (c >> 6));
  290. put_queue(vc, 0x80 | (c & 0x3f));
  291. } else {
  292. /* 1110**** 10****** 10****** */
  293. put_queue(vc, 0xe0 | (c >> 12));
  294. put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
  295. put_queue(vc, 0x80 | (c & 0x3f));
  296. }
  297. }
  298. /*
  299. * Called after returning from RAW mode or when changing consoles - recompute
  300. * shift_down[] and shift_state from key_down[] maybe called when keymap is
  301. * undefined, so that shiftkey release is seen
  302. */
  303. void compute_shiftstate(void)
  304. {
  305. unsigned int i, j, k, sym, val;
  306. shift_state = 0;
  307. memset(shift_down, 0, sizeof(shift_down));
  308. for (i = 0; i < ARRAY_SIZE(key_down); i++) {
  309. if (!key_down[i])
  310. continue;
  311. k = i * BITS_PER_LONG;
  312. for (j = 0; j < BITS_PER_LONG; j++, k++) {
  313. if (!test_bit(k, key_down))
  314. continue;
  315. sym = U(key_maps[0][k]);
  316. if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
  317. continue;
  318. val = KVAL(sym);
  319. if (val == KVAL(K_CAPSSHIFT))
  320. val = KVAL(K_SHIFT);
  321. shift_down[val]++;
  322. shift_state |= (1 << val);
  323. }
  324. }
  325. }
  326. /*
  327. * We have a combining character DIACR here, followed by the character CH.
  328. * If the combination occurs in the table, return the corresponding value.
  329. * Otherwise, if CH is a space or equals DIACR, return DIACR.
  330. * Otherwise, conclude that DIACR was not combining after all,
  331. * queue it and return CH.
  332. */
  333. static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
  334. {
  335. unsigned int d = diacr;
  336. unsigned int i;
  337. diacr = 0;
  338. if ((d & ~0xff) == BRL_UC_ROW) {
  339. if ((ch & ~0xff) == BRL_UC_ROW)
  340. return d | ch;
  341. } else {
  342. for (i = 0; i < accent_table_size; i++)
  343. if (accent_table[i].diacr == d && accent_table[i].base == ch)
  344. return accent_table[i].result;
  345. }
  346. if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
  347. return d;
  348. if (kbd->kbdmode == VC_UNICODE)
  349. to_utf8(vc, d);
  350. else if (d < 0x100)
  351. put_queue(vc, d);
  352. return ch;
  353. }
  354. /*
  355. * Special function handlers
  356. */
  357. static void fn_enter(struct vc_data *vc)
  358. {
  359. if (diacr) {
  360. if (kbd->kbdmode == VC_UNICODE)
  361. to_utf8(vc, diacr);
  362. else if (diacr < 0x100)
  363. put_queue(vc, diacr);
  364. diacr = 0;
  365. }
  366. put_queue(vc, 13);
  367. if (vc_kbd_mode(kbd, VC_CRLF))
  368. put_queue(vc, 10);
  369. }
  370. static void fn_caps_toggle(struct vc_data *vc)
  371. {
  372. if (rep)
  373. return;
  374. chg_vc_kbd_led(kbd, VC_CAPSLOCK);
  375. }
  376. static void fn_caps_on(struct vc_data *vc)
  377. {
  378. if (rep)
  379. return;
  380. set_vc_kbd_led(kbd, VC_CAPSLOCK);
  381. }
  382. static void fn_show_ptregs(struct vc_data *vc)
  383. {
  384. struct pt_regs *regs = get_irq_regs();
  385. if (regs)
  386. show_regs(regs);
  387. }
  388. static void fn_hold(struct vc_data *vc)
  389. {
  390. struct tty_struct *tty = vc->vc_tty;
  391. if (rep || !tty)
  392. return;
  393. /*
  394. * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
  395. * these routines are also activated by ^S/^Q.
  396. * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
  397. */
  398. if (tty->stopped)
  399. start_tty(tty);
  400. else
  401. stop_tty(tty);
  402. }
  403. static void fn_num(struct vc_data *vc)
  404. {
  405. if (vc_kbd_mode(kbd,VC_APPLIC))
  406. applkey(vc, 'P', 1);
  407. else
  408. fn_bare_num(vc);
  409. }
  410. /*
  411. * Bind this to Shift-NumLock if you work in application keypad mode
  412. * but want to be able to change the NumLock flag.
  413. * Bind this to NumLock if you prefer that the NumLock key always
  414. * changes the NumLock flag.
  415. */
  416. static void fn_bare_num(struct vc_data *vc)
  417. {
  418. if (!rep)
  419. chg_vc_kbd_led(kbd, VC_NUMLOCK);
  420. }
  421. static void fn_lastcons(struct vc_data *vc)
  422. {
  423. /* switch to the last used console, ChN */
  424. set_console(last_console);
  425. }
  426. static void fn_dec_console(struct vc_data *vc)
  427. {
  428. int i, cur = fg_console;
  429. /* Currently switching? Queue this next switch relative to that. */
  430. if (want_console != -1)
  431. cur = want_console;
  432. for (i = cur - 1; i != cur; i--) {
  433. if (i == -1)
  434. i = MAX_NR_CONSOLES - 1;
  435. if (vc_cons_allocated(i))
  436. break;
  437. }
  438. set_console(i);
  439. }
  440. static void fn_inc_console(struct vc_data *vc)
  441. {
  442. int i, cur = fg_console;
  443. /* Currently switching? Queue this next switch relative to that. */
  444. if (want_console != -1)
  445. cur = want_console;
  446. for (i = cur+1; i != cur; i++) {
  447. if (i == MAX_NR_CONSOLES)
  448. i = 0;
  449. if (vc_cons_allocated(i))
  450. break;
  451. }
  452. set_console(i);
  453. }
  454. static void fn_send_intr(struct vc_data *vc)
  455. {
  456. struct tty_struct *tty = vc->vc_tty;
  457. if (!tty)
  458. return;
  459. tty_insert_flip_char(tty, 0, TTY_BREAK);
  460. con_schedule_flip(tty);
  461. }
  462. static void fn_scroll_forw(struct vc_data *vc)
  463. {
  464. scrollfront(vc, 0);
  465. }
  466. static void fn_scroll_back(struct vc_data *vc)
  467. {
  468. scrollback(vc, 0);
  469. }
  470. static void fn_show_mem(struct vc_data *vc)
  471. {
  472. show_mem();
  473. }
  474. static void fn_show_state(struct vc_data *vc)
  475. {
  476. show_state();
  477. }
  478. static void fn_boot_it(struct vc_data *vc)
  479. {
  480. ctrl_alt_del();
  481. }
  482. static void fn_compose(struct vc_data *vc)
  483. {
  484. dead_key_next = 1;
  485. }
  486. static void fn_spawn_con(struct vc_data *vc)
  487. {
  488. spin_lock(&vt_spawn_con.lock);
  489. if (vt_spawn_con.pid)
  490. if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
  491. put_pid(vt_spawn_con.pid);
  492. vt_spawn_con.pid = NULL;
  493. }
  494. spin_unlock(&vt_spawn_con.lock);
  495. }
  496. static void fn_SAK(struct vc_data *vc)
  497. {
  498. struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
  499. schedule_work(SAK_work);
  500. }
  501. static void fn_null(struct vc_data *vc)
  502. {
  503. compute_shiftstate();
  504. }
  505. /*
  506. * Special key handlers
  507. */
  508. static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
  509. {
  510. }
  511. static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
  512. {
  513. if (up_flag)
  514. return;
  515. if (value >= ARRAY_SIZE(fn_handler))
  516. return;
  517. if ((kbd->kbdmode == VC_RAW ||
  518. kbd->kbdmode == VC_MEDIUMRAW) &&
  519. value != KVAL(K_SAK))
  520. return; /* SAK is allowed even in raw mode */
  521. fn_handler[value](vc);
  522. }
  523. static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
  524. {
  525. printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
  526. }
  527. static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
  528. {
  529. if (up_flag)
  530. return; /* no action, if this is a key release */
  531. if (diacr)
  532. value = handle_diacr(vc, value);
  533. if (dead_key_next) {
  534. dead_key_next = 0;
  535. diacr = value;
  536. return;
  537. }
  538. if (kbd->kbdmode == VC_UNICODE)
  539. to_utf8(vc, value);
  540. else if (value < 0x100)
  541. put_queue(vc, value);
  542. }
  543. /*
  544. * Handle dead key. Note that we now may have several
  545. * dead keys modifying the same character. Very useful
  546. * for Vietnamese.
  547. */
  548. static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
  549. {
  550. if (up_flag)
  551. return;
  552. diacr = (diacr ? handle_diacr(vc, value) : value);
  553. }
  554. static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
  555. {
  556. k_unicode(vc, value, up_flag);
  557. }
  558. static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
  559. {
  560. k_deadunicode(vc, value, up_flag);
  561. }
  562. /*
  563. * Obsolete - for backwards compatibility only
  564. */
  565. static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
  566. {
  567. static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
  568. value = ret_diacr[value];
  569. k_deadunicode(vc, value, up_flag);
  570. }
  571. static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
  572. {
  573. if (up_flag)
  574. return;
  575. set_console(value);
  576. }
  577. static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
  578. {
  579. unsigned v;
  580. if (up_flag)
  581. return;
  582. v = value;
  583. if (v < ARRAY_SIZE(func_table)) {
  584. if (func_table[value])
  585. puts_queue(vc, func_table[value]);
  586. } else
  587. printk(KERN_ERR "k_fn called with value=%d\n", value);
  588. }
  589. static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
  590. {
  591. static const char cur_chars[] = "BDCA";
  592. if (up_flag)
  593. return;
  594. applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
  595. }
  596. static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
  597. {
  598. static const char pad_chars[] = "0123456789+-*/\015,.?()#";
  599. static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
  600. if (up_flag)
  601. return; /* no action, if this is a key release */
  602. /* kludge... shift forces cursor/number keys */
  603. if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
  604. applkey(vc, app_map[value], 1);
  605. return;
  606. }
  607. if (!vc_kbd_led(kbd, VC_NUMLOCK))
  608. switch (value) {
  609. case KVAL(K_PCOMMA):
  610. case KVAL(K_PDOT):
  611. k_fn(vc, KVAL(K_REMOVE), 0);
  612. return;
  613. case KVAL(K_P0):
  614. k_fn(vc, KVAL(K_INSERT), 0);
  615. return;
  616. case KVAL(K_P1):
  617. k_fn(vc, KVAL(K_SELECT), 0);
  618. return;
  619. case KVAL(K_P2):
  620. k_cur(vc, KVAL(K_DOWN), 0);
  621. return;
  622. case KVAL(K_P3):
  623. k_fn(vc, KVAL(K_PGDN), 0);
  624. return;
  625. case KVAL(K_P4):
  626. k_cur(vc, KVAL(K_LEFT), 0);
  627. return;
  628. case KVAL(K_P6):
  629. k_cur(vc, KVAL(K_RIGHT), 0);
  630. return;
  631. case KVAL(K_P7):
  632. k_fn(vc, KVAL(K_FIND), 0);
  633. return;
  634. case KVAL(K_P8):
  635. k_cur(vc, KVAL(K_UP), 0);
  636. return;
  637. case KVAL(K_P9):
  638. k_fn(vc, KVAL(K_PGUP), 0);
  639. return;
  640. case KVAL(K_P5):
  641. applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
  642. return;
  643. }
  644. put_queue(vc, pad_chars[value]);
  645. if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
  646. put_queue(vc, 10);
  647. }
  648. static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
  649. {
  650. int old_state = shift_state;
  651. if (rep)
  652. return;
  653. /*
  654. * Mimic typewriter:
  655. * a CapsShift key acts like Shift but undoes CapsLock
  656. */
  657. if (value == KVAL(K_CAPSSHIFT)) {
  658. value = KVAL(K_SHIFT);
  659. if (!up_flag)
  660. clr_vc_kbd_led(kbd, VC_CAPSLOCK);
  661. }
  662. if (up_flag) {
  663. /*
  664. * handle the case that two shift or control
  665. * keys are depressed simultaneously
  666. */
  667. if (shift_down[value])
  668. shift_down[value]--;
  669. } else
  670. shift_down[value]++;
  671. if (shift_down[value])
  672. shift_state |= (1 << value);
  673. else
  674. shift_state &= ~(1 << value);
  675. /* kludge */
  676. if (up_flag && shift_state != old_state && npadch != -1) {
  677. if (kbd->kbdmode == VC_UNICODE)
  678. to_utf8(vc, npadch & 0xffff);
  679. else
  680. put_queue(vc, npadch & 0xff);
  681. npadch = -1;
  682. }
  683. }
  684. static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
  685. {
  686. if (up_flag)
  687. return;
  688. if (vc_kbd_mode(kbd, VC_META)) {
  689. put_queue(vc, '\033');
  690. put_queue(vc, value);
  691. } else
  692. put_queue(vc, value | 0x80);
  693. }
  694. static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
  695. {
  696. int base;
  697. if (up_flag)
  698. return;
  699. if (value < 10) {
  700. /* decimal input of code, while Alt depressed */
  701. base = 10;
  702. } else {
  703. /* hexadecimal input of code, while AltGr depressed */
  704. value -= 10;
  705. base = 16;
  706. }
  707. if (npadch == -1)
  708. npadch = value;
  709. else
  710. npadch = npadch * base + value;
  711. }
  712. static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
  713. {
  714. if (up_flag || rep)
  715. return;
  716. chg_vc_kbd_lock(kbd, value);
  717. }
  718. static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
  719. {
  720. k_shift(vc, value, up_flag);
  721. if (up_flag || rep)
  722. return;
  723. chg_vc_kbd_slock(kbd, value);
  724. /* try to make Alt, oops, AltGr and such work */
  725. if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
  726. kbd->slockstate = 0;
  727. chg_vc_kbd_slock(kbd, value);
  728. }
  729. }
  730. /* by default, 300ms interval for combination release */
  731. static unsigned brl_timeout = 300;
  732. MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
  733. module_param(brl_timeout, uint, 0644);
  734. static unsigned brl_nbchords = 1;
  735. MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
  736. module_param(brl_nbchords, uint, 0644);
  737. static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
  738. {
  739. static unsigned long chords;
  740. static unsigned committed;
  741. if (!brl_nbchords)
  742. k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
  743. else {
  744. committed |= pattern;
  745. chords++;
  746. if (chords == brl_nbchords) {
  747. k_unicode(vc, BRL_UC_ROW | committed, up_flag);
  748. chords = 0;
  749. committed = 0;
  750. }
  751. }
  752. }
  753. static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
  754. {
  755. static unsigned pressed,committing;
  756. static unsigned long releasestart;
  757. if (kbd->kbdmode != VC_UNICODE) {
  758. if (!up_flag)
  759. printk("keyboard mode must be unicode for braille patterns\n");
  760. return;
  761. }
  762. if (!value) {
  763. k_unicode(vc, BRL_UC_ROW, up_flag);
  764. return;
  765. }
  766. if (value > 8)
  767. return;
  768. if (up_flag) {
  769. if (brl_timeout) {
  770. if (!committing ||
  771. jiffies - releasestart > (brl_timeout * HZ) / 1000) {
  772. committing = pressed;
  773. releasestart = jiffies;
  774. }
  775. pressed &= ~(1 << (value - 1));
  776. if (!pressed) {
  777. if (committing) {
  778. k_brlcommit(vc, committing, 0);
  779. committing = 0;
  780. }
  781. }
  782. } else {
  783. if (committing) {
  784. k_brlcommit(vc, committing, 0);
  785. committing = 0;
  786. }
  787. pressed &= ~(1 << (value - 1));
  788. }
  789. } else {
  790. pressed |= 1 << (value - 1);
  791. if (!brl_timeout)
  792. committing = pressed;
  793. }
  794. }
  795. /*
  796. * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
  797. * or (ii) whatever pattern of lights people want to show using KDSETLED,
  798. * or (iii) specified bits of specified words in kernel memory.
  799. */
  800. unsigned char getledstate(void)
  801. {
  802. return ledstate;
  803. }
  804. void setledstate(struct kbd_struct *kbd, unsigned int led)
  805. {
  806. if (!(led & ~7)) {
  807. ledioctl = led;
  808. kbd->ledmode = LED_SHOW_IOCTL;
  809. } else
  810. kbd->ledmode = LED_SHOW_FLAGS;
  811. set_leds();
  812. }
  813. static inline unsigned char getleds(void)
  814. {
  815. struct kbd_struct *kbd = kbd_table + fg_console;
  816. unsigned char leds;
  817. int i;
  818. if (kbd->ledmode == LED_SHOW_IOCTL)
  819. return ledioctl;
  820. leds = kbd->ledflagstate;
  821. if (kbd->ledmode == LED_SHOW_MEM) {
  822. for (i = 0; i < 3; i++)
  823. if (ledptrs[i].valid) {
  824. if (*ledptrs[i].addr & ledptrs[i].mask)
  825. leds |= (1 << i);
  826. else
  827. leds &= ~(1 << i);
  828. }
  829. }
  830. return leds;
  831. }
  832. /*
  833. * This routine is the bottom half of the keyboard interrupt
  834. * routine, and runs with all interrupts enabled. It does
  835. * console changing, led setting and copy_to_cooked, which can
  836. * take a reasonably long time.
  837. *
  838. * Aside from timing (which isn't really that important for
  839. * keyboard interrupts as they happen often), using the software
  840. * interrupt routines for this thing allows us to easily mask
  841. * this when we don't want any of the above to happen.
  842. * This allows for easy and efficient race-condition prevention
  843. * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
  844. */
  845. static void kbd_bh(unsigned long dummy)
  846. {
  847. struct list_head *node;
  848. unsigned char leds = getleds();
  849. if (leds != ledstate) {
  850. list_for_each(node, &kbd_handler.h_list) {
  851. struct input_handle *handle = to_handle_h(node);
  852. input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
  853. input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
  854. input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
  855. input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
  856. }
  857. }
  858. ledstate = leds;
  859. }
  860. DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
  861. #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
  862. defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
  863. defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
  864. (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
  865. #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
  866. ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
  867. static const unsigned short x86_keycodes[256] =
  868. { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  869. 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  870. 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  871. 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  872. 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  873. 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
  874. 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
  875. 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
  876. 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
  877. 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
  878. 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
  879. 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
  880. 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
  881. 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
  882. 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
  883. #ifdef CONFIG_MAC_EMUMOUSEBTN
  884. extern int mac_hid_mouse_emulate_buttons(int, int, int);
  885. #endif /* CONFIG_MAC_EMUMOUSEBTN */
  886. #ifdef CONFIG_SPARC
  887. static int sparc_l1_a_state = 0;
  888. extern void sun_do_break(void);
  889. #endif
  890. static int emulate_raw(struct vc_data *vc, unsigned int keycode,
  891. unsigned char up_flag)
  892. {
  893. int code;
  894. switch (keycode) {
  895. case KEY_PAUSE:
  896. put_queue(vc, 0xe1);
  897. put_queue(vc, 0x1d | up_flag);
  898. put_queue(vc, 0x45 | up_flag);
  899. break;
  900. case KEY_HANGEUL:
  901. if (!up_flag)
  902. put_queue(vc, 0xf2);
  903. break;
  904. case KEY_HANJA:
  905. if (!up_flag)
  906. put_queue(vc, 0xf1);
  907. break;
  908. case KEY_SYSRQ:
  909. /*
  910. * Real AT keyboards (that's what we're trying
  911. * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
  912. * pressing PrtSc/SysRq alone, but simply 0x54
  913. * when pressing Alt+PrtSc/SysRq.
  914. */
  915. if (sysrq_alt) {
  916. put_queue(vc, 0x54 | up_flag);
  917. } else {
  918. put_queue(vc, 0xe0);
  919. put_queue(vc, 0x2a | up_flag);
  920. put_queue(vc, 0xe0);
  921. put_queue(vc, 0x37 | up_flag);
  922. }
  923. break;
  924. default:
  925. if (keycode > 255)
  926. return -1;
  927. code = x86_keycodes[keycode];
  928. if (!code)
  929. return -1;
  930. if (code & 0x100)
  931. put_queue(vc, 0xe0);
  932. put_queue(vc, (code & 0x7f) | up_flag);
  933. break;
  934. }
  935. return 0;
  936. }
  937. #else
  938. #define HW_RAW(dev) 0
  939. #warning "Cannot generate rawmode keyboard for your architecture yet."
  940. static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
  941. {
  942. if (keycode > 127)
  943. return -1;
  944. put_queue(vc, keycode | up_flag);
  945. return 0;
  946. }
  947. #endif
  948. static void kbd_rawcode(unsigned char data)
  949. {
  950. struct vc_data *vc = vc_cons[fg_console].d;
  951. kbd = kbd_table + fg_console;
  952. if (kbd->kbdmode == VC_RAW)
  953. put_queue(vc, data);
  954. }
  955. static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
  956. {
  957. struct vc_data *vc = vc_cons[fg_console].d;
  958. unsigned short keysym, *key_map;
  959. unsigned char type, raw_mode;
  960. struct tty_struct *tty;
  961. int shift_final;
  962. tty = vc->vc_tty;
  963. if (tty && (!tty->driver_data)) {
  964. /* No driver data? Strange. Okay we fix it then. */
  965. tty->driver_data = vc;
  966. }
  967. kbd = kbd_table + fg_console;
  968. if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
  969. sysrq_alt = down ? keycode : 0;
  970. #ifdef CONFIG_SPARC
  971. if (keycode == KEY_STOP)
  972. sparc_l1_a_state = down;
  973. #endif
  974. rep = (down == 2);
  975. #ifdef CONFIG_MAC_EMUMOUSEBTN
  976. if (mac_hid_mouse_emulate_buttons(1, keycode, down))
  977. return;
  978. #endif /* CONFIG_MAC_EMUMOUSEBTN */
  979. if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
  980. if (emulate_raw(vc, keycode, !down << 7))
  981. if (keycode < BTN_MISC)
  982. printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
  983. #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
  984. if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
  985. if (!sysrq_down) {
  986. sysrq_down = down;
  987. sysrq_alt_use = sysrq_alt;
  988. }
  989. return;
  990. }
  991. if (sysrq_down && !down && keycode == sysrq_alt_use)
  992. sysrq_down = 0;
  993. if (sysrq_down && down && !rep) {
  994. handle_sysrq(kbd_sysrq_xlate[keycode], tty);
  995. return;
  996. }
  997. #endif
  998. #ifdef CONFIG_SPARC
  999. if (keycode == KEY_A && sparc_l1_a_state) {
  1000. sparc_l1_a_state = 0;
  1001. sun_do_break();
  1002. }
  1003. #endif
  1004. if (kbd->kbdmode == VC_MEDIUMRAW) {
  1005. /*
  1006. * This is extended medium raw mode, with keys above 127
  1007. * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
  1008. * the 'up' flag if needed. 0 is reserved, so this shouldn't
  1009. * interfere with anything else. The two bytes after 0 will
  1010. * always have the up flag set not to interfere with older
  1011. * applications. This allows for 16384 different keycodes,
  1012. * which should be enough.
  1013. */
  1014. if (keycode < 128) {
  1015. put_queue(vc, keycode | (!down << 7));
  1016. } else {
  1017. put_queue(vc, !down << 7);
  1018. put_queue(vc, (keycode >> 7) | 0x80);
  1019. put_queue(vc, keycode | 0x80);
  1020. }
  1021. raw_mode = 1;
  1022. }
  1023. if (down)
  1024. set_bit(keycode, key_down);
  1025. else
  1026. clear_bit(keycode, key_down);
  1027. if (rep &&
  1028. (!vc_kbd_mode(kbd, VC_REPEAT) ||
  1029. (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
  1030. /*
  1031. * Don't repeat a key if the input buffers are not empty and the
  1032. * characters get aren't echoed locally. This makes key repeat
  1033. * usable with slow applications and under heavy loads.
  1034. */
  1035. return;
  1036. }
  1037. shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
  1038. key_map = key_maps[shift_final];
  1039. if (!key_map) {
  1040. compute_shiftstate();
  1041. kbd->slockstate = 0;
  1042. return;
  1043. }
  1044. if (keycode > NR_KEYS)
  1045. if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
  1046. keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
  1047. else
  1048. return;
  1049. else
  1050. keysym = key_map[keycode];
  1051. type = KTYP(keysym);
  1052. if (type < 0xf0) {
  1053. if (down && !raw_mode)
  1054. to_utf8(vc, keysym);
  1055. return;
  1056. }
  1057. type -= 0xf0;
  1058. if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
  1059. return;
  1060. if (type == KT_LETTER) {
  1061. type = KT_LATIN;
  1062. if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
  1063. key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
  1064. if (key_map)
  1065. keysym = key_map[keycode];
  1066. }
  1067. }
  1068. (*k_handler[type])(vc, keysym & 0xff, !down);
  1069. if (type != KT_SLOCK)
  1070. kbd->slockstate = 0;
  1071. }
  1072. static void kbd_event(struct input_handle *handle, unsigned int event_type,
  1073. unsigned int event_code, int value)
  1074. {
  1075. if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
  1076. kbd_rawcode(value);
  1077. if (event_type == EV_KEY)
  1078. kbd_keycode(event_code, value, HW_RAW(handle->dev));
  1079. tasklet_schedule(&keyboard_tasklet);
  1080. do_poke_blanked_console = 1;
  1081. schedule_console_callback();
  1082. }
  1083. /*
  1084. * When a keyboard (or other input device) is found, the kbd_connect
  1085. * function is called. The function then looks at the device, and if it
  1086. * likes it, it can open it and get events from it. In this (kbd_connect)
  1087. * function, we should decide which VT to bind that keyboard to initially.
  1088. */
  1089. static struct input_handle *kbd_connect(struct input_handler *handler,
  1090. struct input_dev *dev,
  1091. const struct input_device_id *id)
  1092. {
  1093. struct input_handle *handle;
  1094. int i;
  1095. for (i = KEY_RESERVED; i < BTN_MISC; i++)
  1096. if (test_bit(i, dev->keybit))
  1097. break;
  1098. if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
  1099. return NULL;
  1100. handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
  1101. if (!handle)
  1102. return NULL;
  1103. handle->dev = dev;
  1104. handle->handler = handler;
  1105. handle->name = "kbd";
  1106. input_open_device(handle);
  1107. return handle;
  1108. }
  1109. static void kbd_disconnect(struct input_handle *handle)
  1110. {
  1111. input_close_device(handle);
  1112. kfree(handle);
  1113. }
  1114. /*
  1115. * Start keyboard handler on the new keyboard by refreshing LED state to
  1116. * match the rest of the system.
  1117. */
  1118. static void kbd_start(struct input_handle *handle)
  1119. {
  1120. unsigned char leds = ledstate;
  1121. tasklet_disable(&keyboard_tasklet);
  1122. if (leds != 0xff) {
  1123. input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
  1124. input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
  1125. input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
  1126. input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
  1127. }
  1128. tasklet_enable(&keyboard_tasklet);
  1129. }
  1130. static const struct input_device_id kbd_ids[] = {
  1131. {
  1132. .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
  1133. .evbit = { BIT(EV_KEY) },
  1134. },
  1135. {
  1136. .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
  1137. .evbit = { BIT(EV_SND) },
  1138. },
  1139. { }, /* Terminating entry */
  1140. };
  1141. MODULE_DEVICE_TABLE(input, kbd_ids);
  1142. static struct input_handler kbd_handler = {
  1143. .event = kbd_event,
  1144. .connect = kbd_connect,
  1145. .disconnect = kbd_disconnect,
  1146. .start = kbd_start,
  1147. .name = "kbd",
  1148. .id_table = kbd_ids,
  1149. };
  1150. int __init kbd_init(void)
  1151. {
  1152. int i;
  1153. int error;
  1154. for (i = 0; i < MAX_NR_CONSOLES; i++) {
  1155. kbd_table[i].ledflagstate = KBD_DEFLEDS;
  1156. kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
  1157. kbd_table[i].ledmode = LED_SHOW_FLAGS;
  1158. kbd_table[i].lockstate = KBD_DEFLOCK;
  1159. kbd_table[i].slockstate = 0;
  1160. kbd_table[i].modeflags = KBD_DEFMODE;
  1161. kbd_table[i].kbdmode = VC_XLATE;
  1162. }
  1163. error = input_register_handler(&kbd_handler);
  1164. if (error)
  1165. return error;
  1166. tasklet_enable(&keyboard_tasklet);
  1167. tasklet_schedule(&keyboard_tasklet);
  1168. return 0;
  1169. }