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