Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
keyboard.c
Go to the documentation of this file.
1 /*
2  * Written for linux by Johan Myreen as a translation from
3  * the assembly version by Linus (with diacriticals added)
4  *
5  * Some additional features added by Christoph Niemann (ChN), March 1993
6  *
7  * Loadable keymaps by Risto Kankkunen, May 1993
8  *
9  * Diacriticals redone & other small changes, [email protected], June 1993
10  * Added decr/incr_console, dynamic keymaps, Unicode support,
11  * dynamic function/string keys, led setting, Sept 1994
12  * `Sticky' modifier keys, 951006.
13  *
14  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15  *
16  * Modified to provide 'generic' keyboard support by Hamish Macdonald
17  * Merge with the m68k keyboard driver and split-off of the PC low-level
18  * parts by Geert Uytterhoeven, May 1997
19  *
20  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21  * 30-07-98: Dead keys redone, [email protected].
22  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
23  */
24 
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26 
27 #include <linux/consolemap.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/mm.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
42 #include <linux/notifier.h>
43 #include <linux/jiffies.h>
44 #include <linux/uaccess.h>
45 
46 #include <asm/irq_regs.h>
47 
48 extern void ctrl_alt_del(void);
49 
50 /*
51  * Exported functions/variables
52  */
53 
54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
55 
56 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
57 #include <asm/kbdleds.h>
58 #else
59 static inline int kbd_defleds(void)
60 {
61  return 0;
62 }
63 #endif
64 
65 #define KBD_DEFLOCK 0
66 
67 /*
68  * Handler Tables.
69  */
70 
71 #define K_HANDLERS\
72  k_self, k_fn, k_spec, k_pad,\
73  k_dead, k_cons, k_cur, k_shift,\
74  k_meta, k_ascii, k_lock, k_lowercase,\
75  k_slock, k_dead2, k_brl, k_ignore
76 
77 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
78  char up_flag);
80 static k_handler_fn *k_handler[16] = { K_HANDLERS };
81 
82 #define FN_HANDLERS\
83  fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
84  fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
85  fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
86  fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
87  fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
88 
89 typedef void (fn_handler_fn)(struct vc_data *vc);
91 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
92 
93 /*
94  * Variables exported for vt_ioctl.c
95  */
96 
98  .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
99  .pid = NULL,
100  .sig = 0,
101 };
102 
103 
104 /*
105  * Internal Data.
106  */
107 
108 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110 
111 /* maximum values each key_handler can handle */
112 static const int max_vals[] = {
113  255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
114  NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
115  255, NR_LOCK - 1, 255, NR_BRL - 1
116 };
117 
118 static const int NR_TYPES = ARRAY_SIZE(max_vals);
119 
120 static struct input_handler kbd_handler;
121 static DEFINE_SPINLOCK(kbd_event_lock);
122 static DEFINE_SPINLOCK(led_lock);
123 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
124 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
125 static bool dead_key_next;
126 static int npadch = -1; /* -1 or number assembled on pad */
127 static unsigned int diacr;
128 static char rep; /* flag telling character repeat */
129 
130 static int shift_state = 0;
131 
132 static unsigned char ledstate = 0xff; /* undefined */
133 static unsigned char ledioctl;
134 
135 static struct ledptr {
136  unsigned int *addr;
137  unsigned int mask;
138  unsigned char valid:1;
139 } ledptrs[3];
140 
141 /*
142  * Notifier list for console keyboard events
143  */
144 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
145 
147 {
148  return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
149 }
151 
153 {
154  return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
155 }
157 
158 /*
159  * Translation of scancodes to keycodes. We set them on only the first
160  * keyboard in the list that accepts the scancode and keycode.
161  * Explanation for not choosing the first attached keyboard anymore:
162  * USB keyboards for example have two event devices: one for all "normal"
163  * keys and one for extra function keys (like "volume up", "make coffee",
164  * etc.). So this means that scancodes for the extra function keys won't
165  * be valid for the first event device, but will be for the second.
166  */
167 
170  int error;
171 };
172 
173 static int getkeycode_helper(struct input_handle *handle, void *data)
174 {
175  struct getset_keycode_data *d = data;
176 
177  d->error = input_get_keycode(handle->dev, &d->ke);
178 
179  return d->error == 0; /* stop as soon as we successfully get one */
180 }
181 
182 static int getkeycode(unsigned int scancode)
183 {
184  struct getset_keycode_data d = {
185  .ke = {
186  .flags = 0,
187  .len = sizeof(scancode),
188  .keycode = 0,
189  },
190  .error = -ENODEV,
191  };
192 
193  memcpy(d.ke.scancode, &scancode, sizeof(scancode));
194 
195  input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
196 
197  return d.error ?: d.ke.keycode;
198 }
199 
200 static int setkeycode_helper(struct input_handle *handle, void *data)
201 {
202  struct getset_keycode_data *d = data;
203 
204  d->error = input_set_keycode(handle->dev, &d->ke);
205 
206  return d->error == 0; /* stop as soon as we successfully set one */
207 }
208 
209 static int setkeycode(unsigned int scancode, unsigned int keycode)
210 {
211  struct getset_keycode_data d = {
212  .ke = {
213  .flags = 0,
214  .len = sizeof(scancode),
215  .keycode = keycode,
216  },
217  .error = -ENODEV,
218  };
219 
220  memcpy(d.ke.scancode, &scancode, sizeof(scancode));
221 
222  input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
223 
224  return d.error;
225 }
226 
227 /*
228  * Making beeps and bells. Note that we prefer beeps to bells, but when
229  * shutting the sound off we do both.
230  */
231 
232 static int kd_sound_helper(struct input_handle *handle, void *data)
233 {
234  unsigned int *hz = data;
235  struct input_dev *dev = handle->dev;
236 
237  if (test_bit(EV_SND, dev->evbit)) {
238  if (test_bit(SND_TONE, dev->sndbit)) {
239  input_inject_event(handle, EV_SND, SND_TONE, *hz);
240  if (*hz)
241  return 0;
242  }
243  if (test_bit(SND_BELL, dev->sndbit))
244  input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
245  }
246 
247  return 0;
248 }
249 
250 static void kd_nosound(unsigned long ignored)
251 {
252  static unsigned int zero;
253 
254  input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
255 }
256 
257 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
258 
259 void kd_mksound(unsigned int hz, unsigned int ticks)
260 {
261  del_timer_sync(&kd_mksound_timer);
262 
263  input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
264 
265  if (hz && ticks)
266  mod_timer(&kd_mksound_timer, jiffies + ticks);
267 }
269 
270 /*
271  * Setting the keyboard rate.
272  */
273 
274 static int kbd_rate_helper(struct input_handle *handle, void *data)
275 {
276  struct input_dev *dev = handle->dev;
277  struct kbd_repeat *rep = data;
278 
279  if (test_bit(EV_REP, dev->evbit)) {
280 
281  if (rep[0].delay > 0)
282  input_inject_event(handle,
283  EV_REP, REP_DELAY, rep[0].delay);
284  if (rep[0].period > 0)
285  input_inject_event(handle,
286  EV_REP, REP_PERIOD, rep[0].period);
287 
288  rep[1].delay = dev->rep[REP_DELAY];
289  rep[1].period = dev->rep[REP_PERIOD];
290  }
291 
292  return 0;
293 }
294 
295 int kbd_rate(struct kbd_repeat *rep)
296 {
297  struct kbd_repeat data[2] = { *rep };
298 
299  input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
300  *rep = data[1]; /* Copy currently used settings */
301 
302  return 0;
303 }
304 
305 /*
306  * Helper Functions.
307  */
308 static void put_queue(struct vc_data *vc, int ch)
309 {
310  struct tty_struct *tty = vc->port.tty;
311 
312  if (tty) {
313  tty_insert_flip_char(tty, ch, 0);
314  tty_schedule_flip(tty);
315  }
316 }
317 
318 static void puts_queue(struct vc_data *vc, char *cp)
319 {
320  struct tty_struct *tty = vc->port.tty;
321 
322  if (!tty)
323  return;
324 
325  while (*cp) {
326  tty_insert_flip_char(tty, *cp, 0);
327  cp++;
328  }
329  tty_schedule_flip(tty);
330 }
331 
332 static void applkey(struct vc_data *vc, int key, char mode)
333 {
334  static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
335 
336  buf[1] = (mode ? 'O' : '[');
337  buf[2] = key;
338  puts_queue(vc, buf);
339 }
340 
341 /*
342  * Many other routines do put_queue, but I think either
343  * they produce ASCII, or they produce some user-assigned
344  * string, and in both cases we might assume that it is
345  * in utf-8 already.
346  */
347 static void to_utf8(struct vc_data *vc, uint c)
348 {
349  if (c < 0x80)
350  /* 0******* */
351  put_queue(vc, c);
352  else if (c < 0x800) {
353  /* 110***** 10****** */
354  put_queue(vc, 0xc0 | (c >> 6));
355  put_queue(vc, 0x80 | (c & 0x3f));
356  } else if (c < 0x10000) {
357  if (c >= 0xD800 && c < 0xE000)
358  return;
359  if (c == 0xFFFF)
360  return;
361  /* 1110**** 10****** 10****** */
362  put_queue(vc, 0xe0 | (c >> 12));
363  put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
364  put_queue(vc, 0x80 | (c & 0x3f));
365  } else if (c < 0x110000) {
366  /* 11110*** 10****** 10****** 10****** */
367  put_queue(vc, 0xf0 | (c >> 18));
368  put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
369  put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
370  put_queue(vc, 0x80 | (c & 0x3f));
371  }
372 }
373 
374 /*
375  * Called after returning from RAW mode or when changing consoles - recompute
376  * shift_down[] and shift_state from key_down[] maybe called when keymap is
377  * undefined, so that shiftkey release is seen. The caller must hold the
378  * kbd_event_lock.
379  */
380 
381 static void do_compute_shiftstate(void)
382 {
383  unsigned int i, j, k, sym, val;
384 
385  shift_state = 0;
386  memset(shift_down, 0, sizeof(shift_down));
387 
388  for (i = 0; i < ARRAY_SIZE(key_down); i++) {
389 
390  if (!key_down[i])
391  continue;
392 
393  k = i * BITS_PER_LONG;
394 
395  for (j = 0; j < BITS_PER_LONG; j++, k++) {
396 
397  if (!test_bit(k, key_down))
398  continue;
399 
400  sym = U(key_maps[0][k]);
401  if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
402  continue;
403 
404  val = KVAL(sym);
405  if (val == KVAL(K_CAPSSHIFT))
406  val = KVAL(K_SHIFT);
407 
408  shift_down[val]++;
409  shift_state |= (1 << val);
410  }
411  }
412 }
413 
414 /* We still have to export this method to vt.c */
416 {
417  unsigned long flags;
418  spin_lock_irqsave(&kbd_event_lock, flags);
419  do_compute_shiftstate();
420  spin_unlock_irqrestore(&kbd_event_lock, flags);
421 }
422 
423 /*
424  * We have a combining character DIACR here, followed by the character CH.
425  * If the combination occurs in the table, return the corresponding value.
426  * Otherwise, if CH is a space or equals DIACR, return DIACR.
427  * Otherwise, conclude that DIACR was not combining after all,
428  * queue it and return CH.
429  */
430 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
431 {
432  unsigned int d = diacr;
433  unsigned int i;
434 
435  diacr = 0;
436 
437  if ((d & ~0xff) == BRL_UC_ROW) {
438  if ((ch & ~0xff) == BRL_UC_ROW)
439  return d | ch;
440  } else {
441  for (i = 0; i < accent_table_size; i++)
442  if (accent_table[i].diacr == d && accent_table[i].base == ch)
443  return accent_table[i].result;
444  }
445 
446  if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
447  return d;
448 
449  if (kbd->kbdmode == VC_UNICODE)
450  to_utf8(vc, d);
451  else {
452  int c = conv_uni_to_8bit(d);
453  if (c != -1)
454  put_queue(vc, c);
455  }
456 
457  return ch;
458 }
459 
460 /*
461  * Special function handlers
462  */
463 static void fn_enter(struct vc_data *vc)
464 {
465  if (diacr) {
466  if (kbd->kbdmode == VC_UNICODE)
467  to_utf8(vc, diacr);
468  else {
469  int c = conv_uni_to_8bit(diacr);
470  if (c != -1)
471  put_queue(vc, c);
472  }
473  diacr = 0;
474  }
475 
476  put_queue(vc, 13);
477  if (vc_kbd_mode(kbd, VC_CRLF))
478  put_queue(vc, 10);
479 }
480 
481 static void fn_caps_toggle(struct vc_data *vc)
482 {
483  if (rep)
484  return;
485 
486  chg_vc_kbd_led(kbd, VC_CAPSLOCK);
487 }
488 
489 static void fn_caps_on(struct vc_data *vc)
490 {
491  if (rep)
492  return;
493 
494  set_vc_kbd_led(kbd, VC_CAPSLOCK);
495 }
496 
497 static void fn_show_ptregs(struct vc_data *vc)
498 {
499  struct pt_regs *regs = get_irq_regs();
500 
501  if (regs)
502  show_regs(regs);
503 }
504 
505 static void fn_hold(struct vc_data *vc)
506 {
507  struct tty_struct *tty = vc->port.tty;
508 
509  if (rep || !tty)
510  return;
511 
512  /*
513  * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
514  * these routines are also activated by ^S/^Q.
515  * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
516  */
517  if (tty->stopped)
518  start_tty(tty);
519  else
520  stop_tty(tty);
521 }
522 
523 static void fn_num(struct vc_data *vc)
524 {
525  if (vc_kbd_mode(kbd, VC_APPLIC))
526  applkey(vc, 'P', 1);
527  else
528  fn_bare_num(vc);
529 }
530 
531 /*
532  * Bind this to Shift-NumLock if you work in application keypad mode
533  * but want to be able to change the NumLock flag.
534  * Bind this to NumLock if you prefer that the NumLock key always
535  * changes the NumLock flag.
536  */
537 static void fn_bare_num(struct vc_data *vc)
538 {
539  if (!rep)
540  chg_vc_kbd_led(kbd, VC_NUMLOCK);
541 }
542 
543 static void fn_lastcons(struct vc_data *vc)
544 {
545  /* switch to the last used console, ChN */
547 }
548 
549 static void fn_dec_console(struct vc_data *vc)
550 {
551  int i, cur = fg_console;
552 
553  /* Currently switching? Queue this next switch relative to that. */
554  if (want_console != -1)
555  cur = want_console;
556 
557  for (i = cur - 1; i != cur; i--) {
558  if (i == -1)
559  i = MAX_NR_CONSOLES - 1;
560  if (vc_cons_allocated(i))
561  break;
562  }
563  set_console(i);
564 }
565 
566 static void fn_inc_console(struct vc_data *vc)
567 {
568  int i, cur = fg_console;
569 
570  /* Currently switching? Queue this next switch relative to that. */
571  if (want_console != -1)
572  cur = want_console;
573 
574  for (i = cur+1; i != cur; i++) {
575  if (i == MAX_NR_CONSOLES)
576  i = 0;
577  if (vc_cons_allocated(i))
578  break;
579  }
580  set_console(i);
581 }
582 
583 static void fn_send_intr(struct vc_data *vc)
584 {
585  struct tty_struct *tty = vc->port.tty;
586 
587  if (!tty)
588  return;
589  tty_insert_flip_char(tty, 0, TTY_BREAK);
590  tty_schedule_flip(tty);
591 }
592 
593 static void fn_scroll_forw(struct vc_data *vc)
594 {
595  scrollfront(vc, 0);
596 }
597 
598 static void fn_scroll_back(struct vc_data *vc)
599 {
600  scrollback(vc, 0);
601 }
602 
603 static void fn_show_mem(struct vc_data *vc)
604 {
605  show_mem(0);
606 }
607 
608 static void fn_show_state(struct vc_data *vc)
609 {
610  show_state();
611 }
612 
613 static void fn_boot_it(struct vc_data *vc)
614 {
615  ctrl_alt_del();
616 }
617 
618 static void fn_compose(struct vc_data *vc)
619 {
620  dead_key_next = true;
621 }
622 
623 static void fn_spawn_con(struct vc_data *vc)
624 {
625  spin_lock(&vt_spawn_con.lock);
626  if (vt_spawn_con.pid)
627  if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
628  put_pid(vt_spawn_con.pid);
629  vt_spawn_con.pid = NULL;
630  }
631  spin_unlock(&vt_spawn_con.lock);
632 }
633 
634 static void fn_SAK(struct vc_data *vc)
635 {
636  struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
637  schedule_work(SAK_work);
638 }
639 
640 static void fn_null(struct vc_data *vc)
641 {
642  do_compute_shiftstate();
643 }
644 
645 /*
646  * Special key handlers
647  */
648 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
649 {
650 }
651 
652 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
653 {
654  if (up_flag)
655  return;
656  if (value >= ARRAY_SIZE(fn_handler))
657  return;
658  if ((kbd->kbdmode == VC_RAW ||
659  kbd->kbdmode == VC_MEDIUMRAW ||
660  kbd->kbdmode == VC_OFF) &&
661  value != KVAL(K_SAK))
662  return; /* SAK is allowed even in raw mode */
663  fn_handler[value](vc);
664 }
665 
666 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
667 {
668  pr_err("k_lowercase was called - impossible\n");
669 }
670 
671 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
672 {
673  if (up_flag)
674  return; /* no action, if this is a key release */
675 
676  if (diacr)
677  value = handle_diacr(vc, value);
678 
679  if (dead_key_next) {
680  dead_key_next = false;
681  diacr = value;
682  return;
683  }
684  if (kbd->kbdmode == VC_UNICODE)
685  to_utf8(vc, value);
686  else {
687  int c = conv_uni_to_8bit(value);
688  if (c != -1)
689  put_queue(vc, c);
690  }
691 }
692 
693 /*
694  * Handle dead key. Note that we now may have several
695  * dead keys modifying the same character. Very useful
696  * for Vietnamese.
697  */
698 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
699 {
700  if (up_flag)
701  return;
702 
703  diacr = (diacr ? handle_diacr(vc, value) : value);
704 }
705 
706 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
707 {
708  k_unicode(vc, conv_8bit_to_uni(value), up_flag);
709 }
710 
711 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
712 {
713  k_deadunicode(vc, value, up_flag);
714 }
715 
716 /*
717  * Obsolete - for backwards compatibility only
718  */
719 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
720 {
721  static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
722 
723  k_deadunicode(vc, ret_diacr[value], up_flag);
724 }
725 
726 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
727 {
728  if (up_flag)
729  return;
730 
731  set_console(value);
732 }
733 
734 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
735 {
736  if (up_flag)
737  return;
738 
739  if ((unsigned)value < ARRAY_SIZE(func_table)) {
740  if (func_table[value])
741  puts_queue(vc, func_table[value]);
742  } else
743  pr_err("k_fn called with value=%d\n", value);
744 }
745 
746 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
747 {
748  static const char cur_chars[] = "BDCA";
749 
750  if (up_flag)
751  return;
752 
753  applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
754 }
755 
756 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
757 {
758  static const char pad_chars[] = "0123456789+-*/\015,.?()#";
759  static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
760 
761  if (up_flag)
762  return; /* no action, if this is a key release */
763 
764  /* kludge... shift forces cursor/number keys */
765  if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
766  applkey(vc, app_map[value], 1);
767  return;
768  }
769 
770  if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
771 
772  switch (value) {
773  case KVAL(K_PCOMMA):
774  case KVAL(K_PDOT):
775  k_fn(vc, KVAL(K_REMOVE), 0);
776  return;
777  case KVAL(K_P0):
778  k_fn(vc, KVAL(K_INSERT), 0);
779  return;
780  case KVAL(K_P1):
781  k_fn(vc, KVAL(K_SELECT), 0);
782  return;
783  case KVAL(K_P2):
784  k_cur(vc, KVAL(K_DOWN), 0);
785  return;
786  case KVAL(K_P3):
787  k_fn(vc, KVAL(K_PGDN), 0);
788  return;
789  case KVAL(K_P4):
790  k_cur(vc, KVAL(K_LEFT), 0);
791  return;
792  case KVAL(K_P6):
793  k_cur(vc, KVAL(K_RIGHT), 0);
794  return;
795  case KVAL(K_P7):
796  k_fn(vc, KVAL(K_FIND), 0);
797  return;
798  case KVAL(K_P8):
799  k_cur(vc, KVAL(K_UP), 0);
800  return;
801  case KVAL(K_P9):
802  k_fn(vc, KVAL(K_PGUP), 0);
803  return;
804  case KVAL(K_P5):
805  applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
806  return;
807  }
808  }
809 
810  put_queue(vc, pad_chars[value]);
811  if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
812  put_queue(vc, 10);
813 }
814 
815 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
816 {
817  int old_state = shift_state;
818 
819  if (rep)
820  return;
821  /*
822  * Mimic typewriter:
823  * a CapsShift key acts like Shift but undoes CapsLock
824  */
825  if (value == KVAL(K_CAPSSHIFT)) {
826  value = KVAL(K_SHIFT);
827  if (!up_flag)
828  clr_vc_kbd_led(kbd, VC_CAPSLOCK);
829  }
830 
831  if (up_flag) {
832  /*
833  * handle the case that two shift or control
834  * keys are depressed simultaneously
835  */
836  if (shift_down[value])
837  shift_down[value]--;
838  } else
839  shift_down[value]++;
840 
841  if (shift_down[value])
842  shift_state |= (1 << value);
843  else
844  shift_state &= ~(1 << value);
845 
846  /* kludge */
847  if (up_flag && shift_state != old_state && npadch != -1) {
848  if (kbd->kbdmode == VC_UNICODE)
849  to_utf8(vc, npadch);
850  else
851  put_queue(vc, npadch & 0xff);
852  npadch = -1;
853  }
854 }
855 
856 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
857 {
858  if (up_flag)
859  return;
860 
861  if (vc_kbd_mode(kbd, VC_META)) {
862  put_queue(vc, '\033');
863  put_queue(vc, value);
864  } else
865  put_queue(vc, value | 0x80);
866 }
867 
868 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
869 {
870  int base;
871 
872  if (up_flag)
873  return;
874 
875  if (value < 10) {
876  /* decimal input of code, while Alt depressed */
877  base = 10;
878  } else {
879  /* hexadecimal input of code, while AltGr depressed */
880  value -= 10;
881  base = 16;
882  }
883 
884  if (npadch == -1)
885  npadch = value;
886  else
887  npadch = npadch * base + value;
888 }
889 
890 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
891 {
892  if (up_flag || rep)
893  return;
894 
895  chg_vc_kbd_lock(kbd, value);
896 }
897 
898 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
899 {
900  k_shift(vc, value, up_flag);
901  if (up_flag || rep)
902  return;
903 
904  chg_vc_kbd_slock(kbd, value);
905  /* try to make Alt, oops, AltGr and such work */
906  if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
907  kbd->slockstate = 0;
908  chg_vc_kbd_slock(kbd, value);
909  }
910 }
911 
912 /* by default, 300ms interval for combination release */
913 static unsigned brl_timeout = 300;
914 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
915 module_param(brl_timeout, uint, 0644);
916 
917 static unsigned brl_nbchords = 1;
918 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
919 module_param(brl_nbchords, uint, 0644);
920 
921 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
922 {
923  static unsigned long chords;
924  static unsigned committed;
925 
926  if (!brl_nbchords)
927  k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
928  else {
929  committed |= pattern;
930  chords++;
931  if (chords == brl_nbchords) {
932  k_unicode(vc, BRL_UC_ROW | committed, up_flag);
933  chords = 0;
934  committed = 0;
935  }
936  }
937 }
938 
939 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
940 {
941  static unsigned pressed, committing;
942  static unsigned long releasestart;
943 
944  if (kbd->kbdmode != VC_UNICODE) {
945  if (!up_flag)
946  pr_warning("keyboard mode must be unicode for braille patterns\n");
947  return;
948  }
949 
950  if (!value) {
951  k_unicode(vc, BRL_UC_ROW, up_flag);
952  return;
953  }
954 
955  if (value > 8)
956  return;
957 
958  if (!up_flag) {
959  pressed |= 1 << (value - 1);
960  if (!brl_timeout)
961  committing = pressed;
962  } else if (brl_timeout) {
963  if (!committing ||
964  time_after(jiffies,
965  releasestart + msecs_to_jiffies(brl_timeout))) {
966  committing = pressed;
967  releasestart = jiffies;
968  }
969  pressed &= ~(1 << (value - 1));
970  if (!pressed && committing) {
971  k_brlcommit(vc, committing, 0);
972  committing = 0;
973  }
974  } else {
975  if (committing) {
976  k_brlcommit(vc, committing, 0);
977  committing = 0;
978  }
979  pressed &= ~(1 << (value - 1));
980  }
981 }
982 
983 /*
984  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
985  * or (ii) whatever pattern of lights people want to show using KDSETLED,
986  * or (iii) specified bits of specified words in kernel memory.
987  */
988 static unsigned char getledstate(void)
989 {
990  return ledstate;
991 }
992 
993 void setledstate(struct kbd_struct *kbd, unsigned int led)
994 {
995  unsigned long flags;
996  spin_lock_irqsave(&led_lock, flags);
997  if (!(led & ~7)) {
998  ledioctl = led;
999  kbd->ledmode = LED_SHOW_IOCTL;
1000  } else
1001  kbd->ledmode = LED_SHOW_FLAGS;
1002 
1003  set_leds();
1004  spin_unlock_irqrestore(&led_lock, flags);
1005 }
1006 
1007 static inline unsigned char getleds(void)
1008 {
1009  struct kbd_struct *kbd = kbd_table + fg_console;
1010  unsigned char leds;
1011  int i;
1012 
1013  if (kbd->ledmode == LED_SHOW_IOCTL)
1014  return ledioctl;
1015 
1016  leds = kbd->ledflagstate;
1017 
1018  if (kbd->ledmode == LED_SHOW_MEM) {
1019  for (i = 0; i < 3; i++)
1020  if (ledptrs[i].valid) {
1021  if (*ledptrs[i].addr & ledptrs[i].mask)
1022  leds |= (1 << i);
1023  else
1024  leds &= ~(1 << i);
1025  }
1026  }
1027  return leds;
1028 }
1029 
1030 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1031 {
1032  unsigned char leds = *(unsigned char *)data;
1033 
1034  if (test_bit(EV_LED, handle->dev->evbit)) {
1035  input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1036  input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1037  input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1038  input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1039  }
1040 
1041  return 0;
1042 }
1043 
1051 int vt_get_leds(int console, int flag)
1052 {
1053  struct kbd_struct * kbd = kbd_table + console;
1054  int ret;
1055  unsigned long flags;
1056 
1057  spin_lock_irqsave(&led_lock, flags);
1058  ret = vc_kbd_led(kbd, flag);
1059  spin_unlock_irqrestore(&led_lock, flags);
1060 
1061  return ret;
1062 }
1064 
1073 void vt_set_led_state(int console, int leds)
1074 {
1075  struct kbd_struct * kbd = kbd_table + console;
1076  setledstate(kbd, leds);
1077 }
1078 
1093 {
1094  struct kbd_struct * kbd = kbd_table + console;
1095  unsigned long flags;
1096  spin_lock_irqsave(&led_lock, flags);
1097  clr_vc_kbd_led(kbd, VC_SCROLLOCK);
1098  set_leds();
1099  spin_unlock_irqrestore(&led_lock, flags);
1100 }
1101 
1110 {
1111  struct kbd_struct * kbd = kbd_table + console;
1112  unsigned long flags;
1113  spin_lock_irqsave(&led_lock, flags);
1114  set_vc_kbd_led(kbd, VC_SCROLLOCK);
1115  set_leds();
1116  spin_unlock_irqrestore(&led_lock, flags);
1117 }
1118 
1119 /*
1120  * This is the tasklet that updates LED state on all keyboards
1121  * attached to the box. The reason we use tasklet is that we
1122  * need to handle the scenario when keyboard handler is not
1123  * registered yet but we already getting updates from the VT to
1124  * update led state.
1125  */
1126 static void kbd_bh(unsigned long dummy)
1127 {
1128  unsigned char leds;
1129  unsigned long flags;
1130 
1131  spin_lock_irqsave(&led_lock, flags);
1132  leds = getleds();
1133  spin_unlock_irqrestore(&led_lock, flags);
1134 
1135  if (leds != ledstate) {
1136  input_handler_for_each_handle(&kbd_handler, &leds,
1137  kbd_update_leds_helper);
1138  ledstate = leds;
1139  }
1140 }
1141 
1142 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1143 
1144 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1145  defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1146  defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1147  (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1148  defined(CONFIG_AVR32)
1149 
1150 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1151  ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1152 
1153 static const unsigned short x86_keycodes[256] =
1154  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1155  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1156  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1157  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1158  64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1159  80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1160  284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1161  367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1162  360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1163  103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1164  291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1165  264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1166  377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1167  308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1168  332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1169 
1170 #ifdef CONFIG_SPARC
1171 static int sparc_l1_a_state;
1172 extern void sun_do_break(void);
1173 #endif
1174 
1175 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1176  unsigned char up_flag)
1177 {
1178  int code;
1179 
1180  switch (keycode) {
1181 
1182  case KEY_PAUSE:
1183  put_queue(vc, 0xe1);
1184  put_queue(vc, 0x1d | up_flag);
1185  put_queue(vc, 0x45 | up_flag);
1186  break;
1187 
1188  case KEY_HANGEUL:
1189  if (!up_flag)
1190  put_queue(vc, 0xf2);
1191  break;
1192 
1193  case KEY_HANJA:
1194  if (!up_flag)
1195  put_queue(vc, 0xf1);
1196  break;
1197 
1198  case KEY_SYSRQ:
1199  /*
1200  * Real AT keyboards (that's what we're trying
1201  * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1202  * pressing PrtSc/SysRq alone, but simply 0x54
1203  * when pressing Alt+PrtSc/SysRq.
1204  */
1205  if (test_bit(KEY_LEFTALT, key_down) ||
1206  test_bit(KEY_RIGHTALT, key_down)) {
1207  put_queue(vc, 0x54 | up_flag);
1208  } else {
1209  put_queue(vc, 0xe0);
1210  put_queue(vc, 0x2a | up_flag);
1211  put_queue(vc, 0xe0);
1212  put_queue(vc, 0x37 | up_flag);
1213  }
1214  break;
1215 
1216  default:
1217  if (keycode > 255)
1218  return -1;
1219 
1220  code = x86_keycodes[keycode];
1221  if (!code)
1222  return -1;
1223 
1224  if (code & 0x100)
1225  put_queue(vc, 0xe0);
1226  put_queue(vc, (code & 0x7f) | up_flag);
1227 
1228  break;
1229  }
1230 
1231  return 0;
1232 }
1233 
1234 #else
1235 
1236 #define HW_RAW(dev) 0
1237 
1238 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1239 {
1240  if (keycode > 127)
1241  return -1;
1242 
1243  put_queue(vc, keycode | up_flag);
1244  return 0;
1245 }
1246 #endif
1247 
1248 static void kbd_rawcode(unsigned char data)
1249 {
1250  struct vc_data *vc = vc_cons[fg_console].d;
1251 
1252  kbd = kbd_table + vc->vc_num;
1253  if (kbd->kbdmode == VC_RAW)
1254  put_queue(vc, data);
1255 }
1256 
1257 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1258 {
1259  struct vc_data *vc = vc_cons[fg_console].d;
1260  unsigned short keysym, *key_map;
1261  unsigned char type;
1262  bool raw_mode;
1263  struct tty_struct *tty;
1264  int shift_final;
1265  struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1266  int rc;
1267 
1268  tty = vc->port.tty;
1269 
1270  if (tty && (!tty->driver_data)) {
1271  /* No driver data? Strange. Okay we fix it then. */
1272  tty->driver_data = vc;
1273  }
1274 
1275  kbd = kbd_table + vc->vc_num;
1276 
1277 #ifdef CONFIG_SPARC
1278  if (keycode == KEY_STOP)
1279  sparc_l1_a_state = down;
1280 #endif
1281 
1282  rep = (down == 2);
1283 
1284  raw_mode = (kbd->kbdmode == VC_RAW);
1285  if (raw_mode && !hw_raw)
1286  if (emulate_raw(vc, keycode, !down << 7))
1287  if (keycode < BTN_MISC && printk_ratelimit())
1288  pr_warning("can't emulate rawmode for keycode %d\n",
1289  keycode);
1290 
1291 #ifdef CONFIG_SPARC
1292  if (keycode == KEY_A && sparc_l1_a_state) {
1293  sparc_l1_a_state = false;
1294  sun_do_break();
1295  }
1296 #endif
1297 
1298  if (kbd->kbdmode == VC_MEDIUMRAW) {
1299  /*
1300  * This is extended medium raw mode, with keys above 127
1301  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1302  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1303  * interfere with anything else. The two bytes after 0 will
1304  * always have the up flag set not to interfere with older
1305  * applications. This allows for 16384 different keycodes,
1306  * which should be enough.
1307  */
1308  if (keycode < 128) {
1309  put_queue(vc, keycode | (!down << 7));
1310  } else {
1311  put_queue(vc, !down << 7);
1312  put_queue(vc, (keycode >> 7) | 0x80);
1313  put_queue(vc, keycode | 0x80);
1314  }
1315  raw_mode = true;
1316  }
1317 
1318  if (down)
1319  set_bit(keycode, key_down);
1320  else
1321  clear_bit(keycode, key_down);
1322 
1323  if (rep &&
1324  (!vc_kbd_mode(kbd, VC_REPEAT) ||
1325  (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1326  /*
1327  * Don't repeat a key if the input buffers are not empty and the
1328  * characters get aren't echoed locally. This makes key repeat
1329  * usable with slow applications and under heavy loads.
1330  */
1331  return;
1332  }
1333 
1334  param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1335  param.ledstate = kbd->ledflagstate;
1336  key_map = key_maps[shift_final];
1337 
1338  rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1339  KBD_KEYCODE, &param);
1340  if (rc == NOTIFY_STOP || !key_map) {
1341  atomic_notifier_call_chain(&keyboard_notifier_list,
1342  KBD_UNBOUND_KEYCODE, &param);
1343  do_compute_shiftstate();
1344  kbd->slockstate = 0;
1345  return;
1346  }
1347 
1348  if (keycode < NR_KEYS)
1349  keysym = key_map[keycode];
1350  else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1351  keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1352  else
1353  return;
1354 
1355  type = KTYP(keysym);
1356 
1357  if (type < 0xf0) {
1358  param.value = keysym;
1359  rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1360  KBD_UNICODE, &param);
1361  if (rc != NOTIFY_STOP)
1362  if (down && !raw_mode)
1363  to_utf8(vc, keysym);
1364  return;
1365  }
1366 
1367  type -= 0xf0;
1368 
1369  if (type == KT_LETTER) {
1370  type = KT_LATIN;
1371  if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1372  key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1373  if (key_map)
1374  keysym = key_map[keycode];
1375  }
1376  }
1377 
1378  param.value = keysym;
1379  rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1380  KBD_KEYSYM, &param);
1381  if (rc == NOTIFY_STOP)
1382  return;
1383 
1384  if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1385  return;
1386 
1387  (*k_handler[type])(vc, keysym & 0xff, !down);
1388 
1389  param.ledstate = kbd->ledflagstate;
1390  atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1391 
1392  if (type != KT_SLOCK)
1393  kbd->slockstate = 0;
1394 }
1395 
1396 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1397  unsigned int event_code, int value)
1398 {
1399  /* We are called with interrupts disabled, just take the lock */
1400  spin_lock(&kbd_event_lock);
1401 
1402  if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1403  kbd_rawcode(value);
1404  if (event_type == EV_KEY)
1405  kbd_keycode(event_code, value, HW_RAW(handle->dev));
1406 
1407  spin_unlock(&kbd_event_lock);
1408 
1409  tasklet_schedule(&keyboard_tasklet);
1412 }
1413 
1414 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1415 {
1416  int i;
1417 
1418  if (test_bit(EV_SND, dev->evbit))
1419  return true;
1420 
1421  if (test_bit(EV_KEY, dev->evbit)) {
1422  for (i = KEY_RESERVED; i < BTN_MISC; i++)
1423  if (test_bit(i, dev->keybit))
1424  return true;
1425  for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1426  if (test_bit(i, dev->keybit))
1427  return true;
1428  }
1429 
1430  return false;
1431 }
1432 
1433 /*
1434  * When a keyboard (or other input device) is found, the kbd_connect
1435  * function is called. The function then looks at the device, and if it
1436  * likes it, it can open it and get events from it. In this (kbd_connect)
1437  * function, we should decide which VT to bind that keyboard to initially.
1438  */
1439 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1440  const struct input_device_id *id)
1441 {
1442  struct input_handle *handle;
1443  int error;
1444 
1445  handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1446  if (!handle)
1447  return -ENOMEM;
1448 
1449  handle->dev = dev;
1450  handle->handler = handler;
1451  handle->name = "kbd";
1452 
1453  error = input_register_handle(handle);
1454  if (error)
1455  goto err_free_handle;
1456 
1457  error = input_open_device(handle);
1458  if (error)
1459  goto err_unregister_handle;
1460 
1461  return 0;
1462 
1463  err_unregister_handle:
1464  input_unregister_handle(handle);
1465  err_free_handle:
1466  kfree(handle);
1467  return error;
1468 }
1469 
1470 static void kbd_disconnect(struct input_handle *handle)
1471 {
1472  input_close_device(handle);
1473  input_unregister_handle(handle);
1474  kfree(handle);
1475 }
1476 
1477 /*
1478  * Start keyboard handler on the new keyboard by refreshing LED state to
1479  * match the rest of the system.
1480  */
1481 static void kbd_start(struct input_handle *handle)
1482 {
1483  tasklet_disable(&keyboard_tasklet);
1484 
1485  if (ledstate != 0xff)
1486  kbd_update_leds_helper(handle, &ledstate);
1487 
1488  tasklet_enable(&keyboard_tasklet);
1489 }
1490 
1491 static const struct input_device_id kbd_ids[] = {
1492  {
1493  .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1494  .evbit = { BIT_MASK(EV_KEY) },
1495  },
1496 
1497  {
1498  .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1499  .evbit = { BIT_MASK(EV_SND) },
1500  },
1501 
1502  { }, /* Terminating entry */
1503 };
1504 
1505 MODULE_DEVICE_TABLE(input, kbd_ids);
1506 
1507 static struct input_handler kbd_handler = {
1508  .event = kbd_event,
1509  .match = kbd_match,
1510  .connect = kbd_connect,
1511  .disconnect = kbd_disconnect,
1512  .start = kbd_start,
1513  .name = "kbd",
1514  .id_table = kbd_ids,
1515 };
1516 
1517 int __init kbd_init(void)
1518 {
1519  int i;
1520  int error;
1521 
1522  for (i = 0; i < MAX_NR_CONSOLES; i++) {
1523  kbd_table[i].ledflagstate = kbd_defleds();
1524  kbd_table[i].default_ledflagstate = kbd_defleds();
1525  kbd_table[i].ledmode = LED_SHOW_FLAGS;
1526  kbd_table[i].lockstate = KBD_DEFLOCK;
1527  kbd_table[i].slockstate = 0;
1528  kbd_table[i].modeflags = KBD_DEFMODE;
1529  kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1530  }
1531 
1532  error = input_register_handler(&kbd_handler);
1533  if (error)
1534  return error;
1535 
1536  tasklet_enable(&keyboard_tasklet);
1537  tasklet_schedule(&keyboard_tasklet);
1538 
1539  return 0;
1540 }
1541 
1542 /* Ioctl support code */
1543 
1553 int vt_do_diacrit(unsigned int cmd, void __user *up, int perm)
1554 {
1555  struct kbdiacrs __user *a = up;
1556  unsigned long flags;
1557  int asize;
1558  int ret = 0;
1559 
1560  switch (cmd) {
1561  case KDGKBDIACR:
1562  {
1563  struct kbdiacr *diacr;
1564  int i;
1565 
1566  diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1567  GFP_KERNEL);
1568  if (diacr == NULL)
1569  return -ENOMEM;
1570 
1571  /* Lock the diacriticals table, make a copy and then
1572  copy it after we unlock */
1573  spin_lock_irqsave(&kbd_event_lock, flags);
1574 
1575  asize = accent_table_size;
1576  for (i = 0; i < asize; i++) {
1577  diacr[i].diacr = conv_uni_to_8bit(
1578  accent_table[i].diacr);
1579  diacr[i].base = conv_uni_to_8bit(
1580  accent_table[i].base);
1581  diacr[i].result = conv_uni_to_8bit(
1582  accent_table[i].result);
1583  }
1584  spin_unlock_irqrestore(&kbd_event_lock, flags);
1585 
1586  if (put_user(asize, &a->kb_cnt))
1587  ret = -EFAULT;
1588  else if (copy_to_user(a->kbdiacr, diacr,
1589  asize * sizeof(struct kbdiacr)))
1590  ret = -EFAULT;
1591  kfree(diacr);
1592  return ret;
1593  }
1594  case KDGKBDIACRUC:
1595  {
1596  struct kbdiacrsuc __user *a = up;
1597  void *buf;
1598 
1599  buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1600  GFP_KERNEL);
1601  if (buf == NULL)
1602  return -ENOMEM;
1603 
1604  /* Lock the diacriticals table, make a copy and then
1605  copy it after we unlock */
1606  spin_lock_irqsave(&kbd_event_lock, flags);
1607 
1608  asize = accent_table_size;
1609  memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1610 
1611  spin_unlock_irqrestore(&kbd_event_lock, flags);
1612 
1613  if (put_user(asize, &a->kb_cnt))
1614  ret = -EFAULT;
1615  else if (copy_to_user(a->kbdiacruc, buf,
1616  asize*sizeof(struct kbdiacruc)))
1617  ret = -EFAULT;
1618  kfree(buf);
1619  return ret;
1620  }
1621 
1622  case KDSKBDIACR:
1623  {
1624  struct kbdiacrs __user *a = up;
1625  struct kbdiacr *diacr = NULL;
1626  unsigned int ct;
1627  int i;
1628 
1629  if (!perm)
1630  return -EPERM;
1631  if (get_user(ct, &a->kb_cnt))
1632  return -EFAULT;
1633  if (ct >= MAX_DIACR)
1634  return -EINVAL;
1635 
1636  if (ct) {
1637  diacr = kmalloc(sizeof(struct kbdiacr) * ct,
1638  GFP_KERNEL);
1639  if (diacr == NULL)
1640  return -ENOMEM;
1641 
1642  if (copy_from_user(diacr, a->kbdiacr,
1643  sizeof(struct kbdiacr) * ct)) {
1644  kfree(diacr);
1645  return -EFAULT;
1646  }
1647  }
1648 
1649  spin_lock_irqsave(&kbd_event_lock, flags);
1650  accent_table_size = ct;
1651  for (i = 0; i < ct; i++) {
1652  accent_table[i].diacr =
1653  conv_8bit_to_uni(diacr[i].diacr);
1654  accent_table[i].base =
1655  conv_8bit_to_uni(diacr[i].base);
1656  accent_table[i].result =
1657  conv_8bit_to_uni(diacr[i].result);
1658  }
1659  spin_unlock_irqrestore(&kbd_event_lock, flags);
1660  kfree(diacr);
1661  return 0;
1662  }
1663 
1664  case KDSKBDIACRUC:
1665  {
1666  struct kbdiacrsuc __user *a = up;
1667  unsigned int ct;
1668  void *buf = NULL;
1669 
1670  if (!perm)
1671  return -EPERM;
1672 
1673  if (get_user(ct, &a->kb_cnt))
1674  return -EFAULT;
1675 
1676  if (ct >= MAX_DIACR)
1677  return -EINVAL;
1678 
1679  if (ct) {
1680  buf = kmalloc(ct * sizeof(struct kbdiacruc),
1681  GFP_KERNEL);
1682  if (buf == NULL)
1683  return -ENOMEM;
1684 
1685  if (copy_from_user(buf, a->kbdiacruc,
1686  ct * sizeof(struct kbdiacruc))) {
1687  kfree(buf);
1688  return -EFAULT;
1689  }
1690  }
1691  spin_lock_irqsave(&kbd_event_lock, flags);
1692  if (ct)
1693  memcpy(accent_table, buf,
1694  ct * sizeof(struct kbdiacruc));
1695  accent_table_size = ct;
1696  spin_unlock_irqrestore(&kbd_event_lock, flags);
1697  kfree(buf);
1698  return 0;
1699  }
1700  }
1701  return ret;
1702 }
1703 
1712 int vt_do_kdskbmode(int console, unsigned int arg)
1713 {
1714  struct kbd_struct * kbd = kbd_table + console;
1715  int ret = 0;
1716  unsigned long flags;
1717 
1718  spin_lock_irqsave(&kbd_event_lock, flags);
1719  switch(arg) {
1720  case K_RAW:
1721  kbd->kbdmode = VC_RAW;
1722  break;
1723  case K_MEDIUMRAW:
1724  kbd->kbdmode = VC_MEDIUMRAW;
1725  break;
1726  case K_XLATE:
1727  kbd->kbdmode = VC_XLATE;
1728  do_compute_shiftstate();
1729  break;
1730  case K_UNICODE:
1731  kbd->kbdmode = VC_UNICODE;
1732  do_compute_shiftstate();
1733  break;
1734  case K_OFF:
1735  kbd->kbdmode = VC_OFF;
1736  break;
1737  default:
1738  ret = -EINVAL;
1739  }
1740  spin_unlock_irqrestore(&kbd_event_lock, flags);
1741  return ret;
1742 }
1743 
1752 int vt_do_kdskbmeta(int console, unsigned int arg)
1753 {
1754  struct kbd_struct * kbd = kbd_table + console;
1755  int ret = 0;
1756  unsigned long flags;
1757 
1758  spin_lock_irqsave(&kbd_event_lock, flags);
1759  switch(arg) {
1760  case K_METABIT:
1761  clr_vc_kbd_mode(kbd, VC_META);
1762  break;
1763  case K_ESCPREFIX:
1764  set_vc_kbd_mode(kbd, VC_META);
1765  break;
1766  default:
1767  ret = -EINVAL;
1768  }
1769  spin_unlock_irqrestore(&kbd_event_lock, flags);
1770  return ret;
1771 }
1772 
1773 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1774  int perm)
1775 {
1776  struct kbkeycode tmp;
1777  int kc = 0;
1778 
1779  if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1780  return -EFAULT;
1781  switch (cmd) {
1782  case KDGETKEYCODE:
1783  kc = getkeycode(tmp.scancode);
1784  if (kc >= 0)
1785  kc = put_user(kc, &user_kbkc->keycode);
1786  break;
1787  case KDSETKEYCODE:
1788  if (!perm)
1789  return -EPERM;
1790  kc = setkeycode(tmp.scancode, tmp.keycode);
1791  break;
1792  }
1793  return kc;
1794 }
1795 
1796 #define i (tmp.kb_index)
1797 #define s (tmp.kb_table)
1798 #define v (tmp.kb_value)
1799 
1800 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1801  int console)
1802 {
1803  struct kbd_struct * kbd = kbd_table + console;
1804  struct kbentry tmp;
1805  ushort *key_map, *new_map, val, ov;
1806  unsigned long flags;
1807 
1808  if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1809  return -EFAULT;
1810 
1812  perm = 0;
1813 
1814  switch (cmd) {
1815  case KDGKBENT:
1816  /* Ensure another thread doesn't free it under us */
1817  spin_lock_irqsave(&kbd_event_lock, flags);
1818  key_map = key_maps[s];
1819  if (key_map) {
1820  val = U(key_map[i]);
1821  if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1822  val = K_HOLE;
1823  } else
1824  val = (i ? K_HOLE : K_NOSUCHMAP);
1825  spin_unlock_irqrestore(&kbd_event_lock, flags);
1826  return put_user(val, &user_kbe->kb_value);
1827  case KDSKBENT:
1828  if (!perm)
1829  return -EPERM;
1830  if (!i && v == K_NOSUCHMAP) {
1831  spin_lock_irqsave(&kbd_event_lock, flags);
1832  /* deallocate map */
1833  key_map = key_maps[s];
1834  if (s && key_map) {
1835  key_maps[s] = NULL;
1836  if (key_map[0] == U(K_ALLOCATED)) {
1837  kfree(key_map);
1838  keymap_count--;
1839  }
1840  }
1841  spin_unlock_irqrestore(&kbd_event_lock, flags);
1842  break;
1843  }
1844 
1845  if (KTYP(v) < NR_TYPES) {
1846  if (KVAL(v) > max_vals[KTYP(v)])
1847  return -EINVAL;
1848  } else
1849  if (kbd->kbdmode != VC_UNICODE)
1850  return -EINVAL;
1851 
1852  /* ++Geert: non-PC keyboards may generate keycode zero */
1853 #if !defined(__mc68000__) && !defined(__powerpc__)
1854  /* assignment to entry 0 only tests validity of args */
1855  if (!i)
1856  break;
1857 #endif
1858 
1859  new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1860  if (!new_map)
1861  return -ENOMEM;
1862  spin_lock_irqsave(&kbd_event_lock, flags);
1863  key_map = key_maps[s];
1864  if (key_map == NULL) {
1865  int j;
1866 
1869  spin_unlock_irqrestore(&kbd_event_lock, flags);
1870  kfree(new_map);
1871  return -EPERM;
1872  }
1873  key_maps[s] = new_map;
1874  key_map = new_map;
1875  key_map[0] = U(K_ALLOCATED);
1876  for (j = 1; j < NR_KEYS; j++)
1877  key_map[j] = U(K_HOLE);
1878  keymap_count++;
1879  } else
1880  kfree(new_map);
1881 
1882  ov = U(key_map[i]);
1883  if (v == ov)
1884  goto out;
1885  /*
1886  * Attention Key.
1887  */
1888  if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1889  spin_unlock_irqrestore(&kbd_event_lock, flags);
1890  return -EPERM;
1891  }
1892  key_map[i] = U(v);
1893  if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1894  do_compute_shiftstate();
1895 out:
1896  spin_unlock_irqrestore(&kbd_event_lock, flags);
1897  break;
1898  }
1899  return 0;
1900 }
1901 #undef i
1902 #undef s
1903 #undef v
1904 
1905 /* FIXME: This one needs untangling and locking */
1906 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1907 {
1908  struct kbsentry *kbs;
1909  char *p;
1910  u_char *q;
1911  u_char __user *up;
1912  int sz;
1913  int delta;
1914  char *first_free, *fj, *fnw;
1915  int i, j, k;
1916  int ret;
1917 
1919  perm = 0;
1920 
1921  kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1922  if (!kbs) {
1923  ret = -ENOMEM;
1924  goto reterr;
1925  }
1926 
1927  /* we mostly copy too much here (512bytes), but who cares ;) */
1928  if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1929  ret = -EFAULT;
1930  goto reterr;
1931  }
1932  kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1933  i = kbs->kb_func;
1934 
1935  switch (cmd) {
1936  case KDGKBSENT:
1937  sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1938  a struct member */
1939  up = user_kdgkb->kb_string;
1940  p = func_table[i];
1941  if(p)
1942  for ( ; *p && sz; p++, sz--)
1943  if (put_user(*p, up++)) {
1944  ret = -EFAULT;
1945  goto reterr;
1946  }
1947  if (put_user('\0', up)) {
1948  ret = -EFAULT;
1949  goto reterr;
1950  }
1951  kfree(kbs);
1952  return ((p && *p) ? -EOVERFLOW : 0);
1953  case KDSKBSENT:
1954  if (!perm) {
1955  ret = -EPERM;
1956  goto reterr;
1957  }
1958 
1959  q = func_table[i];
1960  first_free = funcbufptr + (funcbufsize - funcbufleft);
1961  for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1962  ;
1963  if (j < MAX_NR_FUNC)
1964  fj = func_table[j];
1965  else
1966  fj = first_free;
1967 
1968  delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1969  if (delta <= funcbufleft) { /* it fits in current buf */
1970  if (j < MAX_NR_FUNC) {
1971  memmove(fj + delta, fj, first_free - fj);
1972  for (k = j; k < MAX_NR_FUNC; k++)
1973  if (func_table[k])
1974  func_table[k] += delta;
1975  }
1976  if (!q)
1977  func_table[i] = fj;
1978  funcbufleft -= delta;
1979  } else { /* allocate a larger buffer */
1980  sz = 256;
1981  while (sz < funcbufsize - funcbufleft + delta)
1982  sz <<= 1;
1983  fnw = kmalloc(sz, GFP_KERNEL);
1984  if(!fnw) {
1985  ret = -ENOMEM;
1986  goto reterr;
1987  }
1988 
1989  if (!q)
1990  func_table[i] = fj;
1991  if (fj > funcbufptr)
1992  memmove(fnw, funcbufptr, fj - funcbufptr);
1993  for (k = 0; k < j; k++)
1994  if (func_table[k])
1995  func_table[k] = fnw + (func_table[k] - funcbufptr);
1996 
1997  if (first_free > fj) {
1998  memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
1999  for (k = j; k < MAX_NR_FUNC; k++)
2000  if (func_table[k])
2001  func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2002  }
2003  if (funcbufptr != func_buf)
2004  kfree(funcbufptr);
2005  funcbufptr = fnw;
2006  funcbufleft = funcbufleft - delta + sz - funcbufsize;
2007  funcbufsize = sz;
2008  }
2009  strcpy(func_table[i], kbs->kb_string);
2010  break;
2011  }
2012  ret = 0;
2013 reterr:
2014  kfree(kbs);
2015  return ret;
2016 }
2017 
2018 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2019 {
2020  struct kbd_struct * kbd = kbd_table + console;
2021  unsigned long flags;
2022  unsigned char ucval;
2023 
2024  switch(cmd) {
2025  /* the ioctls below read/set the flags usually shown in the leds */
2026  /* don't use them - they will go away without warning */
2027  case KDGKBLED:
2028  spin_lock_irqsave(&kbd_event_lock, flags);
2029  ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4);
2030  spin_unlock_irqrestore(&kbd_event_lock, flags);
2031  return put_user(ucval, (char __user *)arg);
2032 
2033  case KDSKBLED:
2034  if (!perm)
2035  return -EPERM;
2036  if (arg & ~0x77)
2037  return -EINVAL;
2038  spin_lock_irqsave(&led_lock, flags);
2039  kbd->ledflagstate = (arg & 7);
2040  kbd->default_ledflagstate = ((arg >> 4) & 7);
2041  set_leds();
2042  spin_unlock_irqrestore(&led_lock, flags);
2043  return 0;
2044 
2045  /* the ioctls below only set the lights, not the functions */
2046  /* for those, see KDGKBLED and KDSKBLED above */
2047  case KDGETLED:
2048  ucval = getledstate();
2049  return put_user(ucval, (char __user *)arg);
2050 
2051  case KDSETLED:
2052  if (!perm)
2053  return -EPERM;
2054  setledstate(kbd, arg);
2055  return 0;
2056  }
2057  return -ENOIOCTLCMD;
2058 }
2059 
2061 {
2062  struct kbd_struct * kbd = kbd_table + console;
2063  /* This is a spot read so needs no locking */
2064  switch (kbd->kbdmode) {
2065  case VC_RAW:
2066  return K_RAW;
2067  case VC_MEDIUMRAW:
2068  return K_MEDIUMRAW;
2069  case VC_UNICODE:
2070  return K_UNICODE;
2071  case VC_OFF:
2072  return K_OFF;
2073  default:
2074  return K_XLATE;
2075  }
2076 }
2077 
2085 {
2086  struct kbd_struct * kbd = kbd_table + console;
2087  /* Again a spot read so no locking */
2088  return vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT;
2089 }
2090 
2098 {
2099  unsigned long flags;
2100 
2101  spin_lock_irqsave(&kbd_event_lock, flags);
2102  kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2103  spin_unlock_irqrestore(&kbd_event_lock, flags);
2104 }
2105 
2113 {
2114  /* Don't lock as this is a transient report */
2115  return shift_state;
2116 }
2117 
2126 {
2127  struct kbd_struct * kbd = kbd_table + console;
2128  unsigned long flags;
2129 
2130  spin_lock_irqsave(&kbd_event_lock, flags);
2131  set_vc_kbd_mode(kbd, VC_REPEAT);
2132  clr_vc_kbd_mode(kbd, VC_CKMODE);
2133  clr_vc_kbd_mode(kbd, VC_APPLIC);
2134  clr_vc_kbd_mode(kbd, VC_CRLF);
2135  kbd->lockstate = 0;
2136  kbd->slockstate = 0;
2137  spin_lock(&led_lock);
2138  kbd->ledmode = LED_SHOW_FLAGS;
2139  kbd->ledflagstate = kbd->default_ledflagstate;
2140  spin_unlock(&led_lock);
2141  /* do not do set_leds here because this causes an endless tasklet loop
2142  when the keyboard hasn't been initialized yet */
2143  spin_unlock_irqrestore(&kbd_event_lock, flags);
2144 }
2145 
2156 {
2157  struct kbd_struct * kbd = kbd_table + console;
2158  return vc_kbd_mode(kbd, bit);
2159 }
2160 
2171 {
2172  struct kbd_struct * kbd = kbd_table + console;
2173  unsigned long flags;
2174 
2175  spin_lock_irqsave(&kbd_event_lock, flags);
2176  set_vc_kbd_mode(kbd, bit);
2177  spin_unlock_irqrestore(&kbd_event_lock, flags);
2178 }
2179 
2190 {
2191  struct kbd_struct * kbd = kbd_table + console;
2192  unsigned long flags;
2193 
2194  spin_lock_irqsave(&kbd_event_lock, flags);
2195  clr_vc_kbd_mode(kbd, bit);
2196  spin_unlock_irqrestore(&kbd_event_lock, flags);
2197 }