1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * AT and PS/2 keyboard driver 4 * 5 * Copyright (c) 1999-2002 Vojtech Pavlik 6 * 7 * This driver can handle standard AT keyboards and PS/2 keyboards in 8 * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb 9 * input-only controllers and AT keyboards connected over a one way RS232 10 * converter. 11 */ 12 13 #include <linux/delay.h> 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <linux/interrupt.h> 17 #include <linux/init.h> 18 #include <linux/input.h> 19 #include <linux/input/vivaldi-fmap.h> 20 #include <linux/serio.h> 21 #include <linux/workqueue.h> 22 #include <linux/libps2.h> 23 #include <linux/mutex.h> 24 #include <linux/dmi.h> 25 #include <linux/property.h> 26 27 #define DRIVER_DESC "AT and PS/2 keyboard driver" 28 29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 30 MODULE_DESCRIPTION(DRIVER_DESC); 31 MODULE_LICENSE("GPL"); 32 33 static int atkbd_set = 2; 34 module_param_named(set, atkbd_set, int, 0); 35 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)"); 36 37 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__) || defined(__loongarch__) 38 static bool atkbd_reset; 39 #else 40 static bool atkbd_reset = true; 41 #endif 42 module_param_named(reset, atkbd_reset, bool, 0); 43 MODULE_PARM_DESC(reset, "Reset keyboard during initialization"); 44 45 static bool atkbd_softrepeat; 46 module_param_named(softrepeat, atkbd_softrepeat, bool, 0); 47 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat"); 48 49 static bool atkbd_softraw = true; 50 module_param_named(softraw, atkbd_softraw, bool, 0); 51 MODULE_PARM_DESC(softraw, "Use software generated rawmode"); 52 53 static bool atkbd_scroll; 54 module_param_named(scroll, atkbd_scroll, bool, 0); 55 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards"); 56 57 static bool atkbd_extra; 58 module_param_named(extra, atkbd_extra, bool, 0); 59 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards"); 60 61 static bool atkbd_terminal; 62 module_param_named(terminal, atkbd_terminal, bool, 0); 63 MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2"); 64 65 #define SCANCODE(keymap) (((keymap) >> 16) & 0xFFFF) 66 #define KEYCODE(keymap) ((keymap) & 0xFFFF) 67 68 /* 69 * Scancode to keycode tables. These are just the default setting, and 70 * are loadable via a userland utility. 71 */ 72 73 #define ATKBD_KEYMAP_SIZE 512 74 75 static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = { 76 0, 67, 65, 63, 61, 59, 60, 88,183, 68, 66, 64, 62, 15, 41,117, 77 184, 56, 42, 93, 29, 16, 2, 0,185, 0, 44, 31, 30, 17, 3, 0, 78 186, 46, 45, 32, 18, 5, 4, 95,187, 57, 47, 33, 20, 19, 6,183, 79 188, 49, 48, 35, 34, 21, 7,184,189, 0, 50, 36, 22, 8, 9,185, 80 190, 51, 37, 23, 24, 11, 10, 0,191, 52, 53, 38, 39, 25, 12, 0, 81 192, 89, 40, 0, 26, 13, 0,193, 58, 54, 28, 27, 0, 43, 0,194, 82 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0, 83 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99, 84 85 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 86 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125, 87 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127, 88 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142, 89 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0, 90 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0, 91 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112, 92 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0, 93 94 0, 0, 0, 65, 99, 95 }; 96 97 static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = { 98 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60, 99 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62, 100 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64, 101 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66, 102 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68, 103 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70, 104 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104, 105 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183, 106 107 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0, 108 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168, 109 148,149,147,140 110 }; 111 112 static const u8 atkbd_unxlate_table[128] = { 113 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13, 114 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27, 115 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42, 116 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3, 117 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105, 118 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63, 119 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111, 120 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110 121 }; 122 123 #define ATKBD_CMD_SETLEDS 0x10ed 124 #define ATKBD_CMD_GSCANSET 0x11f0 125 #define ATKBD_CMD_SSCANSET 0x10f0 126 #define ATKBD_CMD_GETID 0x02f2 127 #define ATKBD_CMD_SETREP 0x10f3 128 #define ATKBD_CMD_ENABLE 0x00f4 129 #define ATKBD_CMD_RESET_DIS 0x00f5 /* Reset to defaults and disable */ 130 #define ATKBD_CMD_RESET_DEF 0x00f6 /* Reset to defaults */ 131 #define ATKBD_CMD_SETALL_MB 0x00f8 /* Set all keys to give break codes */ 132 #define ATKBD_CMD_SETALL_MBR 0x00fa /* ... and repeat */ 133 #define ATKBD_CMD_RESET_BAT 0x02ff 134 #define ATKBD_CMD_RESEND 0x00fe 135 #define ATKBD_CMD_EX_ENABLE 0x10ea 136 #define ATKBD_CMD_EX_SETLEDS 0x20eb 137 #define ATKBD_CMD_OK_GETID 0x02e8 138 139 #define ATKBD_RET_ACK 0xfa 140 #define ATKBD_RET_NAK 0xfe 141 #define ATKBD_RET_BAT 0xaa 142 #define ATKBD_RET_EMUL0 0xe0 143 #define ATKBD_RET_EMUL1 0xe1 144 #define ATKBD_RET_RELEASE 0xf0 145 #define ATKBD_RET_HANJA 0xf1 146 #define ATKBD_RET_HANGEUL 0xf2 147 #define ATKBD_RET_ERR 0xff 148 149 #define ATKBD_KEY_UNKNOWN 0 150 #define ATKBD_KEY_NULL 255 151 152 #define ATKBD_SCR_1 0xfffe 153 #define ATKBD_SCR_2 0xfffd 154 #define ATKBD_SCR_4 0xfffc 155 #define ATKBD_SCR_8 0xfffb 156 #define ATKBD_SCR_CLICK 0xfffa 157 #define ATKBD_SCR_LEFT 0xfff9 158 #define ATKBD_SCR_RIGHT 0xfff8 159 160 #define ATKBD_SPECIAL ATKBD_SCR_RIGHT 161 162 #define ATKBD_LED_EVENT_BIT 0 163 #define ATKBD_REP_EVENT_BIT 1 164 165 #define ATKBD_XL_ERR 0x01 166 #define ATKBD_XL_BAT 0x02 167 #define ATKBD_XL_ACK 0x04 168 #define ATKBD_XL_NAK 0x08 169 #define ATKBD_XL_HANGEUL 0x10 170 #define ATKBD_XL_HANJA 0x20 171 172 static const struct { 173 unsigned short keycode; 174 u8 set2; 175 } atkbd_scroll_keys[] = { 176 { ATKBD_SCR_1, 0xc5 }, 177 { ATKBD_SCR_2, 0x9d }, 178 { ATKBD_SCR_4, 0xa4 }, 179 { ATKBD_SCR_8, 0x9b }, 180 { ATKBD_SCR_CLICK, 0xe0 }, 181 { ATKBD_SCR_LEFT, 0xcb }, 182 { ATKBD_SCR_RIGHT, 0xd2 }, 183 }; 184 185 /* 186 * The atkbd control structure 187 */ 188 189 struct atkbd { 190 struct ps2dev ps2dev; 191 struct input_dev *dev; 192 193 /* Written only during init */ 194 char name[64]; 195 char phys[32]; 196 197 unsigned short id; 198 unsigned short keycode[ATKBD_KEYMAP_SIZE]; 199 DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE); 200 u8 set; 201 bool translated; 202 bool extra; 203 bool write; 204 bool softrepeat; 205 bool softraw; 206 bool scroll; 207 bool enabled; 208 209 /* Accessed only from interrupt */ 210 u8 emul; 211 bool resend; 212 bool release; 213 unsigned long xl_bit; 214 unsigned int last; 215 unsigned long time; 216 unsigned long err_count; 217 218 struct delayed_work event_work; 219 unsigned long event_jiffies; 220 unsigned long event_mask; 221 222 /* Serializes reconnect(), attr->set() and event work */ 223 struct mutex mutex; 224 225 struct vivaldi_data vdata; 226 }; 227 228 /* 229 * System-specific keymap fixup routine 230 */ 231 static void (*atkbd_platform_fixup)(struct atkbd *, const void *data); 232 static void *atkbd_platform_fixup_data; 233 static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int); 234 235 /* 236 * Certain keyboards to not like ATKBD_CMD_RESET_DIS and stop responding 237 * to many commands until full reset (ATKBD_CMD_RESET_BAT) is performed. 238 */ 239 static bool atkbd_skip_deactivate; 240 241 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 242 ssize_t (*handler)(struct atkbd *, char *)); 243 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 244 ssize_t (*handler)(struct atkbd *, const char *, size_t)); 245 #define ATKBD_DEFINE_ATTR(_name) \ 246 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 247 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \ 248 static ssize_t atkbd_do_show_##_name(struct device *d, \ 249 struct device_attribute *attr, char *b) \ 250 { \ 251 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 252 } \ 253 static ssize_t atkbd_do_set_##_name(struct device *d, \ 254 struct device_attribute *attr, const char *b, size_t s) \ 255 { \ 256 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \ 257 } \ 258 static struct device_attribute atkbd_attr_##_name = \ 259 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name) 260 261 ATKBD_DEFINE_ATTR(extra); 262 ATKBD_DEFINE_ATTR(force_release); 263 ATKBD_DEFINE_ATTR(scroll); 264 ATKBD_DEFINE_ATTR(set); 265 ATKBD_DEFINE_ATTR(softrepeat); 266 ATKBD_DEFINE_ATTR(softraw); 267 268 #define ATKBD_DEFINE_RO_ATTR(_name) \ 269 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 270 static ssize_t atkbd_do_show_##_name(struct device *d, \ 271 struct device_attribute *attr, char *b) \ 272 { \ 273 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 274 } \ 275 static struct device_attribute atkbd_attr_##_name = \ 276 __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL) 277 278 ATKBD_DEFINE_RO_ATTR(err_count); 279 ATKBD_DEFINE_RO_ATTR(function_row_physmap); 280 281 static struct attribute *atkbd_attributes[] = { 282 &atkbd_attr_extra.attr, 283 &atkbd_attr_force_release.attr, 284 &atkbd_attr_scroll.attr, 285 &atkbd_attr_set.attr, 286 &atkbd_attr_softrepeat.attr, 287 &atkbd_attr_softraw.attr, 288 &atkbd_attr_err_count.attr, 289 &atkbd_attr_function_row_physmap.attr, 290 NULL 291 }; 292 293 static ssize_t atkbd_show_function_row_physmap(struct atkbd *atkbd, char *buf) 294 { 295 return vivaldi_function_row_physmap_show(&atkbd->vdata, buf); 296 } 297 298 static struct atkbd *atkbd_from_serio(struct serio *serio) 299 { 300 struct ps2dev *ps2dev = serio_get_drvdata(serio); 301 302 return container_of(ps2dev, struct atkbd, ps2dev); 303 } 304 305 static umode_t atkbd_attr_is_visible(struct kobject *kobj, 306 struct attribute *attr, int i) 307 { 308 struct device *dev = kobj_to_dev(kobj); 309 struct serio *serio = to_serio_port(dev); 310 struct atkbd *atkbd = atkbd_from_serio(serio); 311 312 if (attr == &atkbd_attr_function_row_physmap.attr && 313 !atkbd->vdata.num_function_row_keys) 314 return 0; 315 316 return attr->mode; 317 } 318 319 static const struct attribute_group atkbd_attribute_group = { 320 .attrs = atkbd_attributes, 321 .is_visible = atkbd_attr_is_visible, 322 }; 323 324 __ATTRIBUTE_GROUPS(atkbd_attribute); 325 326 static const u8 xl_table[] = { 327 ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK, 328 ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL, 329 }; 330 331 /* 332 * Checks if we should mangle the scancode to extract 'release' bit 333 * in translated mode. 334 */ 335 static bool atkbd_need_xlate(unsigned long xl_bit, u8 code) 336 { 337 int i; 338 339 if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1) 340 return false; 341 342 for (i = 0; i < ARRAY_SIZE(xl_table); i++) 343 if (code == xl_table[i]) 344 return test_bit(i, &xl_bit); 345 346 return true; 347 } 348 349 /* 350 * Calculates new value of xl_bit so the driver can distinguish 351 * between make/break pair of scancodes for select keys and PS/2 352 * protocol responses. 353 */ 354 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, u8 code) 355 { 356 int i; 357 358 for (i = 0; i < ARRAY_SIZE(xl_table); i++) { 359 if (!((code ^ xl_table[i]) & 0x7f)) { 360 __assign_bit(i, &atkbd->xl_bit, !(code & 0x80)); 361 break; 362 } 363 } 364 } 365 366 /* 367 * Encode the scancode, 0xe0 prefix, and high bit into a single integer, 368 * keeping kernel 2.4 compatibility for set 2 369 */ 370 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code) 371 { 372 if (atkbd->set == 3) { 373 if (atkbd->emul == 1) 374 code |= 0x100; 375 } else { 376 code = (code & 0x7f) | ((code & 0x80) << 1); 377 if (atkbd->emul == 1) 378 code |= 0x80; 379 } 380 381 return code; 382 } 383 384 /* 385 * Tries to handle frame or parity error by requesting the keyboard controller 386 * to resend the last byte. This historically not done on x86 as controllers 387 * there typically do not implement this command. 388 */ 389 static bool __maybe_unused atkbd_handle_frame_error(struct ps2dev *ps2dev, 390 u8 data, unsigned int flags) 391 { 392 struct atkbd *atkbd = container_of(ps2dev, struct atkbd, ps2dev); 393 struct serio *serio = ps2dev->serio; 394 395 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && 396 (~flags & SERIO_TIMEOUT) && 397 !atkbd->resend && atkbd->write) { 398 dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags); 399 serio_write(serio, ATKBD_CMD_RESEND); 400 atkbd->resend = true; 401 return true; 402 } 403 404 if (!flags && data == ATKBD_RET_ACK) 405 atkbd->resend = false; 406 407 return false; 408 } 409 410 static enum ps2_disposition atkbd_pre_receive_byte(struct ps2dev *ps2dev, 411 u8 data, unsigned int flags) 412 { 413 struct serio *serio = ps2dev->serio; 414 415 dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags); 416 417 #if !defined(__i386__) && !defined(__x86_64__) 418 if (atkbd_handle_frame_error(ps2dev, data, flags)) 419 return PS2_IGNORE; 420 #endif 421 422 return PS2_PROCESS; 423 } 424 425 static void atkbd_receive_byte(struct ps2dev *ps2dev, u8 data) 426 { 427 struct serio *serio = ps2dev->serio; 428 struct atkbd *atkbd = container_of(ps2dev, struct atkbd, ps2dev); 429 struct input_dev *dev = atkbd->dev; 430 unsigned int code = data; 431 int scroll = 0, hscroll = 0, click = -1; 432 int value; 433 unsigned short keycode; 434 435 pm_wakeup_event(&serio->dev, 0); 436 437 if (!atkbd->enabled) 438 return; 439 440 input_event(dev, EV_MSC, MSC_RAW, code); 441 442 if (atkbd_platform_scancode_fixup) 443 code = atkbd_platform_scancode_fixup(atkbd, code); 444 445 if (atkbd->translated) { 446 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) { 447 atkbd->release = code >> 7; 448 code &= 0x7f; 449 } 450 451 if (!atkbd->emul) 452 atkbd_calculate_xl_bit(atkbd, data); 453 } 454 455 switch (code) { 456 case ATKBD_RET_BAT: 457 atkbd->enabled = false; 458 serio_reconnect(atkbd->ps2dev.serio); 459 return; 460 case ATKBD_RET_EMUL0: 461 atkbd->emul = 1; 462 return; 463 case ATKBD_RET_EMUL1: 464 atkbd->emul = 2; 465 return; 466 case ATKBD_RET_RELEASE: 467 atkbd->release = true; 468 return; 469 case ATKBD_RET_ACK: 470 case ATKBD_RET_NAK: 471 dev_warn_ratelimited(&serio->dev, 472 "Spurious %s on %s. Some program might be trying to access hardware directly.\n", 473 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys); 474 return; 475 case ATKBD_RET_ERR: 476 atkbd->err_count++; 477 dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n", 478 serio->phys); 479 return; 480 } 481 482 code = atkbd_compat_scancode(atkbd, code); 483 484 if (atkbd->emul && --atkbd->emul) 485 return; 486 487 keycode = atkbd->keycode[code]; 488 489 if (!(atkbd->release && test_bit(code, atkbd->force_release_mask))) 490 if (keycode != ATKBD_KEY_NULL) 491 input_event(dev, EV_MSC, MSC_SCAN, code); 492 493 switch (keycode) { 494 case ATKBD_KEY_NULL: 495 break; 496 case ATKBD_KEY_UNKNOWN: 497 dev_warn(&serio->dev, 498 "Unknown key %s (%s set %d, code %#x on %s).\n", 499 atkbd->release ? "released" : "pressed", 500 atkbd->translated ? "translated" : "raw", 501 atkbd->set, code, serio->phys); 502 dev_warn(&serio->dev, 503 "Use 'setkeycodes %s%02x <keycode>' to make it known.\n", 504 code & 0x80 ? "e0" : "", code & 0x7f); 505 input_sync(dev); 506 break; 507 case ATKBD_SCR_1: 508 scroll = 1; 509 break; 510 case ATKBD_SCR_2: 511 scroll = 2; 512 break; 513 case ATKBD_SCR_4: 514 scroll = 4; 515 break; 516 case ATKBD_SCR_8: 517 scroll = 8; 518 break; 519 case ATKBD_SCR_CLICK: 520 click = !atkbd->release; 521 break; 522 case ATKBD_SCR_LEFT: 523 hscroll = -1; 524 break; 525 case ATKBD_SCR_RIGHT: 526 hscroll = 1; 527 break; 528 default: 529 if (atkbd->release) { 530 value = 0; 531 atkbd->last = 0; 532 } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) { 533 /* Workaround Toshiba laptop multiple keypress */ 534 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2; 535 } else { 536 value = 1; 537 atkbd->last = code; 538 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2; 539 } 540 541 input_event(dev, EV_KEY, keycode, value); 542 input_sync(dev); 543 544 if (value && test_bit(code, atkbd->force_release_mask)) { 545 input_event(dev, EV_MSC, MSC_SCAN, code); 546 input_report_key(dev, keycode, 0); 547 input_sync(dev); 548 } 549 } 550 551 if (atkbd->scroll) { 552 if (click != -1) 553 input_report_key(dev, BTN_MIDDLE, click); 554 input_report_rel(dev, REL_WHEEL, 555 atkbd->release ? -scroll : scroll); 556 input_report_rel(dev, REL_HWHEEL, hscroll); 557 input_sync(dev); 558 } 559 560 atkbd->release = false; 561 } 562 563 static int atkbd_set_repeat_rate(struct atkbd *atkbd) 564 { 565 const short period[32] = { 566 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125, 567 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 568 }; 569 const short delay[4] = { 250, 500, 750, 1000 }; 570 571 struct input_dev *dev = atkbd->dev; 572 u8 param; 573 int i = 0, j = 0; 574 575 while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD]) 576 i++; 577 dev->rep[REP_PERIOD] = period[i]; 578 579 while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY]) 580 j++; 581 dev->rep[REP_DELAY] = delay[j]; 582 583 param = i | (j << 5); 584 return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP); 585 } 586 587 static int atkbd_set_leds(struct atkbd *atkbd) 588 { 589 struct input_dev *dev = atkbd->dev; 590 u8 param[2]; 591 592 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0) 593 | (test_bit(LED_NUML, dev->led) ? 2 : 0) 594 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0); 595 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS)) 596 return -1; 597 598 if (atkbd->extra) { 599 param[0] = 0; 600 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0) 601 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0) 602 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0) 603 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0) 604 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0); 605 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS)) 606 return -1; 607 } 608 609 return 0; 610 } 611 612 /* 613 * atkbd_event_work() is used to complete processing of events that 614 * can not be processed by input_event() which is often called from 615 * interrupt context. 616 */ 617 618 static void atkbd_event_work(struct work_struct *work) 619 { 620 struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work); 621 622 guard(mutex)(&atkbd->mutex); 623 624 if (!atkbd->enabled) { 625 /* 626 * Serio ports are resumed asynchronously so while driver core 627 * thinks that device is already fully operational in reality 628 * it may not be ready yet. In this case we need to keep 629 * rescheduling till reconnect completes. 630 */ 631 schedule_delayed_work(&atkbd->event_work, msecs_to_jiffies(100)); 632 } else { 633 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask)) 634 atkbd_set_leds(atkbd); 635 636 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask)) 637 atkbd_set_repeat_rate(atkbd); 638 } 639 } 640 641 /* 642 * Schedule switch for execution. We need to throttle requests, 643 * otherwise keyboard may become unresponsive. 644 */ 645 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit) 646 { 647 unsigned long delay = msecs_to_jiffies(50); 648 649 if (time_after(jiffies, atkbd->event_jiffies + delay)) 650 delay = 0; 651 652 atkbd->event_jiffies = jiffies; 653 set_bit(event_bit, &atkbd->event_mask); 654 mb(); 655 schedule_delayed_work(&atkbd->event_work, delay); 656 } 657 658 /* 659 * Event callback from the input module. Events that change the state of 660 * the hardware are processed here. If action can not be performed in 661 * interrupt context it is offloaded to atkbd_event_work. 662 */ 663 664 static int atkbd_event(struct input_dev *dev, 665 unsigned int type, unsigned int code, int value) 666 { 667 struct atkbd *atkbd = input_get_drvdata(dev); 668 669 if (!atkbd->write) 670 return -1; 671 672 switch (type) { 673 case EV_LED: 674 atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT); 675 return 0; 676 677 case EV_REP: 678 if (!atkbd->softrepeat) 679 atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT); 680 return 0; 681 682 default: 683 return -1; 684 } 685 } 686 687 /* 688 * atkbd_enable() signals that interrupt handler is allowed to 689 * generate input events. 690 */ 691 692 static inline void atkbd_enable(struct atkbd *atkbd) 693 { 694 guard(serio_pause_rx)(atkbd->ps2dev.serio); 695 696 atkbd->enabled = true; 697 } 698 699 /* 700 * atkbd_disable() tells input handler that all incoming data except 701 * for ACKs and command response should be dropped. 702 */ 703 704 static inline void atkbd_disable(struct atkbd *atkbd) 705 { 706 guard(serio_pause_rx)(atkbd->ps2dev.serio); 707 708 atkbd->enabled = false; 709 } 710 711 static int atkbd_activate(struct atkbd *atkbd) 712 { 713 struct ps2dev *ps2dev = &atkbd->ps2dev; 714 715 /* 716 * Enable the keyboard to receive keystrokes. 717 */ 718 719 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) { 720 dev_err(&ps2dev->serio->dev, 721 "Failed to enable keyboard on %s\n", 722 ps2dev->serio->phys); 723 return -1; 724 } 725 726 return 0; 727 } 728 729 /* 730 * atkbd_deactivate() resets and disables the keyboard from sending 731 * keystrokes. 732 */ 733 734 static void atkbd_deactivate(struct atkbd *atkbd) 735 { 736 struct ps2dev *ps2dev = &atkbd->ps2dev; 737 738 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS)) 739 dev_err(&ps2dev->serio->dev, 740 "Failed to deactivate keyboard on %s\n", 741 ps2dev->serio->phys); 742 } 743 744 #ifdef CONFIG_X86 745 static bool atkbd_is_portable_device(void) 746 { 747 static const char * const chassis_types[] = { 748 "8", /* Portable */ 749 "9", /* Laptop */ 750 "10", /* Notebook */ 751 "14", /* Sub-Notebook */ 752 "31", /* Convertible */ 753 "32", /* Detachable */ 754 }; 755 int i; 756 757 for (i = 0; i < ARRAY_SIZE(chassis_types); i++) 758 if (dmi_match(DMI_CHASSIS_TYPE, chassis_types[i])) 759 return true; 760 761 return false; 762 } 763 764 /* 765 * On many modern laptops ATKBD_CMD_GETID may cause problems, on these laptops 766 * the controller is always in translated mode. In this mode mice/touchpads will 767 * not work. So in this case simply assume a keyboard is connected to avoid 768 * confusing some laptop keyboards. 769 * 770 * Skipping ATKBD_CMD_GETID ends up using a fake keyboard id. Using the standard 771 * 0xab83 id is ok in translated mode, only atkbd_select_set() checks atkbd->id 772 * and in translated mode that is a no-op. 773 */ 774 static bool atkbd_skip_getid(struct atkbd *atkbd) 775 { 776 return atkbd->translated && atkbd_is_portable_device(); 777 } 778 #else 779 static inline bool atkbd_skip_getid(struct atkbd *atkbd) { return false; } 780 #endif 781 782 /* 783 * atkbd_probe() probes for an AT keyboard on a serio port. 784 */ 785 786 static int atkbd_probe(struct atkbd *atkbd) 787 { 788 struct ps2dev *ps2dev = &atkbd->ps2dev; 789 u8 param[2]; 790 791 /* 792 * Some systems, where the bit-twiddling when testing the io-lines of the 793 * controller may confuse the keyboard need a full reset of the keyboard. On 794 * these systems the BIOS also usually doesn't do it for us. 795 */ 796 797 if (atkbd_reset) 798 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT)) 799 dev_warn(&ps2dev->serio->dev, 800 "keyboard reset failed on %s\n", 801 ps2dev->serio->phys); 802 803 if (atkbd_skip_getid(atkbd)) { 804 atkbd->id = 0xab83; 805 goto deactivate_kbd; 806 } 807 808 /* 809 * Then we check the keyboard ID. We should get 0xab83 under normal conditions. 810 * Some keyboards report different values, but the first byte is always 0xab or 811 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this 812 * should make sure we don't try to set the LEDs on it. 813 */ 814 815 param[0] = param[1] = 0xa5; /* initialize with invalid values */ 816 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) { 817 /* 818 * If the get ID command failed, we check if we can at least set 819 * the LEDs on the keyboard. This should work on every keyboard out there. 820 * It also turns the LEDs off, which we want anyway. 821 */ 822 param[0] = 0; 823 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 824 return -1; 825 atkbd->id = 0xabba; 826 return 0; 827 } 828 829 if (!ps2_is_keyboard_id(param[0])) 830 return -1; 831 832 atkbd->id = (param[0] << 8) | param[1]; 833 834 if (atkbd->id == 0xaca1 && atkbd->translated) { 835 dev_err(&ps2dev->serio->dev, 836 "NCD terminal keyboards are only supported on non-translating controllers. Use i8042.direct=1 to disable translation.\n"); 837 return -1; 838 } 839 840 deactivate_kbd: 841 /* 842 * Make sure nothing is coming from the keyboard and disturbs our 843 * internal state. 844 */ 845 if (!atkbd_skip_deactivate) 846 atkbd_deactivate(atkbd); 847 848 return 0; 849 } 850 851 /* 852 * atkbd_select_set checks if a keyboard has a working Set 3 support, and 853 * sets it into that. Unfortunately there are keyboards that can be switched 854 * to Set 3, but don't work well in that (BTC Multimedia ...) 855 */ 856 857 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra) 858 { 859 struct ps2dev *ps2dev = &atkbd->ps2dev; 860 u8 param[2]; 861 862 atkbd->extra = false; 863 /* 864 * For known special keyboards we can go ahead and set the correct set. 865 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and 866 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards. 867 */ 868 869 if (atkbd->translated) 870 return 2; 871 872 if (atkbd->id == 0xaca1) { 873 param[0] = 3; 874 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET); 875 return 3; 876 } 877 878 if (allow_extra) { 879 param[0] = 0x71; 880 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) { 881 atkbd->extra = true; 882 return 2; 883 } 884 } 885 886 if (atkbd_terminal) { 887 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB); 888 return 3; 889 } 890 891 if (target_set != 3) 892 return 2; 893 894 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) { 895 atkbd->id = param[0] << 8 | param[1]; 896 return 2; 897 } 898 899 param[0] = 3; 900 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 901 return 2; 902 903 param[0] = 0; 904 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET)) 905 return 2; 906 907 if (param[0] != 3) { 908 param[0] = 2; 909 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 910 return 2; 911 } 912 913 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR); 914 915 return 3; 916 } 917 918 static int atkbd_reset_state(struct atkbd *atkbd) 919 { 920 struct ps2dev *ps2dev = &atkbd->ps2dev; 921 u8 param[1]; 922 923 /* 924 * Set the LEDs to a predefined state (all off). 925 */ 926 927 param[0] = 0; 928 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 929 return -1; 930 931 /* 932 * Set autorepeat to fastest possible. 933 */ 934 935 param[0] = 0; 936 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP)) 937 return -1; 938 939 return 0; 940 } 941 942 /* 943 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a 944 * reboot. 945 */ 946 static void atkbd_cleanup(struct serio *serio) 947 { 948 struct atkbd *atkbd = atkbd_from_serio(serio); 949 950 atkbd_disable(atkbd); 951 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF); 952 } 953 954 /* 955 * atkbd_disconnect() closes and frees. 956 */ 957 static void atkbd_disconnect(struct serio *serio) 958 { 959 struct atkbd *atkbd = atkbd_from_serio(serio); 960 961 atkbd_disable(atkbd); 962 963 input_unregister_device(atkbd->dev); 964 965 /* 966 * Make sure we don't have a command in flight. 967 * Note that since atkbd->enabled is false event work will keep 968 * rescheduling itself until it gets canceled and will not try 969 * accessing freed input device or serio port. 970 */ 971 cancel_delayed_work_sync(&atkbd->event_work); 972 973 serio_close(serio); 974 serio_set_drvdata(serio, NULL); 975 kfree(atkbd); 976 } 977 978 /* 979 * generate release events for the keycodes given in data 980 */ 981 static void atkbd_apply_forced_release_keylist(struct atkbd *atkbd, const void *data) 982 { 983 const unsigned int *keys = data; 984 unsigned int i; 985 986 if (atkbd->set == 2) 987 for (i = 0; keys[i] != -1U; i++) 988 __set_bit(keys[i], atkbd->force_release_mask); 989 } 990 991 /* 992 * Most special keys (Fn+F?) on Dell laptops do not generate release 993 * events so we have to do it ourselves. 994 */ 995 static unsigned int atkbd_dell_laptop_forced_release_keys[] = { 996 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U 997 }; 998 999 /* 1000 * Perform fixup for HP system that doesn't generate release 1001 * for its video switch 1002 */ 1003 static unsigned int atkbd_hp_forced_release_keys[] = { 1004 0x94, -1U 1005 }; 1006 1007 /* 1008 * Samsung NC10,NC20 with Fn+F? key release not working 1009 */ 1010 static unsigned int atkbd_samsung_forced_release_keys[] = { 1011 0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U 1012 }; 1013 1014 /* 1015 * Amilo Pi 3525 key release for Fn+Volume keys not working 1016 */ 1017 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = { 1018 0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U 1019 }; 1020 1021 /* 1022 * Amilo Xi 3650 key release for light touch bar not working 1023 */ 1024 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = { 1025 0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U 1026 }; 1027 1028 /* 1029 * Soltech TA12 system with broken key release on volume keys and mute key 1030 */ 1031 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = { 1032 0xa0, 0xae, 0xb0, -1U 1033 }; 1034 1035 /* 1036 * Many notebooks don't send key release event for volume up/down 1037 * keys, with key list below common among them 1038 */ 1039 static unsigned int atkbd_volume_forced_release_keys[] = { 1040 0xae, 0xb0, -1U 1041 }; 1042 1043 /* 1044 * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas 1045 * they should be generating e4-e6 (0x80 | code). 1046 */ 1047 static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd, 1048 unsigned int code) 1049 { 1050 if (atkbd->translated && atkbd->emul == 1 && 1051 (code == 0x64 || code == 0x65 || code == 0x66)) { 1052 atkbd->emul = 0; 1053 code |= 0x80; 1054 } 1055 1056 return code; 1057 } 1058 1059 static int atkbd_get_keymap_from_fwnode(struct atkbd *atkbd) 1060 { 1061 struct device *dev = &atkbd->ps2dev.serio->dev; 1062 int i, n; 1063 u16 scancode, keycode; 1064 1065 /* Parse "linux,keymap" property */ 1066 n = device_property_count_u32(dev, "linux,keymap"); 1067 if (n <= 0 || n > ATKBD_KEYMAP_SIZE) 1068 return -ENXIO; 1069 1070 u32 *ptr __free(kfree) = kzalloc_objs(*ptr, n); 1071 if (!ptr) 1072 return -ENOMEM; 1073 1074 if (device_property_read_u32_array(dev, "linux,keymap", ptr, n)) { 1075 dev_err(dev, "problem parsing FW keymap property\n"); 1076 return -EINVAL; 1077 } 1078 1079 memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 1080 for (i = 0; i < n; i++) { 1081 scancode = SCANCODE(ptr[i]); 1082 keycode = KEYCODE(ptr[i]); 1083 if (scancode >= ATKBD_KEYMAP_SIZE) { 1084 dev_warn(dev, "invalid scancode %#x in FW keymap entry %d\n", 1085 scancode, i); 1086 return -EINVAL; 1087 } 1088 atkbd->keycode[scancode] = keycode; 1089 } 1090 1091 return 0; 1092 } 1093 1094 /* 1095 * atkbd_set_keycode_table() initializes keyboard's keycode table 1096 * according to the selected scancode set 1097 */ 1098 1099 static void atkbd_set_keycode_table(struct atkbd *atkbd) 1100 { 1101 struct device *dev = &atkbd->ps2dev.serio->dev; 1102 unsigned int scancode; 1103 int i, j; 1104 1105 memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 1106 bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE); 1107 1108 if (!atkbd_get_keymap_from_fwnode(atkbd)) { 1109 dev_dbg(dev, "Using FW keymap\n"); 1110 } else if (atkbd->translated) { 1111 for (i = 0; i < 128; i++) { 1112 scancode = atkbd_unxlate_table[i]; 1113 atkbd->keycode[i] = atkbd_set2_keycode[scancode]; 1114 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80]; 1115 if (atkbd->scroll) 1116 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++) 1117 if ((scancode | 0x80) == atkbd_scroll_keys[j].set2) 1118 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode; 1119 } 1120 } else if (atkbd->set == 3) { 1121 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode)); 1122 } else { 1123 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode)); 1124 1125 if (atkbd->scroll) 1126 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) { 1127 scancode = atkbd_scroll_keys[i].set2; 1128 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode; 1129 } 1130 } 1131 1132 /* 1133 * HANGEUL and HANJA keys do not send release events so we need to 1134 * generate such events ourselves 1135 */ 1136 scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL); 1137 atkbd->keycode[scancode] = KEY_HANGEUL; 1138 __set_bit(scancode, atkbd->force_release_mask); 1139 1140 scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA); 1141 atkbd->keycode[scancode] = KEY_HANJA; 1142 __set_bit(scancode, atkbd->force_release_mask); 1143 1144 /* 1145 * Perform additional fixups 1146 */ 1147 if (atkbd_platform_fixup) 1148 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data); 1149 } 1150 1151 /* 1152 * atkbd_set_device_attrs() sets up keyboard's input device structure 1153 */ 1154 1155 static void atkbd_set_device_attrs(struct atkbd *atkbd) 1156 { 1157 struct input_dev *input_dev = atkbd->dev; 1158 int i; 1159 1160 if (atkbd->extra) 1161 snprintf(atkbd->name, sizeof(atkbd->name), 1162 "AT Set 2 Extra keyboard"); 1163 else 1164 snprintf(atkbd->name, sizeof(atkbd->name), 1165 "AT %s Set %d keyboard", 1166 atkbd->translated ? "Translated" : "Raw", atkbd->set); 1167 1168 scnprintf(atkbd->phys, sizeof(atkbd->phys), 1169 "%s/input0", atkbd->ps2dev.serio->phys); 1170 1171 input_dev->name = atkbd->name; 1172 input_dev->phys = atkbd->phys; 1173 input_dev->id.bustype = BUS_I8042; 1174 input_dev->id.vendor = 0x0001; 1175 input_dev->id.product = atkbd->translated ? 1 : atkbd->set; 1176 input_dev->id.version = atkbd->id; 1177 input_dev->event = atkbd_event; 1178 input_dev->dev.parent = &atkbd->ps2dev.serio->dev; 1179 1180 input_set_drvdata(input_dev, atkbd); 1181 1182 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | 1183 BIT_MASK(EV_MSC); 1184 1185 if (atkbd->write) { 1186 input_dev->evbit[0] |= BIT_MASK(EV_LED); 1187 input_dev->ledbit[0] = BIT_MASK(LED_NUML) | 1188 BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL); 1189 } 1190 1191 if (atkbd->extra) 1192 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) | 1193 BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) | 1194 BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC); 1195 1196 if (!atkbd->softrepeat) { 1197 input_dev->rep[REP_DELAY] = 250; 1198 input_dev->rep[REP_PERIOD] = 33; 1199 } 1200 1201 input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) : 1202 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN); 1203 1204 if (atkbd->scroll) { 1205 input_dev->evbit[0] |= BIT_MASK(EV_REL); 1206 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) | 1207 BIT_MASK(REL_HWHEEL); 1208 __set_bit(BTN_MIDDLE, input_dev->keybit); 1209 } 1210 1211 input_dev->keycode = atkbd->keycode; 1212 input_dev->keycodesize = sizeof(atkbd->keycode[0]); 1213 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode); 1214 1215 for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) { 1216 if (atkbd->keycode[i] != KEY_RESERVED && 1217 atkbd->keycode[i] != ATKBD_KEY_NULL && 1218 atkbd->keycode[i] < ATKBD_SPECIAL) { 1219 __set_bit(atkbd->keycode[i], input_dev->keybit); 1220 } 1221 } 1222 } 1223 1224 static void atkbd_parse_fwnode_data(struct serio *serio) 1225 { 1226 struct atkbd *atkbd = atkbd_from_serio(serio); 1227 struct device *dev = &serio->dev; 1228 int n; 1229 1230 /* Parse "function-row-physmap" property */ 1231 n = device_property_count_u32(dev, "function-row-physmap"); 1232 if (n > 0 && n <= VIVALDI_MAX_FUNCTION_ROW_KEYS && 1233 !device_property_read_u32_array(dev, "function-row-physmap", 1234 atkbd->vdata.function_row_physmap, 1235 n)) { 1236 atkbd->vdata.num_function_row_keys = n; 1237 dev_dbg(dev, "FW reported %d function-row key locations\n", n); 1238 } 1239 } 1240 1241 /* 1242 * atkbd_connect() is called when the serio module finds an interface 1243 * that isn't handled yet by an appropriate device driver. We check if 1244 * there is an AT keyboard out there and if yes, we register ourselves 1245 * to the input module. 1246 */ 1247 1248 static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 1249 { 1250 struct atkbd *atkbd; 1251 struct input_dev *dev; 1252 int err = -ENOMEM; 1253 1254 atkbd = kzalloc_obj(*atkbd); 1255 dev = input_allocate_device(); 1256 if (!atkbd || !dev) 1257 goto fail1; 1258 1259 atkbd->dev = dev; 1260 ps2_init(&atkbd->ps2dev, serio, 1261 atkbd_pre_receive_byte, atkbd_receive_byte); 1262 INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work); 1263 mutex_init(&atkbd->mutex); 1264 1265 switch (serio->id.type) { 1266 case SERIO_8042_XL: 1267 atkbd->translated = true; 1268 fallthrough; 1269 1270 case SERIO_8042: 1271 if (serio->write) 1272 atkbd->write = true; 1273 break; 1274 } 1275 1276 atkbd->softraw = atkbd_softraw; 1277 atkbd->softrepeat = atkbd_softrepeat; 1278 atkbd->scroll = atkbd_scroll; 1279 1280 if (atkbd->softrepeat) 1281 atkbd->softraw = true; 1282 1283 serio_set_drvdata(serio, atkbd); 1284 1285 err = serio_open(serio, drv); 1286 if (err) 1287 goto fail2; 1288 1289 if (atkbd->write) { 1290 if (atkbd_probe(atkbd)) { 1291 err = -ENODEV; 1292 goto fail3; 1293 } 1294 1295 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra); 1296 atkbd_reset_state(atkbd); 1297 1298 } else { 1299 atkbd->set = 2; 1300 atkbd->id = 0xab00; 1301 } 1302 1303 atkbd_parse_fwnode_data(serio); 1304 1305 atkbd_set_keycode_table(atkbd); 1306 atkbd_set_device_attrs(atkbd); 1307 1308 atkbd_enable(atkbd); 1309 if (serio->write) 1310 atkbd_activate(atkbd); 1311 1312 err = input_register_device(atkbd->dev); 1313 if (err) 1314 goto fail3; 1315 1316 return 0; 1317 1318 fail3: serio_close(serio); 1319 fail2: serio_set_drvdata(serio, NULL); 1320 fail1: input_free_device(dev); 1321 kfree(atkbd); 1322 return err; 1323 } 1324 1325 /* 1326 * atkbd_reconnect() tries to restore keyboard into a sane state and is 1327 * most likely called on resume. 1328 */ 1329 static int atkbd_reconnect(struct serio *serio) 1330 { 1331 struct atkbd *atkbd = atkbd_from_serio(serio); 1332 struct serio_driver *drv = serio->drv; 1333 int error; 1334 1335 if (!atkbd || !drv) { 1336 dev_dbg(&serio->dev, 1337 "reconnect request, but serio is disconnected, ignoring...\n"); 1338 return -1; 1339 } 1340 1341 guard(mutex)(&atkbd->mutex); 1342 1343 atkbd_disable(atkbd); 1344 1345 if (atkbd->write) { 1346 error = atkbd_probe(atkbd); 1347 if (error) 1348 return error; 1349 1350 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra)) 1351 return -EIO; 1352 1353 /* 1354 * Restore LED state and repeat rate. While input core 1355 * will do this for us at resume time reconnect may happen 1356 * because user requested it via sysfs or simply because 1357 * keyboard was unplugged and plugged in again so we need 1358 * to do it ourselves here. 1359 */ 1360 atkbd_set_leds(atkbd); 1361 if (!atkbd->softrepeat) 1362 atkbd_set_repeat_rate(atkbd); 1363 } 1364 1365 /* 1366 * Reset our state machine in case reconnect happened in the middle 1367 * of multi-byte scancode. 1368 */ 1369 atkbd->xl_bit = 0; 1370 atkbd->emul = 0; 1371 1372 atkbd_enable(atkbd); 1373 if (atkbd->write) 1374 atkbd_activate(atkbd); 1375 1376 return 0; 1377 } 1378 1379 static const struct serio_device_id atkbd_serio_ids[] = { 1380 { 1381 .type = SERIO_8042, 1382 .proto = SERIO_ANY, 1383 .id = SERIO_ANY, 1384 .extra = SERIO_ANY, 1385 }, 1386 { 1387 .type = SERIO_8042_XL, 1388 .proto = SERIO_ANY, 1389 .id = SERIO_ANY, 1390 .extra = SERIO_ANY, 1391 }, 1392 { 1393 .type = SERIO_RS232, 1394 .proto = SERIO_PS2SER, 1395 .id = SERIO_ANY, 1396 .extra = SERIO_ANY, 1397 }, 1398 { 0 } 1399 }; 1400 1401 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids); 1402 1403 static struct serio_driver atkbd_drv = { 1404 .driver = { 1405 .name = "atkbd", 1406 .dev_groups = atkbd_attribute_groups, 1407 }, 1408 .description = DRIVER_DESC, 1409 .id_table = atkbd_serio_ids, 1410 .interrupt = ps2_interrupt, 1411 .connect = atkbd_connect, 1412 .reconnect = atkbd_reconnect, 1413 .disconnect = atkbd_disconnect, 1414 .cleanup = atkbd_cleanup, 1415 }; 1416 1417 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 1418 ssize_t (*handler)(struct atkbd *, char *)) 1419 { 1420 struct serio *serio = to_serio_port(dev); 1421 struct atkbd *atkbd = atkbd_from_serio(serio); 1422 1423 return handler(atkbd, buf); 1424 } 1425 1426 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 1427 ssize_t (*handler)(struct atkbd *, const char *, size_t)) 1428 { 1429 struct serio *serio = to_serio_port(dev); 1430 struct atkbd *atkbd = atkbd_from_serio(serio); 1431 int retval; 1432 1433 scoped_guard(mutex_intr, &atkbd->mutex) { 1434 atkbd_disable(atkbd); 1435 retval = handler(atkbd, buf, count); 1436 atkbd_enable(atkbd); 1437 1438 return retval; 1439 } 1440 1441 return -EINTR; 1442 } 1443 1444 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 1445 { 1446 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0); 1447 } 1448 1449 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 1450 { 1451 struct input_dev *old_dev, *new_dev; 1452 unsigned int value; 1453 int err; 1454 bool old_extra; 1455 u8 old_set; 1456 1457 if (!atkbd->write) 1458 return -EIO; 1459 1460 err = kstrtouint(buf, 10, &value); 1461 if (err) 1462 return err; 1463 1464 if (value > 1) 1465 return -EINVAL; 1466 1467 if (atkbd->extra != value) { 1468 /* 1469 * Since device's properties will change we need to 1470 * unregister old device. But allocate and register 1471 * new one first to make sure we have it. 1472 */ 1473 old_dev = atkbd->dev; 1474 old_extra = atkbd->extra; 1475 old_set = atkbd->set; 1476 1477 new_dev = input_allocate_device(); 1478 if (!new_dev) 1479 return -ENOMEM; 1480 1481 atkbd->dev = new_dev; 1482 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value); 1483 atkbd_reset_state(atkbd); 1484 atkbd_activate(atkbd); 1485 atkbd_set_keycode_table(atkbd); 1486 atkbd_set_device_attrs(atkbd); 1487 1488 err = input_register_device(atkbd->dev); 1489 if (err) { 1490 input_free_device(new_dev); 1491 1492 atkbd->dev = old_dev; 1493 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 1494 atkbd_set_keycode_table(atkbd); 1495 atkbd_set_device_attrs(atkbd); 1496 1497 return err; 1498 } 1499 input_unregister_device(old_dev); 1500 } 1501 1502 return count; 1503 } 1504 1505 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf) 1506 { 1507 size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", 1508 ATKBD_KEYMAP_SIZE, atkbd->force_release_mask); 1509 1510 buf[len++] = '\n'; 1511 buf[len] = '\0'; 1512 1513 return len; 1514 } 1515 1516 static ssize_t atkbd_set_force_release(struct atkbd *atkbd, 1517 const char *buf, size_t count) 1518 { 1519 /* 64 bytes on stack should be acceptable */ 1520 DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE); 1521 int err; 1522 1523 err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE); 1524 if (err) 1525 return err; 1526 1527 memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask)); 1528 return count; 1529 } 1530 1531 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 1532 { 1533 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0); 1534 } 1535 1536 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 1537 { 1538 struct input_dev *old_dev, *new_dev; 1539 unsigned int value; 1540 int err; 1541 bool old_scroll; 1542 1543 err = kstrtouint(buf, 10, &value); 1544 if (err) 1545 return err; 1546 1547 if (value > 1) 1548 return -EINVAL; 1549 1550 if (atkbd->scroll != value) { 1551 old_dev = atkbd->dev; 1552 old_scroll = atkbd->scroll; 1553 1554 new_dev = input_allocate_device(); 1555 if (!new_dev) 1556 return -ENOMEM; 1557 1558 atkbd->dev = new_dev; 1559 atkbd->scroll = value; 1560 atkbd_set_keycode_table(atkbd); 1561 atkbd_set_device_attrs(atkbd); 1562 1563 err = input_register_device(atkbd->dev); 1564 if (err) { 1565 input_free_device(new_dev); 1566 1567 atkbd->scroll = old_scroll; 1568 atkbd->dev = old_dev; 1569 atkbd_set_keycode_table(atkbd); 1570 atkbd_set_device_attrs(atkbd); 1571 1572 return err; 1573 } 1574 input_unregister_device(old_dev); 1575 } 1576 return count; 1577 } 1578 1579 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 1580 { 1581 return sprintf(buf, "%d\n", atkbd->set); 1582 } 1583 1584 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 1585 { 1586 struct input_dev *old_dev, *new_dev; 1587 unsigned int value; 1588 int err; 1589 u8 old_set; 1590 bool old_extra; 1591 1592 if (!atkbd->write) 1593 return -EIO; 1594 1595 err = kstrtouint(buf, 10, &value); 1596 if (err) 1597 return err; 1598 1599 if (value != 2 && value != 3) 1600 return -EINVAL; 1601 1602 if (atkbd->set != value) { 1603 old_dev = atkbd->dev; 1604 old_extra = atkbd->extra; 1605 old_set = atkbd->set; 1606 1607 new_dev = input_allocate_device(); 1608 if (!new_dev) 1609 return -ENOMEM; 1610 1611 atkbd->dev = new_dev; 1612 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra); 1613 atkbd_reset_state(atkbd); 1614 atkbd_activate(atkbd); 1615 atkbd_set_keycode_table(atkbd); 1616 atkbd_set_device_attrs(atkbd); 1617 1618 err = input_register_device(atkbd->dev); 1619 if (err) { 1620 input_free_device(new_dev); 1621 1622 atkbd->dev = old_dev; 1623 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 1624 atkbd_set_keycode_table(atkbd); 1625 atkbd_set_device_attrs(atkbd); 1626 1627 return err; 1628 } 1629 input_unregister_device(old_dev); 1630 } 1631 return count; 1632 } 1633 1634 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 1635 { 1636 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0); 1637 } 1638 1639 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 1640 { 1641 struct input_dev *old_dev, *new_dev; 1642 unsigned int value; 1643 int err; 1644 bool old_softrepeat, old_softraw; 1645 1646 if (!atkbd->write) 1647 return -EIO; 1648 1649 err = kstrtouint(buf, 10, &value); 1650 if (err) 1651 return err; 1652 1653 if (value > 1) 1654 return -EINVAL; 1655 1656 if (atkbd->softrepeat != value) { 1657 old_dev = atkbd->dev; 1658 old_softrepeat = atkbd->softrepeat; 1659 old_softraw = atkbd->softraw; 1660 1661 new_dev = input_allocate_device(); 1662 if (!new_dev) 1663 return -ENOMEM; 1664 1665 atkbd->dev = new_dev; 1666 atkbd->softrepeat = value; 1667 if (atkbd->softrepeat) 1668 atkbd->softraw = true; 1669 atkbd_set_device_attrs(atkbd); 1670 1671 err = input_register_device(atkbd->dev); 1672 if (err) { 1673 input_free_device(new_dev); 1674 1675 atkbd->dev = old_dev; 1676 atkbd->softrepeat = old_softrepeat; 1677 atkbd->softraw = old_softraw; 1678 atkbd_set_device_attrs(atkbd); 1679 1680 return err; 1681 } 1682 input_unregister_device(old_dev); 1683 } 1684 return count; 1685 } 1686 1687 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 1688 { 1689 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0); 1690 } 1691 1692 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 1693 { 1694 struct input_dev *old_dev, *new_dev; 1695 unsigned int value; 1696 int err; 1697 bool old_softraw; 1698 1699 err = kstrtouint(buf, 10, &value); 1700 if (err) 1701 return err; 1702 1703 if (value > 1) 1704 return -EINVAL; 1705 1706 if (atkbd->softraw != value) { 1707 old_dev = atkbd->dev; 1708 old_softraw = atkbd->softraw; 1709 1710 new_dev = input_allocate_device(); 1711 if (!new_dev) 1712 return -ENOMEM; 1713 1714 atkbd->dev = new_dev; 1715 atkbd->softraw = value; 1716 atkbd_set_device_attrs(atkbd); 1717 1718 err = input_register_device(atkbd->dev); 1719 if (err) { 1720 input_free_device(new_dev); 1721 1722 atkbd->dev = old_dev; 1723 atkbd->softraw = old_softraw; 1724 atkbd_set_device_attrs(atkbd); 1725 1726 return err; 1727 } 1728 input_unregister_device(old_dev); 1729 } 1730 return count; 1731 } 1732 1733 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf) 1734 { 1735 return sprintf(buf, "%lu\n", atkbd->err_count); 1736 } 1737 1738 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id) 1739 { 1740 atkbd_platform_fixup = atkbd_apply_forced_release_keylist; 1741 atkbd_platform_fixup_data = id->driver_data; 1742 1743 return 1; 1744 } 1745 1746 static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id) 1747 { 1748 atkbd_platform_scancode_fixup = id->driver_data; 1749 1750 return 1; 1751 } 1752 1753 static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id) 1754 { 1755 atkbd_skip_deactivate = true; 1756 return 1; 1757 } 1758 1759 /* 1760 * NOTE: do not add any more "force release" quirks to this table. The 1761 * task of adjusting list of keys that should be "released" automatically 1762 * by the driver is now delegated to userspace tools, such as udev, so 1763 * submit such quirks there. 1764 */ 1765 static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = { 1766 { 1767 .matches = { 1768 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1769 DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */ 1770 }, 1771 .callback = atkbd_setup_forced_release, 1772 .driver_data = atkbd_dell_laptop_forced_release_keys, 1773 }, 1774 { 1775 .matches = { 1776 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 1777 DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */ 1778 }, 1779 .callback = atkbd_setup_forced_release, 1780 .driver_data = atkbd_dell_laptop_forced_release_keys, 1781 }, 1782 { 1783 .matches = { 1784 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1785 DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"), 1786 }, 1787 .callback = atkbd_setup_forced_release, 1788 .driver_data = atkbd_hp_forced_release_keys, 1789 }, 1790 { 1791 .matches = { 1792 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1793 DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"), 1794 }, 1795 .callback = atkbd_setup_forced_release, 1796 .driver_data = atkbd_volume_forced_release_keys, 1797 }, 1798 { 1799 .matches = { 1800 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1801 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"), 1802 }, 1803 .callback = atkbd_setup_forced_release, 1804 .driver_data = atkbd_volume_forced_release_keys, 1805 }, 1806 { 1807 .matches = { 1808 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1809 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"), 1810 }, 1811 .callback = atkbd_setup_forced_release, 1812 .driver_data = atkbd_volume_forced_release_keys, 1813 }, 1814 { 1815 .matches = { 1816 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1817 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"), 1818 }, 1819 .callback = atkbd_setup_forced_release, 1820 .driver_data = atkbd_volume_forced_release_keys, 1821 }, 1822 { 1823 /* Inventec Symphony */ 1824 .matches = { 1825 DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"), 1826 DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"), 1827 }, 1828 .callback = atkbd_setup_forced_release, 1829 .driver_data = atkbd_volume_forced_release_keys, 1830 }, 1831 { 1832 /* Samsung NC10 */ 1833 .matches = { 1834 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 1835 DMI_MATCH(DMI_PRODUCT_NAME, "NC10"), 1836 }, 1837 .callback = atkbd_setup_forced_release, 1838 .driver_data = atkbd_samsung_forced_release_keys, 1839 }, 1840 { 1841 /* Samsung NC20 */ 1842 .matches = { 1843 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 1844 DMI_MATCH(DMI_PRODUCT_NAME, "NC20"), 1845 }, 1846 .callback = atkbd_setup_forced_release, 1847 .driver_data = atkbd_samsung_forced_release_keys, 1848 }, 1849 { 1850 /* Samsung SQ45S70S */ 1851 .matches = { 1852 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 1853 DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"), 1854 }, 1855 .callback = atkbd_setup_forced_release, 1856 .driver_data = atkbd_samsung_forced_release_keys, 1857 }, 1858 { 1859 /* Fujitsu Amilo PA 1510 */ 1860 .matches = { 1861 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1862 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"), 1863 }, 1864 .callback = atkbd_setup_forced_release, 1865 .driver_data = atkbd_volume_forced_release_keys, 1866 }, 1867 { 1868 /* Fujitsu Amilo Pi 3525 */ 1869 .matches = { 1870 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1871 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"), 1872 }, 1873 .callback = atkbd_setup_forced_release, 1874 .driver_data = atkbd_amilo_pi3525_forced_release_keys, 1875 }, 1876 { 1877 /* Fujitsu Amilo Xi 3650 */ 1878 .matches = { 1879 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1880 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"), 1881 }, 1882 .callback = atkbd_setup_forced_release, 1883 .driver_data = atkbd_amilo_xi3650_forced_release_keys, 1884 }, 1885 { 1886 .matches = { 1887 DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"), 1888 DMI_MATCH(DMI_PRODUCT_NAME, "TA12"), 1889 }, 1890 .callback = atkbd_setup_forced_release, 1891 .driver_data = atkdb_soltech_ta12_forced_release_keys, 1892 }, 1893 { 1894 /* OQO Model 01+ */ 1895 .matches = { 1896 DMI_MATCH(DMI_SYS_VENDOR, "OQO"), 1897 DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"), 1898 }, 1899 .callback = atkbd_setup_scancode_fixup, 1900 .driver_data = atkbd_oqo_01plus_scancode_fixup, 1901 }, 1902 { 1903 .matches = { 1904 DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"), 1905 }, 1906 .callback = atkbd_deactivate_fixup, 1907 }, 1908 { 1909 .matches = { 1910 DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), 1911 DMI_MATCH(DMI_PRODUCT_NAME, "BCC-N"), 1912 }, 1913 .callback = atkbd_deactivate_fixup, 1914 }, 1915 { 1916 .matches = { 1917 DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), 1918 DMI_MATCH(DMI_PRODUCT_NAME, "FMB-P"), 1919 }, 1920 .callback = atkbd_deactivate_fixup, 1921 }, 1922 { 1923 /* HONOR MagicBook Pro 14 2026 */ 1924 .matches = { 1925 DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), 1926 DMI_MATCH(DMI_PRODUCT_NAME, "ZQC-P"), 1927 }, 1928 .callback = atkbd_deactivate_fixup, 1929 }, 1930 { 1931 /* Lenovo Yoga Air 14 (83QK) */ 1932 .matches = { 1933 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1934 DMI_MATCH(DMI_PRODUCT_NAME, "83QK"), 1935 }, 1936 .callback = atkbd_deactivate_fixup, 1937 }, 1938 { 1939 /* Lenovo IdeaPad Slim 3 15IWC11 (83RR) */ 1940 .matches = { 1941 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1942 DMI_MATCH(DMI_PRODUCT_NAME, "83RR"), 1943 }, 1944 .callback = atkbd_deactivate_fixup, 1945 }, 1946 { 1947 /* Xiaomi Book Pro 14 (TM2424) */ 1948 .matches = { 1949 DMI_MATCH(DMI_SYS_VENDOR, "XIAOMI"), 1950 DMI_MATCH(DMI_PRODUCT_NAME, "Xiaomi Book Pro 14"), 1951 }, 1952 .callback = atkbd_deactivate_fixup, 1953 }, 1954 { 1955 /* Xiaomi Redmi Book Pro 16 2026 (TM2425) */ 1956 .matches = { 1957 DMI_MATCH(DMI_SYS_VENDOR, "XIAOMI"), 1958 DMI_MATCH(DMI_PRODUCT_NAME, "REDMI Book Pro 16 2026"), 1959 }, 1960 .callback = atkbd_deactivate_fixup, 1961 }, 1962 { } 1963 }; 1964 1965 static int __init atkbd_init(void) 1966 { 1967 dmi_check_system(atkbd_dmi_quirk_table); 1968 1969 return serio_register_driver(&atkbd_drv); 1970 } 1971 1972 static void __exit atkbd_exit(void) 1973 { 1974 serio_unregister_driver(&atkbd_drv); 1975 } 1976 1977 module_init(atkbd_init); 1978 module_exit(atkbd_exit); 1979