arch/arm26/lib/kbd.c

   1 #include <linux/kd.h>
   2 //#include <linux/kbd_ll.h>
   3 #include <linux/kbd_kern.h>
   4
   5 /*
   6  * Translation of escaped scancodes to keycodes.
   7  * This is now user-settable.
   8  * The keycodes 1-88,96-111,119 are fairly standard, and
   9  * should probably not be changed - changing might confuse X.
  10  * X also interprets scancode 0x5d (KEY_Begin).
  11  *
  12  * For 1-88 keycode equals scancode.
  13  */
  14
  15 #define E0_KPENTER 96
  16 #define E0_RCTRL   97
  17 #define E0_KPSLASH 98
  18 #define E0_PRSCR   99
  19 #define E0_RALT    100
  20 #define E0_BREAK   101          /* (control-pause) */
  21 #define E0_HOME    102
  22 #define E0_UP      103
  23 #define E0_PGUP    104
  24 #define E0_LEFT    105
  25 #define E0_RIGHT   106
  26 #define E0_END     107
  27 #define E0_DOWN    108
  28 #define E0_PGDN    109
  29 #define E0_INS     110
  30 #define E0_DEL     111
  31
  32 /* for USB 106 keyboard */
  33 #define E0_YEN         124
  34 #define E0_BACKSLASH   89
  35
  36
  37 #define E1_PAUSE   119
  38
  39 /*
  40  * The keycodes below are randomly located in 89-95,112-118,120-127.
  41  * They could be thrown away (and all occurrences below replaced by 0),
  42  * but that would force many users to use the `setkeycodes' utility, where
  43  * they needed not before. It does not matter that there are duplicates, as
  44  * long as no duplication occurs for any single keyboard.
  45  */
  46 #define SC_LIM 89
  47
  48 #define FOCUS_PF1 85            /* actual code! */
  49 #define FOCUS_PF2 89
  50 #define FOCUS_PF3 90
  51 #define FOCUS_PF4 91
  52 #define FOCUS_PF5 92
  53 #define FOCUS_PF6 93
  54 #define FOCUS_PF7 94
  55 #define FOCUS_PF8 95
  56 #define FOCUS_PF9 120
  57 #define FOCUS_PF10 121
  58 #define FOCUS_PF11 122
  59 #define FOCUS_PF12 123
  60
  61 #define JAP_86     124
  62 /* tfj@olivia.ping.dk:
  63  * The four keys are located over the numeric keypad, and are
  64  * labelled A1-A4. It's an rc930 keyboard, from
  65  * Regnecentralen/RC International, Now ICL.
  66  * Scancodes: 59, 5a, 5b, 5c.
  67  */
  68 #define RGN1 124
  69 #define RGN2 125
  70 #define RGN3 126
  71 #define RGN4 127
  72
  73 static unsigned char high_keys[128 - SC_LIM] = {
  74         RGN1, RGN2, RGN3, RGN4, 0, 0, 0,        /* 0x59-0x5f */
  75         0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
  76         0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12,       /* 0x68-0x6f */
  77         0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3, /* 0x70-0x77 */
  78         FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7,     /* 0x78-0x7b */
  79         FOCUS_PF8, JAP_86, FOCUS_PF10, 0        /* 0x7c-0x7f */
  80 };
  81
  82 /* BTC */
  83 #define E0_MACRO   112
  84 /* LK450 */
  85 #define E0_F13     113
  86 #define E0_F14     114
  87 #define E0_HELP    115
  88 #define E0_DO      116
  89 #define E0_F17     117
  90 #define E0_KPMINPLUS 118
  91 /*
  92  * My OmniKey generates e0 4c for  the "OMNI" key and the
  93  * right alt key does nada. [kkoller@nyx10.cs.du.edu]
  94  */
  95 #define E0_OK  124
  96 /*
  97  * New microsoft keyboard is rumoured to have
  98  * e0 5b (left window button), e0 5c (right window button),
  99  * e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
 100  * [or: Windows_L, Windows_R, TaskMan]
 101  */
 102 #define E0_MSLW        125
 103 #define E0_MSRW        126
 104 #define E0_MSTM        127
 105
 106 static unsigned char e0_keys[128] = {
 107         0, 0, 0, 0, 0, 0, 0, 0, /* 0x00-0x07 */
 108         0, 0, 0, 0, 0, 0, 0, 0, /* 0x08-0x0f */
 109         0, 0, 0, 0, 0, 0, 0, 0, /* 0x10-0x17 */
 110         0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0, /* 0x18-0x1f */
 111         0, 0, 0, 0, 0, 0, 0, 0, /* 0x20-0x27 */
 112         0, 0, 0, 0, 0, 0, 0, 0, /* 0x28-0x2f */
 113         0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR, /* 0x30-0x37 */
 114         E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP,   /* 0x38-0x3f */
 115         E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME,   /* 0x40-0x47 */
 116         E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END,      /* 0x48-0x4f */
 117         E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0,   /* 0x50-0x57 */
 118         0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0,       /* 0x58-0x5f */
 119         0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
 120         0, 0, 0, 0, 0, 0, 0, E0_MACRO,  /* 0x68-0x6f */
 121         //0, 0, 0, 0, 0, 0, 0, 0,                          /* 0x70-0x77 */
 122         0, 0, 0, 0, 0, E0_BACKSLASH, 0, 0,      /* 0x70-0x77 */
 123         0, 0, 0, E0_YEN, 0, 0, 0, 0     /* 0x78-0x7f */
 124 };
 125
 126 static int gen_setkeycode(unsigned int scancode, unsigned int keycode)
 127 {
 128         if (scancode < SC_LIM || scancode > 255 || keycode > 127)
 129                 return -EINVAL;
 130         if (scancode < 128)
 131                 high_keys[scancode - SC_LIM] = keycode;
 132         else
 133                 e0_keys[scancode - 128] = keycode;
 134         return 0;
 135 }
 136
 137 static int gen_getkeycode(unsigned int scancode)
 138 {
 139         return
 140             (scancode < SC_LIM || scancode > 255) ? -EINVAL :
 141             (scancode <
 142              128) ? high_keys[scancode - SC_LIM] : e0_keys[scancode - 128];
 143 }
 144
 145 static int
 146 gen_translate(unsigned char scancode, unsigned char *keycode, char raw_mode)
 147 {
 148         static int prev_scancode;
 149
 150         /* special prefix scancodes.. */
 151         if (scancode == 0xe0 || scancode == 0xe1) {
 152                 prev_scancode = scancode;
 153                 return 0;
 154         }
 155
 156         /* 0xFF is sent by a few keyboards, ignore it. 0x00 is error */
 157         if (scancode == 0x00 || scancode == 0xff) {
 158                 prev_scancode = 0;
 159                 return 0;
 160         }
 161
 162         scancode &= 0x7f;
 163
 164         if (prev_scancode) {
 165                 /*
 166                  * usually it will be 0xe0, but a Pause key generates
 167                  * e1 1d 45 e1 9d c5 when pressed, and nothing when released
 168                  */
 169                 if (prev_scancode != 0xe0) {
 170                         if (prev_scancode == 0xe1 && scancode == 0x1d) {
 171                                 prev_scancode = 0x100;
 172                                 return 0;
 173                         }
 174                                 else if (prev_scancode == 0x100
 175                                          && scancode == 0x45) {
 176                                 *keycode = E1_PAUSE;
 177                                 prev_scancode = 0;
 178                         } else {
 179 #ifdef KBD_REPORT_UNKN
 180                                 if (!raw_mode)
 181                                         printk(KERN_INFO
 182                                                "keyboard: unknown e1 escape sequence\n");
 183 #endif
 184                                 prev_scancode = 0;
 185                                 return 0;
 186                         }
 187                 } else {
 188                         prev_scancode = 0;
 189                         /*
 190                          *  The keyboard maintains its own internal caps lock and
 191                          *  num lock statuses. In caps lock mode E0 AA precedes make
 192                          *  code and E0 2A follows break code. In num lock mode,
 193                          *  E0 2A precedes make code and E0 AA follows break code.
 194                          *  We do our own book-keeping, so we will just ignore these.
 195                          */
 196                         /*
 197                          *  For my keyboard there is no caps lock mode, but there are
 198                          *  both Shift-L and Shift-R modes. The former mode generates
 199                          *  E0 2A / E0 AA pairs, the latter E0 B6 / E0 36 pairs.
 200                          *  So, we should also ignore the latter. - aeb@cwi.nl
 201                          */
 202                         if (scancode == 0x2a || scancode == 0x36)
 203                                 return 0;
 204
 205                         if (e0_keys[scancode])
 206                                 *keycode = e0_keys[scancode];
 207                         else {
 208 #ifdef KBD_REPORT_UNKN
 209                                 if (!raw_mode)
 210                                         printk(KERN_INFO
 211                                                "keyboard: unknown scancode e0 %02x\n",
 212                                                scancode);
 213 #endif
 214                                 return 0;
 215                         }
 216                 }
 217         } else if (scancode >= SC_LIM) {
 218                 /* This happens with the FOCUS 9000 keyboard
 219                    Its keys PF1..PF12 are reported to generate
 220                    55 73 77 78 79 7a 7b 7c 74 7e 6d 6f
 221                    Moreover, unless repeated, they do not generate
 222                    key-down events, so we have to zero up_flag below */
 223                 /* Also, Japanese 86/106 keyboards are reported to
 224                    generate 0x73 and 0x7d for \ - and \ | respectively. */
 225                 /* Also, some Brazilian keyboard is reported to produce
 226                    0x73 and 0x7e for \ ? and KP-dot, respectively. */
 227
 228                 *keycode = high_keys[scancode - SC_LIM];
 229
 230                 if (!*keycode) {
 231                         if (!raw_mode) {
 232 #ifdef KBD_REPORT_UNKN
 233                                 printk(KERN_INFO
 234                                        "keyboard: unrecognized scancode (%02x)"
 235                                        " - ignored\n", scancode);
 236 #endif
 237                         }
 238                         return 0;
 239                 }
 240         } else
 241                 *keycode = scancode;
 242         return 1;
 243 }
 244
 245 static char gen_unexpected_up(unsigned char keycode)
 246 {
 247         /* unexpected, but this can happen: maybe this was a key release for a
 248            FOCUS 9000 PF key; if we want to see it, we have to clear up_flag */
 249         if (keycode >= SC_LIM || keycode == 85)
 250                 return 0;
 251         else
 252                 return 0200;
 253 }
 254
 255 /*
 256  * These are the default mappings
 257  */
 258 int  (*k_setkeycode)(unsigned int, unsigned int) = gen_setkeycode;
 259 int  (*k_getkeycode)(unsigned int) = gen_getkeycode;
 260 int  (*k_translate)(unsigned char, unsigned char *, char) = gen_translate;
 261 char (*k_unexpected_up)(unsigned char) = gen_unexpected_up;
 262 void (*k_leds)(unsigned char);
 263
 264 /* Simple translation table for the SysRq keys */
 265
 266 #ifdef CONFIG_MAGIC_SYSRQ
 267 static unsigned char gen_sysrq_xlate[128] =
 268         "\000\0331234567890-=\177\t"    /* 0x00 - 0x0f */
 269         "qwertyuiop[]\r\000as"  /* 0x10 - 0x1f */
 270         "dfghjkl;'`\000\\zxcv"  /* 0x20 - 0x2f */
 271         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 272         "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
 273         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000"       /* 0x50 - 0x5f */
 274         "\r\000/";                      /* 0x60 - 0x6f */
 275
 276 unsigned char *k_sysrq_xlate = gen_sysrq_xlate;
 277 int k_sysrq_key = 0x54;
 278 #endif