drivers/tty/vt/keyboard.c

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

DEFINITIONS
