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