LCOV - code coverage report
Current view: top level - drivers/tty/vt - keyboard.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 163 955 17.1 %
Date: 2021-04-22 12:43:58 Functions: 14 92 15.2 %

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

Generated by: LCOV version 1.14