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