src/acpi/acpigen_ps2_keybd.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 #include <acpi/acpigen.h>
   4 #include <acpi/acpigen_ps2_keybd.h>
   5 #include <console/console.h>
   6 #include <input-event-codes.h>
   7 #include <stdbool.h>
   8 #include <stdint.h>
   9
  10 #define KEYMAP(scancode, keycode) (((uint32_t)(scancode) << 16) | (keycode & 0xFFFF))
  11 #define SCANCODE(keymap) ((keymap >> 16) & 0xFFFF)
  12
  13 /* Possible keymaps for function keys in the top row */
  14 static const uint32_t function_keymaps[] = {
  15         KEYMAP(0x3b, KEY_F1),
  16         KEYMAP(0x3c, KEY_F2),
  17         KEYMAP(0x3d, KEY_F3),
  18         KEYMAP(0x3e, KEY_F4),
  19         KEYMAP(0x3f, KEY_F5),
  20         KEYMAP(0x40, KEY_F6),
  21         KEYMAP(0x41, KEY_F7),
  22         KEYMAP(0x42, KEY_F8),
  23         KEYMAP(0x43, KEY_F9),
  24         KEYMAP(0x44, KEY_F10),
  25         KEYMAP(0x57, KEY_F11),
  26         KEYMAP(0x58, KEY_F12),
  27         KEYMAP(0x59, KEY_F13),
  28         KEYMAP(0x5a, KEY_F14),
  29         KEYMAP(0x5b, KEY_F15),
  30 };
  31
  32 /*
  33  * Possible keymaps for action keys in the top row. This is a superset of
  34  * possible keys. Individual keyboards will have a subset of these keys.
  35  * The scancodes are true / condensed 1 byte scancodes from set-1
  36  */
  37 static const uint32_t action_keymaps[] = {
  38         [PS2_KEY_BACK] = KEYMAP(0xea, KEY_BACK),                /* e06a */
  39         [PS2_KEY_FORWARD] = KEYMAP(0xe9, KEY_FORWARD),          /* e069 */
  40         [PS2_KEY_REFRESH] = KEYMAP(0xe7, KEY_REFRESH),          /* e067 */
  41         [PS2_KEY_FULLSCREEN] = KEYMAP(0x91, KEY_FULL_SCREEN),   /* e011 */
  42         [PS2_KEY_OVERVIEW] = KEYMAP(0x92, KEY_SCALE),           /* e012 */
  43         [PS2_KEY_VOL_MUTE] = KEYMAP(0xa0, KEY_MUTE),            /* e020 */
  44         [PS2_KEY_VOL_DOWN] = KEYMAP(0xae, KEY_VOLUMEDOWN),      /* e02e */
  45         [PS2_KEY_VOL_UP] = KEYMAP(0xb0, KEY_VOLUMEUP),          /* e030 */
  46         [PS2_KEY_PLAY_PAUSE] = KEYMAP(0x9a, KEY_PLAYPAUSE),     /* e01a */
  47         [PS2_KEY_NEXT_TRACK] = KEYMAP(0x99, KEY_NEXTSONG),      /* e019 */
  48         [PS2_KEY_PREV_TRACK] = KEYMAP(0x90, KEY_PREVIOUSSONG),  /* e010 */
  49         [PS2_KEY_SNAPSHOT] = KEYMAP(0x93, KEY_SYSRQ),           /* e013 */
  50         [PS2_KEY_BRIGHTNESS_DOWN] = KEYMAP(0x94, KEY_BRIGHTNESSDOWN),   /* e014 */
  51         [PS2_KEY_BRIGHTNESS_UP] = KEYMAP(0x95, KEY_BRIGHTNESSUP),       /* e015 */
  52         [PS2_KEY_KBD_BKLIGHT_DOWN] = KEYMAP(0x97, KEY_KBDILLUMDOWN),    /* e017 */
  53         [PS2_KEY_KBD_BKLIGHT_UP] = KEYMAP(0x98, KEY_KBDILLUMUP),        /* e018 */
  54         [PS2_KEY_PRIVACY_SCRN_TOGGLE] = KEYMAP(0x96,                    /* e016 */
  55                                           KEY_PRIVACY_SCREEN_TOGGLE),
  56         [PS2_KEY_MICMUTE] = KEYMAP(0x9b, KEY_MICMUTE),                  /* e01b */
  57         [PS2_KEY_KBD_BKLIGHT_TOGGLE] = KEYMAP(0x9e, KEY_KBDILLUMTOGGLE),        /* e01e */
  58         [PS2_KEY_MENU] = KEYMAP(0xdd, KEY_CONTROLPANEL),        /* e0d5 */
  59         [PS2_KEY_DICTATE] = KEYMAP(0xa7, KEY_DICTATE),          /* e027*/
  60         [PS2_KEY_ACCESSIBILITY] = KEYMAP(0xa9, KEY_ACCESSIBILITY),      /* e029 */
  61         [PS2_KEY_DO_NOT_DISTURB] = KEYMAP(0xa8, KEY_DO_NOT_DISTURB),    /* e028 */
  62 };
  63
  64 /* Keymap for numeric keypad keys */
  65 static uint32_t numeric_keypad_keymaps[] = {
  66         /* Row-0 */
  67         KEYMAP(0xc9, KEY_PAGEUP),
  68         KEYMAP(0xd1, KEY_PAGEDOWN),
  69         KEYMAP(0xc7, KEY_HOME),
  70         KEYMAP(0xcf, KEY_END),
  71         /* Row-1 */
  72         KEYMAP(0xb5, KEY_KPSLASH),
  73         KEYMAP(0x37, KEY_KPASTERISK),
  74         KEYMAP(0x4a, KEY_KPMINUS),
  75         /* Row-2 */
  76         KEYMAP(0x47, KEY_KP7),
  77         KEYMAP(0x48, KEY_KP8),
  78         KEYMAP(0x49, KEY_KP9),
  79         KEYMAP(0x4e, KEY_KPPLUS),
  80         /* Row-3 */
  81         KEYMAP(0x4b, KEY_KP4),
  82         KEYMAP(0x4c, KEY_KP5),
  83         KEYMAP(0x4d, KEY_KP6),
  84         /* Row-4 */
  85         KEYMAP(0x4f, KEY_KP1),
  86         KEYMAP(0x50, KEY_KP2),
  87         KEYMAP(0x51, KEY_KP3),
  88         KEYMAP(0x9c, KEY_KPENTER),
  89         /* Row-5 */
  90         KEYMAP(0x52, KEY_KP0),
  91         KEYMAP(0x53, KEY_KPDOT),
  92 };
  93
  94 /*
  95  * Keymap for rest of non-top-row keys. This is a superset of all the possible
  96  * keys that any chromeos keyboards can have.
  97  */
  98 static uint32_t rest_of_keymaps[] = {
  99         /* Row-0 */
 100         KEYMAP(0x01, KEY_ESC),
 101         KEYMAP(0xd3, KEY_DELETE),
 102         /* Row-1 */
 103         KEYMAP(0x29, KEY_GRAVE),
 104         KEYMAP(0x02, KEY_1),
 105         KEYMAP(0x03, KEY_2),
 106         KEYMAP(0x04, KEY_3),
 107         KEYMAP(0x05, KEY_4),
 108         KEYMAP(0x06, KEY_5),
 109         KEYMAP(0x07, KEY_6),
 110         KEYMAP(0x08, KEY_7),
 111         KEYMAP(0x09, KEY_8),
 112         KEYMAP(0x0a, KEY_9),
 113         KEYMAP(0x0b, KEY_0),
 114         KEYMAP(0x0c, KEY_MINUS),
 115         KEYMAP(0x0d, KEY_EQUAL),
 116         KEYMAP(0x7d, KEY_YEN),          /* JP keyboards only */
 117         KEYMAP(0x0e, KEY_BACKSPACE),
 118         /* Row-2 */
 119         KEYMAP(0x0f, KEY_TAB),
 120         KEYMAP(0x10, KEY_Q),
 121         KEYMAP(0x11, KEY_W),
 122         KEYMAP(0x12, KEY_E),
 123         KEYMAP(0x13, KEY_R),
 124         KEYMAP(0x14, KEY_T),
 125         KEYMAP(0x15, KEY_Y),
 126         KEYMAP(0x16, KEY_U),
 127         KEYMAP(0x17, KEY_I),
 128         KEYMAP(0x18, KEY_O),
 129         KEYMAP(0x19, KEY_P),
 130         KEYMAP(0x1a, KEY_LEFTBRACE),
 131         KEYMAP(0x1b, KEY_RIGHTBRACE),
 132         KEYMAP(0x2b, KEY_BACKSLASH),
 133         /* Row-3 */
 134         KEYMAP(0xdb, KEY_LEFTMETA),     /* Search Key */
 135         KEYMAP(0x1e, KEY_A),
 136         KEYMAP(0x1f, KEY_S),
 137         KEYMAP(0x20, KEY_D),
 138         KEYMAP(0x21, KEY_F),
 139         KEYMAP(0x22, KEY_G),
 140         KEYMAP(0x23, KEY_H),
 141         KEYMAP(0x24, KEY_J),
 142         KEYMAP(0x25, KEY_K),
 143         KEYMAP(0x26, KEY_L),
 144         KEYMAP(0x27, KEY_SEMICOLON),
 145         KEYMAP(0x28, KEY_APOSTROPHE),
 146         KEYMAP(0x1c, KEY_ENTER),
 147         /* Row-4 */
 148         KEYMAP(0x2a, KEY_LEFTSHIFT),
 149         KEYMAP(0x56, KEY_102ND),        /* UK keyboards only */
 150         KEYMAP(0x2c, KEY_Z),
 151         KEYMAP(0x2d, KEY_X),
 152         KEYMAP(0x2e, KEY_C),
 153         KEYMAP(0x2f, KEY_V),
 154         KEYMAP(0x30, KEY_B),
 155         KEYMAP(0x31, KEY_N),
 156         KEYMAP(0x32, KEY_M),
 157         KEYMAP(0x33, KEY_COMMA),
 158         KEYMAP(0x34, KEY_DOT),
 159         KEYMAP(0x35, KEY_SLASH),
 160         KEYMAP(0x73, KEY_RO),           /* JP keyboards only */
 161         KEYMAP(0x36, KEY_RIGHTSHIFT),
 162         /* Row-5 */
 163         KEYMAP(0x1d, KEY_LEFTCTRL),
 164         KEYMAP(0x38, KEY_LEFTALT),
 165         KEYMAP(0x7b, KEY_MUHENKAN),     /* JP keyboards only */
 166         KEYMAP(0x39, KEY_SPACE),
 167         KEYMAP(0x79, KEY_HENKAN),       /* JP keyboards only */
 168         KEYMAP(0xb8, KEY_RIGHTALT),
 169         KEYMAP(0x9d, KEY_RIGHTCTRL),
 170         /* Arrow keys */
 171         KEYMAP(0xcb, KEY_LEFT),
 172         KEYMAP(0xd0, KEY_DOWN),
 173         KEYMAP(0xcd, KEY_RIGHT),
 174         KEYMAP(0xc8, KEY_UP),
 175         /* Power Key */
 176         KEYMAP(0xde, KEY_POWER),
 177 };
 178
 179 static void ssdt_generate_physmap(struct acpi_dp *dp, uint8_t num_top_row_keys,
 180                                   enum ps2_action_key action_keys[])
 181 {
 182         struct acpi_dp *dp_array;
 183         enum ps2_action_key key;
 184         uint32_t keymap, i;
 185
 186         dp_array = acpi_dp_new_table("function-row-physmap");
 187         if (!dp_array) {
 188                 printk(BIOS_ERR, "PS2K: couldn't write function-row-physmap\n");
 189                 return;
 190         }
 191
 192         printk(BIOS_INFO, "PS2K: Physmap: [");
 193         for (i = 0; i < num_top_row_keys; i++) {
 194                 key = action_keys[i];
 195                 if (key && key < ARRAY_SIZE(action_keymaps)) {
 196                         keymap = action_keymaps[key];
 197                 } else {
 198                         keymap = 0;
 199                         printk(BIOS_ERR,
 200                                "PS2K: invalid top-action-key-%u: %u(skipped)\n",
 201                                i, key);
 202                 }
 203                 acpi_dp_add_integer(dp_array, NULL, SCANCODE(keymap));
 204                 printk(BIOS_INFO, " %X", SCANCODE(keymap));
 205         }
 206
 207         printk(BIOS_INFO, " ]\n");
 208         acpi_dp_add_array(dp, dp_array);
 209 }
 210
 211 static void ssdt_generate_keymap(struct acpi_dp *dp, uint8_t num_top_row_keys,
 212                                  enum ps2_action_key action_keys[],
 213                                  bool can_send_function_keys,
 214                                  bool has_numeric_keypad,
 215                                  bool has_scrnlock_key,
 216                                  bool has_assistant_key,
 217                                  bool has_alpha_num_punct_keys)
 218 {
 219         struct acpi_dp *dp_array;
 220         enum ps2_action_key key;
 221         uint32_t keymap;
 222         unsigned int i, total = 0;
 223
 224         dp_array = acpi_dp_new_table("linux,keymap");
 225         if (!dp_array) {
 226                 printk(BIOS_ERR, "PS2K: couldn't write linux,keymap\n");
 227                 return;
 228         }
 229
 230         /* Write out keymap for top row action keys */
 231         for (i = 0; i < num_top_row_keys; i++) {
 232                 key = action_keys[i];
 233                 if (!key || key >= ARRAY_SIZE(action_keymaps)) {
 234                         printk(BIOS_ERR,
 235                                "PS2K: invalid top-action-key-%u: %u\n", i, key);
 236                         continue;
 237                 }
 238                 keymap = action_keymaps[key];
 239                 acpi_dp_add_integer(dp_array, NULL, keymap);
 240                 total++;
 241         }
 242
 243         /* Write out keymap for function keys, if keyboard can send them */
 244         if (can_send_function_keys) {
 245                 for (i = 0; i < num_top_row_keys; i++) {
 246                         keymap = function_keymaps[i];
 247                         acpi_dp_add_integer(dp_array, NULL, keymap);
 248                 }
 249
 250                 /* Add the Fn-key */
 251                 if (CONFIG_ACPI_FNKEY_GEN_SCANCODE != 0) {
 252                         acpi_dp_add_integer(dp_array, NULL, KEYMAP(CONFIG_ACPI_FNKEY_GEN_SCANCODE,
 253                                                                    KEY_FN));
 254                         total++;
 255                 }
 256
 257                 total += num_top_row_keys;
 258         }
 259
 260         /* Write out keymap for numeric keypad, if the keyboard has it */
 261         if (has_numeric_keypad) {
 262                 for (i = 0; i < ARRAY_SIZE(numeric_keypad_keymaps); i++) {
 263                         keymap = numeric_keypad_keymaps[i];
 264                         acpi_dp_add_integer(dp_array, NULL, keymap);
 265                 }
 266
 267                 total += ARRAY_SIZE(numeric_keypad_keymaps);
 268         }
 269
 270         /* Provide keymap for screenlock only if it is present */
 271         if (has_scrnlock_key) {
 272                 acpi_dp_add_integer(dp_array, NULL, KEYMAP(0x5d, KEY_SLEEP));
 273                 total++;
 274         }
 275
 276         /* Add the keymap for the assistant key if present */
 277         if (has_assistant_key) {
 278                 acpi_dp_add_integer(dp_array, NULL, KEYMAP(0x5c, KEY_ASSISTANT));
 279                 total++;
 280         }
 281
 282         /* Provide alphanumeric and punctuation keys (rest of the keyboard) if
 283          * present
 284          */
 285         if (has_alpha_num_punct_keys) {
 286                 for (i = 0; i < ARRAY_SIZE(rest_of_keymaps); i++) {
 287                         keymap = rest_of_keymaps[i];
 288                         acpi_dp_add_integer(dp_array, NULL, keymap);
 289                 }
 290
 291                 total += ARRAY_SIZE(rest_of_keymaps);
 292         }
 293
 294         printk(BIOS_INFO, "PS2K: Passing %u keymaps to kernel\n", total);
 295
 296         acpi_dp_add_array(dp, dp_array);
 297 }
 298
 299 void acpigen_ps2_keyboard_dsd(const char *scope, uint8_t num_top_row_keys,
 300                               enum ps2_action_key action_keys[],
 301                               bool can_send_function_keys,
 302                               bool has_numeric_keypad,
 303                               bool has_scrnlock_key,
 304                               bool has_assistant_key,
 305                               bool has_alpha_num_punct_keys)
 306 {
 307         struct acpi_dp *dsd;
 308
 309         if (!scope ||
 310             num_top_row_keys < PS2_MIN_TOP_ROW_KEYS ||
 311             num_top_row_keys > PS2_MAX_TOP_ROW_KEYS) {
 312                 printk(BIOS_ERR, "PS2K: %s: invalid args\n", __func__);
 313                 return;
 314         }
 315
 316         dsd = acpi_dp_new_table("_DSD");
 317         if (!dsd) {
 318                 printk(BIOS_ERR, "PS2K: couldn't write _DSD\n");
 319                 return;
 320         }
 321
 322         acpigen_write_scope(scope);
 323         ssdt_generate_physmap(dsd, num_top_row_keys, action_keys);
 324         ssdt_generate_keymap(dsd, num_top_row_keys, action_keys,
 325                              can_send_function_keys, has_numeric_keypad,
 326                              has_scrnlock_key, has_assistant_key,
 327                              has_alpha_num_punct_keys);
 328         acpi_dp_write(dsd);
 329         acpigen_pop_len(); /* Scope */
 330 }