kernel/debug/kdb/kdb_keyboard.c

   1 /*
   2  * Kernel Debugger Architecture Dependent Console I/O handler
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.
   6  *
   7  * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
   8  * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
   9  */
  10
  11 #include <linux/kdb.h>
  12 #include <linux/keyboard.h>
  13 #include <linux/ctype.h>
  14 #include <linux/io.h>
  15
  16 #include "kdb_private.h"
  17
  18 /* Keyboard Controller Registers on normal PCs. */
  19
  20 #define KBD_STATUS_REG          0x64    /* Status register (R) */
  21 #define KBD_DATA_REG            0x60    /* Keyboard data register (R/W) */
  22
  23 /* Status Register Bits */
  24
  25 #define KBD_STAT_OBF            0x01    /* Keyboard output buffer full */
  26 #define KBD_STAT_MOUSE_OBF      0x20    /* Mouse output buffer full */
  27
  28 static int kbd_exists;
  29 static int kbd_last_ret;
  30
  31 /*
  32  * Check if the keyboard controller has a keypress for us.
  33  * Some parts (Enter Release, LED change) are still blocking polled here,
  34  * but hopefully they are all short.
  35  */
  36 int kdb_get_kbd_char(void)
  37 {
  38         int scancode, scanstatus;
  39         static int shift_lock;  /* CAPS LOCK state (0-off, 1-on) */
  40         static int shift_key;   /* Shift next keypress */
  41         static int ctrl_key;
  42         u_short keychar;
  43
  44         if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) ||
  45             (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
  46                 kbd_exists = 0;
  47                 return -1;
  48         }
  49         kbd_exists = 1;
  50
  51         if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
  52                 return -1;
  53
  54         /*
  55          * Fetch the scancode
  56          */
  57         scancode = inb(KBD_DATA_REG);
  58         scanstatus = inb(KBD_STATUS_REG);
  59
  60         /*
  61          * Ignore mouse events.
  62          */
  63         if (scanstatus & KBD_STAT_MOUSE_OBF)
  64                 return -1;
  65
  66         /*
  67          * Ignore release, trigger on make
  68          * (except for shift keys, where we want to
  69          *  keep the shift state so long as the key is
  70          *  held down).
  71          */
  72
  73         if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) {
  74                 /*
  75                  * Next key may use shift table
  76                  */
  77                 if ((scancode & 0x80) == 0)
  78                         shift_key = 1;
  79                 else
  80                         shift_key = 0;
  81                 return -1;
  82         }
  83
  84         if ((scancode&0x7f) == 0x1d) {
  85                 /*
  86                  * Left ctrl key
  87                  */
  88                 if ((scancode & 0x80) == 0)
  89                         ctrl_key = 1;
  90                 else
  91                         ctrl_key = 0;
  92                 return -1;
  93         }
  94
  95         if ((scancode & 0x80) != 0) {
  96                 if (scancode == 0x9c)
  97                         kbd_last_ret = 0;
  98                 return -1;
  99         }
 100
 101         scancode &= 0x7f;
 102
 103         /*
 104          * Translate scancode
 105          */
 106
 107         if (scancode == 0x3a) {
 108                 /*
 109                  * Toggle caps lock
 110                  */
 111                 shift_lock ^= 1;
 112
 113 #ifdef  KDB_BLINK_LED
 114                 kdb_toggleled(0x4);
 115 #endif
 116                 return -1;
 117         }
 118
 119         if (scancode == 0x0e) {
 120                 /*
 121                  * Backspace
 122                  */
 123                 return 8;
 124         }
 125
 126         /* Special Key */
 127         switch (scancode) {
 128         case 0xF: /* Tab */
 129                 return 9;
 130         case 0x53: /* Del */
 131                 return 4;
 132         case 0x47: /* Home */
 133                 return 1;
 134         case 0x4F: /* End */
 135                 return 5;
 136         case 0x4B: /* Left */
 137                 return 2;
 138         case 0x48: /* Up */
 139                 return 16;
 140         case 0x50: /* Down */
 141                 return 14;
 142         case 0x4D: /* Right */
 143                 return 6;
 144         }
 145
 146         if (scancode == 0xe0)
 147                 return -1;
 148
 149         /*
 150          * For Japanese 86/106 keyboards
 151          *      See comment in drivers/char/pc_keyb.c.
 152          *      - Masahiro Adegawa
 153          */
 154         if (scancode == 0x73)
 155                 scancode = 0x59;
 156         else if (scancode == 0x7d)
 157                 scancode = 0x7c;
 158
 159         if (!shift_lock && !shift_key && !ctrl_key) {
 160                 keychar = plain_map[scancode];
 161         } else if ((shift_lock || shift_key) && key_maps[1]) {
 162                 keychar = key_maps[1][scancode];
 163         } else if (ctrl_key && key_maps[4]) {
 164                 keychar = key_maps[4][scancode];
 165         } else {
 166                 keychar = 0x0020;
 167                 kdb_printf("Unknown state/scancode (%d)\n", scancode);
 168         }
 169         keychar &= 0x0fff;
 170         if (keychar == '\t')
 171                 keychar = ' ';
 172         switch (KTYP(keychar)) {
 173         case KT_LETTER:
 174         case KT_LATIN:
 175                 if (isprint(keychar))
 176                         break;          /* printable characters */
 177                 fallthrough;
 178         case KT_SPEC:
 179                 if (keychar == K_ENTER)
 180                         break;
 181                 fallthrough;
 182         default:
 183                 return -1;      /* ignore unprintables */
 184         }
 185
 186         if (scancode == 0x1c) {
 187                 kbd_last_ret = 1;
 188                 return 13;
 189         }
 190
 191         return keychar & 0xff;
 192 }
 193 EXPORT_SYMBOL_GPL(kdb_get_kbd_char);
 194
 195 /*
 196  * Best effort cleanup of ENTER break codes on leaving KDB. Called on
 197  * exiting KDB, when we know we processed an ENTER or KP ENTER scan
 198  * code.
 199  */
 200 void kdb_kbd_cleanup_state(void)
 201 {
 202         int scancode, scanstatus;
 203
 204         /*
 205          * Nothing to clean up, since either
 206          * ENTER was never pressed, or has already
 207          * gotten cleaned up.
 208          */
 209         if (!kbd_last_ret)
 210                 return;
 211
 212         kbd_last_ret = 0;
 213         /*
 214          * Enter key. Need to absorb the break code here, lest it gets
 215          * leaked out if we exit KDB as the result of processing 'g'.
 216          *
 217          * This has several interesting implications:
 218          * + Need to handle KP ENTER, which has break code 0xe0 0x9c.
 219          * + Need to handle repeat ENTER and repeat KP ENTER. Repeats
 220          *   only get a break code at the end of the repeated
 221          *   sequence. This means we can't propagate the repeated key
 222          *   press, and must swallow it away.
 223          * + Need to handle possible PS/2 mouse input.
 224          * + Need to handle mashed keys.
 225          */
 226
 227         while (1) {
 228                 while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
 229                         cpu_relax();
 230
 231                 /*
 232                  * Fetch the scancode.
 233                  */
 234                 scancode = inb(KBD_DATA_REG);
 235                 scanstatus = inb(KBD_STATUS_REG);
 236
 237                 /*
 238                  * Skip mouse input.
 239                  */
 240                 if (scanstatus & KBD_STAT_MOUSE_OBF)
 241                         continue;
 242
 243                 /*
 244                  * If we see 0xe0, this is either a break code for KP
 245                  * ENTER, or a repeat make for KP ENTER. Either way,
 246                  * since the second byte is equivalent to an ENTER,
 247                  * skip the 0xe0 and try again.
 248                  *
 249                  * If we see 0x1c, this must be a repeat ENTER or KP
 250                  * ENTER (and we swallowed 0xe0 before). Try again.
 251                  *
 252                  * We can also see make and break codes for other keys
 253                  * mashed before or after pressing ENTER. Thus, if we
 254                  * see anything other than 0x9c, we have to try again.
 255                  *
 256                  * Note, if you held some key as ENTER was depressed,
 257                  * that break code would get leaked out.
 258                  */
 259                 if (scancode != 0x9c)
 260                         continue;
 261
 262                 return;
 263         }
 264 }