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/moduleparam.h> 23 #include <linux/slab.h> 24 #include <linux/interrupt.h> 25 #include <linux/init.h> 26 #include <linux/input.h> 27 #include <linux/serio.h> 28 #include <linux/workqueue.h> 29 #include <linux/libps2.h> 30 #include <linux/mutex.h> 31 32 #define DRIVER_DESC "AT and PS/2 keyboard driver" 33 34 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 35 MODULE_DESCRIPTION(DRIVER_DESC); 36 MODULE_LICENSE("GPL"); 37 38 static int atkbd_set = 2; 39 module_param_named(set, atkbd_set, int, 0); 40 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)"); 41 42 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__) 43 static int atkbd_reset; 44 #else 45 static int atkbd_reset = 1; 46 #endif 47 module_param_named(reset, atkbd_reset, bool, 0); 48 MODULE_PARM_DESC(reset, "Reset keyboard during initialization"); 49 50 static int atkbd_softrepeat; 51 module_param_named(softrepeat, atkbd_softrepeat, bool, 0); 52 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat"); 53 54 static int atkbd_softraw = 1; 55 module_param_named(softraw, atkbd_softraw, bool, 0); 56 MODULE_PARM_DESC(softraw, "Use software generated rawmode"); 57 58 static int atkbd_scroll; 59 module_param_named(scroll, atkbd_scroll, bool, 0); 60 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards"); 61 62 static int atkbd_extra; 63 module_param_named(extra, atkbd_extra, bool, 0); 64 MODULE_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 an userland utility. 69 */ 70 71 static unsigned char atkbd_set2_keycode[512] = { 72 73 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES 74 75 /* XXX: need a more general approach */ 76 77 #include "hpps2atkbd.h" /* include the keyboard scancodes */ 78 79 #else 80 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117, 81 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0, 82 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183, 83 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185, 84 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0, 85 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85, 86 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0, 87 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99, 88 89 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125, 91 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127, 92 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142, 93 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0, 94 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0, 95 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112, 96 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0, 97 98 0, 0, 0, 65, 99, 99 #endif 100 }; 101 102 static unsigned char atkbd_set3_keycode[512] = { 103 104 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60, 105 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62, 106 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64, 107 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66, 108 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68, 109 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70, 110 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104, 111 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183, 112 113 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0, 114 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168, 115 148,149,147,140 116 }; 117 118 static unsigned char atkbd_unxlate_table[128] = { 119 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13, 120 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27, 121 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42, 122 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3, 123 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105, 124 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63, 125 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111, 126 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110 127 }; 128 129 #define ATKBD_CMD_SETLEDS 0x10ed 130 #define ATKBD_CMD_GSCANSET 0x11f0 131 #define ATKBD_CMD_SSCANSET 0x10f0 132 #define ATKBD_CMD_GETID 0x02f2 133 #define ATKBD_CMD_SETREP 0x10f3 134 #define ATKBD_CMD_ENABLE 0x00f4 135 #define ATKBD_CMD_RESET_DIS 0x00f5 136 #define ATKBD_CMD_SETALL_MBR 0x00fa 137 #define ATKBD_CMD_RESET_BAT 0x02ff 138 #define ATKBD_CMD_RESEND 0x00fe 139 #define ATKBD_CMD_EX_ENABLE 0x10ea 140 #define ATKBD_CMD_EX_SETLEDS 0x20eb 141 #define ATKBD_CMD_OK_GETID 0x02e8 142 143 #define ATKBD_RET_ACK 0xfa 144 #define ATKBD_RET_NAK 0xfe 145 #define ATKBD_RET_BAT 0xaa 146 #define ATKBD_RET_EMUL0 0xe0 147 #define ATKBD_RET_EMUL1 0xe1 148 #define ATKBD_RET_RELEASE 0xf0 149 #define ATKBD_RET_HANJA 0xf1 150 #define ATKBD_RET_HANGEUL 0xf2 151 #define ATKBD_RET_ERR 0xff 152 153 #define ATKBD_KEY_UNKNOWN 0 154 #define ATKBD_KEY_NULL 255 155 156 #define ATKBD_SCR_1 254 157 #define ATKBD_SCR_2 253 158 #define ATKBD_SCR_4 252 159 #define ATKBD_SCR_8 251 160 #define ATKBD_SCR_CLICK 250 161 #define ATKBD_SCR_LEFT 249 162 #define ATKBD_SCR_RIGHT 248 163 164 #define ATKBD_SPECIAL 248 165 166 #define ATKBD_LED_EVENT_BIT 0 167 #define ATKBD_REP_EVENT_BIT 1 168 169 #define ATKBD_XL_ERR 0x01 170 #define ATKBD_XL_BAT 0x02 171 #define ATKBD_XL_ACK 0x04 172 #define ATKBD_XL_NAK 0x08 173 #define ATKBD_XL_HANGEUL 0x10 174 #define ATKBD_XL_HANJA 0x20 175 176 static struct { 177 unsigned char keycode; 178 unsigned char set2; 179 } atkbd_scroll_keys[] = { 180 { ATKBD_SCR_1, 0xc5 }, 181 { ATKBD_SCR_2, 0x9d }, 182 { ATKBD_SCR_4, 0xa4 }, 183 { ATKBD_SCR_8, 0x9b }, 184 { ATKBD_SCR_CLICK, 0xe0 }, 185 { ATKBD_SCR_LEFT, 0xcb }, 186 { ATKBD_SCR_RIGHT, 0xd2 }, 187 }; 188 189 /* 190 * The atkbd control structure 191 */ 192 193 struct atkbd { 194 195 struct ps2dev ps2dev; 196 struct input_dev *dev; 197 198 /* Written only during init */ 199 char name[64]; 200 char phys[32]; 201 202 unsigned short id; 203 unsigned char keycode[512]; 204 unsigned char set; 205 unsigned char translated; 206 unsigned char extra; 207 unsigned char write; 208 unsigned char softrepeat; 209 unsigned char softraw; 210 unsigned char scroll; 211 unsigned char enabled; 212 213 /* Accessed only from interrupt */ 214 unsigned char emul; 215 unsigned char resend; 216 unsigned char release; 217 unsigned long xl_bit; 218 unsigned int last; 219 unsigned long time; 220 unsigned long err_count; 221 222 struct delayed_work event_work; 223 unsigned long event_jiffies; 224 struct mutex event_mutex; 225 unsigned long event_mask; 226 }; 227 228 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 229 ssize_t (*handler)(struct atkbd *, char *)); 230 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 231 ssize_t (*handler)(struct atkbd *, const char *, size_t)); 232 #define ATKBD_DEFINE_ATTR(_name) \ 233 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 234 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \ 235 static ssize_t atkbd_do_show_##_name(struct device *d, \ 236 struct device_attribute *attr, char *b) \ 237 { \ 238 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 239 } \ 240 static ssize_t atkbd_do_set_##_name(struct device *d, \ 241 struct device_attribute *attr, const char *b, size_t s) \ 242 { \ 243 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \ 244 } \ 245 static struct device_attribute atkbd_attr_##_name = \ 246 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name); 247 248 ATKBD_DEFINE_ATTR(extra); 249 ATKBD_DEFINE_ATTR(scroll); 250 ATKBD_DEFINE_ATTR(set); 251 ATKBD_DEFINE_ATTR(softrepeat); 252 ATKBD_DEFINE_ATTR(softraw); 253 254 #define ATKBD_DEFINE_RO_ATTR(_name) \ 255 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 256 static ssize_t atkbd_do_show_##_name(struct device *d, \ 257 struct device_attribute *attr, char *b) \ 258 { \ 259 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 260 } \ 261 static struct device_attribute atkbd_attr_##_name = \ 262 __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL); 263 264 ATKBD_DEFINE_RO_ATTR(err_count); 265 266 static struct attribute *atkbd_attributes[] = { 267 &atkbd_attr_extra.attr, 268 &atkbd_attr_scroll.attr, 269 &atkbd_attr_set.attr, 270 &atkbd_attr_softrepeat.attr, 271 &atkbd_attr_softraw.attr, 272 &atkbd_attr_err_count.attr, 273 NULL 274 }; 275 276 static struct attribute_group atkbd_attribute_group = { 277 .attrs = atkbd_attributes, 278 }; 279 280 static const unsigned int xl_table[] = { 281 ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK, 282 ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL, 283 }; 284 285 /* 286 * Checks if we should mangle the scancode to extract 'release' bit 287 * in translated mode. 288 */ 289 static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code) 290 { 291 int i; 292 293 if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1) 294 return 0; 295 296 for (i = 0; i < ARRAY_SIZE(xl_table); i++) 297 if (code == xl_table[i]) 298 return test_bit(i, &xl_bit); 299 300 return 1; 301 } 302 303 /* 304 * Calculates new value of xl_bit so the driver can distinguish 305 * between make/break pair of scancodes for select keys and PS/2 306 * protocol responses. 307 */ 308 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code) 309 { 310 int i; 311 312 for (i = 0; i < ARRAY_SIZE(xl_table); i++) { 313 if (!((code ^ xl_table[i]) & 0x7f)) { 314 if (code & 0x80) 315 __clear_bit(i, &atkbd->xl_bit); 316 else 317 __set_bit(i, &atkbd->xl_bit); 318 break; 319 } 320 } 321 } 322 323 /* 324 * Encode the scancode, 0xe0 prefix, and high bit into a single integer, 325 * keeping kernel 2.4 compatibility for set 2 326 */ 327 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code) 328 { 329 if (atkbd->set == 3) { 330 if (atkbd->emul == 1) 331 code |= 0x100; 332 } else { 333 code = (code & 0x7f) | ((code & 0x80) << 1); 334 if (atkbd->emul == 1) 335 code |= 0x80; 336 } 337 338 return code; 339 } 340 341 /* 342 * atkbd_interrupt(). Here takes place processing of data received from 343 * the keyboard into events. 344 */ 345 346 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 347 unsigned int flags) 348 { 349 struct atkbd *atkbd = serio_get_drvdata(serio); 350 struct input_dev *dev = atkbd->dev; 351 unsigned int code = data; 352 int scroll = 0, hscroll = 0, click = -1, add_release_event = 0; 353 int value; 354 unsigned char keycode; 355 356 #ifdef ATKBD_DEBUG 357 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags); 358 #endif 359 360 #if !defined(__i386__) && !defined (__x86_64__) 361 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) { 362 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags); 363 serio_write(serio, ATKBD_CMD_RESEND); 364 atkbd->resend = 1; 365 goto out; 366 } 367 368 if (!flags && data == ATKBD_RET_ACK) 369 atkbd->resend = 0; 370 #endif 371 372 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK)) 373 if (ps2_handle_ack(&atkbd->ps2dev, data)) 374 goto out; 375 376 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD)) 377 if (ps2_handle_response(&atkbd->ps2dev, data)) 378 goto out; 379 380 if (!atkbd->enabled) 381 goto out; 382 383 input_event(dev, EV_MSC, MSC_RAW, code); 384 385 if (atkbd->translated) { 386 387 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) { 388 atkbd->release = code >> 7; 389 code &= 0x7f; 390 } 391 392 if (!atkbd->emul) 393 atkbd_calculate_xl_bit(atkbd, data); 394 } 395 396 switch (code) { 397 case ATKBD_RET_BAT: 398 atkbd->enabled = 0; 399 serio_reconnect(atkbd->ps2dev.serio); 400 goto out; 401 case ATKBD_RET_EMUL0: 402 atkbd->emul = 1; 403 goto out; 404 case ATKBD_RET_EMUL1: 405 atkbd->emul = 2; 406 goto out; 407 case ATKBD_RET_RELEASE: 408 atkbd->release = 1; 409 goto out; 410 case ATKBD_RET_ACK: 411 case ATKBD_RET_NAK: 412 if (printk_ratelimit()) 413 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. " 414 "Some program might be trying access hardware directly.\n", 415 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys); 416 goto out; 417 case ATKBD_RET_HANGEUL: 418 case ATKBD_RET_HANJA: 419 /* 420 * These keys do not report release and thus need to be 421 * flagged properly 422 */ 423 add_release_event = 1; 424 break; 425 case ATKBD_RET_ERR: 426 atkbd->err_count++; 427 #ifdef ATKBD_DEBUG 428 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys); 429 #endif 430 goto out; 431 } 432 433 code = atkbd_compat_scancode(atkbd, code); 434 435 if (atkbd->emul && --atkbd->emul) 436 goto out; 437 438 keycode = atkbd->keycode[code]; 439 440 if (keycode != ATKBD_KEY_NULL) 441 input_event(dev, EV_MSC, MSC_SCAN, code); 442 443 switch (keycode) { 444 case ATKBD_KEY_NULL: 445 break; 446 case ATKBD_KEY_UNKNOWN: 447 printk(KERN_WARNING 448 "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n", 449 atkbd->release ? "released" : "pressed", 450 atkbd->translated ? "translated" : "raw", 451 atkbd->set, code, serio->phys); 452 printk(KERN_WARNING 453 "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n", 454 code & 0x80 ? "e0" : "", code & 0x7f); 455 input_sync(dev); 456 break; 457 case ATKBD_SCR_1: 458 scroll = 1 - atkbd->release * 2; 459 break; 460 case ATKBD_SCR_2: 461 scroll = 2 - atkbd->release * 4; 462 break; 463 case ATKBD_SCR_4: 464 scroll = 4 - atkbd->release * 8; 465 break; 466 case ATKBD_SCR_8: 467 scroll = 8 - atkbd->release * 16; 468 break; 469 case ATKBD_SCR_CLICK: 470 click = !atkbd->release; 471 break; 472 case ATKBD_SCR_LEFT: 473 hscroll = -1; 474 break; 475 case ATKBD_SCR_RIGHT: 476 hscroll = 1; 477 break; 478 default: 479 if (atkbd->release) { 480 value = 0; 481 atkbd->last = 0; 482 } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) { 483 /* Workaround Toshiba laptop multiple keypress */ 484 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2; 485 } else { 486 value = 1; 487 atkbd->last = code; 488 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2; 489 } 490 491 input_event(dev, EV_KEY, keycode, value); 492 input_sync(dev); 493 494 if (value && add_release_event) { 495 input_report_key(dev, keycode, 0); 496 input_sync(dev); 497 } 498 } 499 500 if (atkbd->scroll) { 501 if (click != -1) 502 input_report_key(dev, BTN_MIDDLE, click); 503 input_report_rel(dev, REL_WHEEL, scroll); 504 input_report_rel(dev, REL_HWHEEL, hscroll); 505 input_sync(dev); 506 } 507 508 atkbd->release = 0; 509 out: 510 return IRQ_HANDLED; 511 } 512 513 static int atkbd_set_repeat_rate(struct atkbd *atkbd) 514 { 515 const short period[32] = 516 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125, 517 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 }; 518 const short delay[4] = 519 { 250, 500, 750, 1000 }; 520 521 struct input_dev *dev = atkbd->dev; 522 unsigned char param; 523 int i = 0, j = 0; 524 525 while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD]) 526 i++; 527 dev->rep[REP_PERIOD] = period[i]; 528 529 while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY]) 530 j++; 531 dev->rep[REP_DELAY] = delay[j]; 532 533 param = i | (j << 5); 534 return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP); 535 } 536 537 static int atkbd_set_leds(struct atkbd *atkbd) 538 { 539 struct input_dev *dev = atkbd->dev; 540 unsigned char param[2]; 541 542 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0) 543 | (test_bit(LED_NUML, dev->led) ? 2 : 0) 544 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0); 545 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS)) 546 return -1; 547 548 if (atkbd->extra) { 549 param[0] = 0; 550 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0) 551 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0) 552 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0) 553 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0) 554 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0); 555 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS)) 556 return -1; 557 } 558 559 return 0; 560 } 561 562 /* 563 * atkbd_event_work() is used to complete processing of events that 564 * can not be processed by input_event() which is often called from 565 * interrupt context. 566 */ 567 568 static void atkbd_event_work(struct work_struct *work) 569 { 570 struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work); 571 572 mutex_lock(&atkbd->event_mutex); 573 574 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask)) 575 atkbd_set_leds(atkbd); 576 577 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask)) 578 atkbd_set_repeat_rate(atkbd); 579 580 mutex_unlock(&atkbd->event_mutex); 581 } 582 583 /* 584 * Schedule switch for execution. We need to throttle requests, 585 * otherwise keyboard may become unresponsive. 586 */ 587 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit) 588 { 589 unsigned long delay = msecs_to_jiffies(50); 590 591 if (time_after(jiffies, atkbd->event_jiffies + delay)) 592 delay = 0; 593 594 atkbd->event_jiffies = jiffies; 595 set_bit(event_bit, &atkbd->event_mask); 596 wmb(); 597 schedule_delayed_work(&atkbd->event_work, delay); 598 } 599 600 /* 601 * Event callback from the input module. Events that change the state of 602 * the hardware are processed here. If action can not be performed in 603 * interrupt context it is offloaded to atkbd_event_work. 604 */ 605 606 static int atkbd_event(struct input_dev *dev, 607 unsigned int type, unsigned int code, int value) 608 { 609 struct atkbd *atkbd = input_get_drvdata(dev); 610 611 if (!atkbd->write) 612 return -1; 613 614 switch (type) { 615 616 case EV_LED: 617 atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT); 618 return 0; 619 620 case EV_REP: 621 if (!atkbd->softrepeat) 622 atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT); 623 return 0; 624 } 625 626 return -1; 627 } 628 629 /* 630 * atkbd_enable() signals that interrupt handler is allowed to 631 * generate input events. 632 */ 633 634 static inline void atkbd_enable(struct atkbd *atkbd) 635 { 636 serio_pause_rx(atkbd->ps2dev.serio); 637 atkbd->enabled = 1; 638 serio_continue_rx(atkbd->ps2dev.serio); 639 } 640 641 /* 642 * atkbd_disable() tells input handler that all incoming data except 643 * for ACKs and command response should be dropped. 644 */ 645 646 static inline void atkbd_disable(struct atkbd *atkbd) 647 { 648 serio_pause_rx(atkbd->ps2dev.serio); 649 atkbd->enabled = 0; 650 serio_continue_rx(atkbd->ps2dev.serio); 651 } 652 653 /* 654 * atkbd_probe() probes for an AT keyboard on a serio port. 655 */ 656 657 static int atkbd_probe(struct atkbd *atkbd) 658 { 659 struct ps2dev *ps2dev = &atkbd->ps2dev; 660 unsigned char param[2]; 661 662 /* 663 * Some systems, where the bit-twiddling when testing the io-lines of the 664 * controller may confuse the keyboard need a full reset of the keyboard. On 665 * these systems the BIOS also usually doesn't do it for us. 666 */ 667 668 if (atkbd_reset) 669 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT)) 670 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys); 671 672 /* 673 * Then we check the keyboard ID. We should get 0xab83 under normal conditions. 674 * Some keyboards report different values, but the first byte is always 0xab or 675 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this 676 * should make sure we don't try to set the LEDs on it. 677 */ 678 679 param[0] = param[1] = 0xa5; /* initialize with invalid values */ 680 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) { 681 682 /* 683 * If the get ID command failed, we check if we can at least set the LEDs on 684 * the keyboard. This should work on every keyboard out there. It also turns 685 * the LEDs off, which we want anyway. 686 */ 687 param[0] = 0; 688 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 689 return -1; 690 atkbd->id = 0xabba; 691 return 0; 692 } 693 694 if (!ps2_is_keyboard_id(param[0])) 695 return -1; 696 697 atkbd->id = (param[0] << 8) | param[1]; 698 699 if (atkbd->id == 0xaca1 && atkbd->translated) { 700 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n"); 701 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n"); 702 return -1; 703 } 704 705 return 0; 706 } 707 708 /* 709 * atkbd_select_set checks if a keyboard has a working Set 3 support, and 710 * sets it into that. Unfortunately there are keyboards that can be switched 711 * to Set 3, but don't work well in that (BTC Multimedia ...) 712 */ 713 714 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra) 715 { 716 struct ps2dev *ps2dev = &atkbd->ps2dev; 717 unsigned char param[2]; 718 719 atkbd->extra = 0; 720 /* 721 * For known special keyboards we can go ahead and set the correct set. 722 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and 723 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards. 724 */ 725 726 if (atkbd->translated) 727 return 2; 728 729 if (atkbd->id == 0xaca1) { 730 param[0] = 3; 731 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET); 732 return 3; 733 } 734 735 if (allow_extra) { 736 param[0] = 0x71; 737 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) { 738 atkbd->extra = 1; 739 return 2; 740 } 741 } 742 743 if (target_set != 3) 744 return 2; 745 746 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) { 747 atkbd->id = param[0] << 8 | param[1]; 748 return 2; 749 } 750 751 param[0] = 3; 752 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 753 return 2; 754 755 param[0] = 0; 756 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET)) 757 return 2; 758 759 if (param[0] != 3) { 760 param[0] = 2; 761 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 762 return 2; 763 } 764 765 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR); 766 767 return 3; 768 } 769 770 static int atkbd_activate(struct atkbd *atkbd) 771 { 772 struct ps2dev *ps2dev = &atkbd->ps2dev; 773 unsigned char param[1]; 774 775 /* 776 * Set the LEDs to a defined state. 777 */ 778 779 param[0] = 0; 780 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 781 return -1; 782 783 /* 784 * Set autorepeat to fastest possible. 785 */ 786 787 param[0] = 0; 788 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP)) 789 return -1; 790 791 /* 792 * Enable the keyboard to receive keystrokes. 793 */ 794 795 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) { 796 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n", 797 ps2dev->serio->phys); 798 return -1; 799 } 800 801 return 0; 802 } 803 804 /* 805 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a 806 * reboot. 807 */ 808 809 static void atkbd_cleanup(struct serio *serio) 810 { 811 struct atkbd *atkbd = serio_get_drvdata(serio); 812 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT); 813 } 814 815 816 /* 817 * atkbd_disconnect() closes and frees. 818 */ 819 820 static void atkbd_disconnect(struct serio *serio) 821 { 822 struct atkbd *atkbd = serio_get_drvdata(serio); 823 824 atkbd_disable(atkbd); 825 826 /* make sure we don't have a command in flight */ 827 synchronize_sched(); /* Allow atkbd_interrupt()s to complete. */ 828 flush_scheduled_work(); 829 830 sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); 831 input_unregister_device(atkbd->dev); 832 serio_close(serio); 833 serio_set_drvdata(serio, NULL); 834 kfree(atkbd); 835 } 836 837 838 /* 839 * atkbd_set_keycode_table() initializes keyboard's keycode table 840 * according to the selected scancode set 841 */ 842 843 static void atkbd_set_keycode_table(struct atkbd *atkbd) 844 { 845 int i, j; 846 847 memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 848 849 if (atkbd->translated) { 850 for (i = 0; i < 128; i++) { 851 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]]; 852 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80]; 853 if (atkbd->scroll) 854 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++) 855 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2) 856 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode; 857 } 858 } else if (atkbd->set == 3) { 859 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode)); 860 } else { 861 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode)); 862 863 if (atkbd->scroll) 864 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) 865 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode; 866 } 867 868 atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL)] = KEY_HANGUEL; 869 atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA)] = KEY_HANJA; 870 } 871 872 /* 873 * atkbd_set_device_attrs() sets up keyboard's input device structure 874 */ 875 876 static void atkbd_set_device_attrs(struct atkbd *atkbd) 877 { 878 struct input_dev *input_dev = atkbd->dev; 879 int i; 880 881 if (atkbd->extra) 882 snprintf(atkbd->name, sizeof(atkbd->name), 883 "AT Set 2 Extra keyboard"); 884 else 885 snprintf(atkbd->name, sizeof(atkbd->name), 886 "AT %s Set %d keyboard", 887 atkbd->translated ? "Translated" : "Raw", atkbd->set); 888 889 snprintf(atkbd->phys, sizeof(atkbd->phys), 890 "%s/input0", atkbd->ps2dev.serio->phys); 891 892 input_dev->name = atkbd->name; 893 input_dev->phys = atkbd->phys; 894 input_dev->id.bustype = BUS_I8042; 895 input_dev->id.vendor = 0x0001; 896 input_dev->id.product = atkbd->translated ? 1 : atkbd->set; 897 input_dev->id.version = atkbd->id; 898 input_dev->event = atkbd_event; 899 input_dev->dev.parent = &atkbd->ps2dev.serio->dev; 900 901 input_set_drvdata(input_dev, atkbd); 902 903 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC); 904 905 if (atkbd->write) { 906 input_dev->evbit[0] |= BIT(EV_LED); 907 input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL); 908 } 909 910 if (atkbd->extra) 911 input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) | 912 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC); 913 914 if (!atkbd->softrepeat) { 915 input_dev->rep[REP_DELAY] = 250; 916 input_dev->rep[REP_PERIOD] = 33; 917 } 918 919 input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN); 920 921 if (atkbd->scroll) { 922 input_dev->evbit[0] |= BIT(EV_REL); 923 input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL); 924 set_bit(BTN_MIDDLE, input_dev->keybit); 925 } 926 927 input_dev->keycode = atkbd->keycode; 928 input_dev->keycodesize = sizeof(unsigned char); 929 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode); 930 931 for (i = 0; i < 512; i++) 932 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL) 933 set_bit(atkbd->keycode[i], input_dev->keybit); 934 } 935 936 /* 937 * atkbd_connect() is called when the serio module finds an interface 938 * that isn't handled yet by an appropriate device driver. We check if 939 * there is an AT keyboard out there and if yes, we register ourselves 940 * to the input module. 941 */ 942 943 static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 944 { 945 struct atkbd *atkbd; 946 struct input_dev *dev; 947 int err = -ENOMEM; 948 949 atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL); 950 dev = input_allocate_device(); 951 if (!atkbd || !dev) 952 goto fail1; 953 954 atkbd->dev = dev; 955 ps2_init(&atkbd->ps2dev, serio); 956 INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work); 957 mutex_init(&atkbd->event_mutex); 958 959 switch (serio->id.type) { 960 961 case SERIO_8042_XL: 962 atkbd->translated = 1; 963 case SERIO_8042: 964 if (serio->write) 965 atkbd->write = 1; 966 break; 967 } 968 969 atkbd->softraw = atkbd_softraw; 970 atkbd->softrepeat = atkbd_softrepeat; 971 atkbd->scroll = atkbd_scroll; 972 973 if (atkbd->softrepeat) 974 atkbd->softraw = 1; 975 976 serio_set_drvdata(serio, atkbd); 977 978 err = serio_open(serio, drv); 979 if (err) 980 goto fail2; 981 982 if (atkbd->write) { 983 984 if (atkbd_probe(atkbd)) { 985 err = -ENODEV; 986 goto fail3; 987 } 988 989 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra); 990 atkbd_activate(atkbd); 991 992 } else { 993 atkbd->set = 2; 994 atkbd->id = 0xab00; 995 } 996 997 atkbd_set_keycode_table(atkbd); 998 atkbd_set_device_attrs(atkbd); 999 1000 err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group); 1001 if (err) 1002 goto fail3; 1003 1004 atkbd_enable(atkbd); 1005 1006 err = input_register_device(atkbd->dev); 1007 if (err) 1008 goto fail4; 1009 1010 return 0; 1011 1012 fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); 1013 fail3: serio_close(serio); 1014 fail2: serio_set_drvdata(serio, NULL); 1015 fail1: input_free_device(dev); 1016 kfree(atkbd); 1017 return err; 1018 } 1019 1020 /* 1021 * atkbd_reconnect() tries to restore keyboard into a sane state and is 1022 * most likely called on resume. 1023 */ 1024 1025 static int atkbd_reconnect(struct serio *serio) 1026 { 1027 struct atkbd *atkbd = serio_get_drvdata(serio); 1028 struct serio_driver *drv = serio->drv; 1029 1030 if (!atkbd || !drv) { 1031 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n"); 1032 return -1; 1033 } 1034 1035 atkbd_disable(atkbd); 1036 1037 if (atkbd->write) { 1038 if (atkbd_probe(atkbd)) 1039 return -1; 1040 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra)) 1041 return -1; 1042 1043 atkbd_activate(atkbd); 1044 1045 /* 1046 * Restore repeat rate and LEDs (that were reset by atkbd_activate) 1047 * to pre-resume state 1048 */ 1049 if (!atkbd->softrepeat) 1050 atkbd_set_repeat_rate(atkbd); 1051 atkbd_set_leds(atkbd); 1052 } 1053 1054 atkbd_enable(atkbd); 1055 1056 return 0; 1057 } 1058 1059 static struct serio_device_id atkbd_serio_ids[] = { 1060 { 1061 .type = SERIO_8042, 1062 .proto = SERIO_ANY, 1063 .id = SERIO_ANY, 1064 .extra = SERIO_ANY, 1065 }, 1066 { 1067 .type = SERIO_8042_XL, 1068 .proto = SERIO_ANY, 1069 .id = SERIO_ANY, 1070 .extra = SERIO_ANY, 1071 }, 1072 { 1073 .type = SERIO_RS232, 1074 .proto = SERIO_PS2SER, 1075 .id = SERIO_ANY, 1076 .extra = SERIO_ANY, 1077 }, 1078 { 0 } 1079 }; 1080 1081 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids); 1082 1083 static struct serio_driver atkbd_drv = { 1084 .driver = { 1085 .name = "atkbd", 1086 }, 1087 .description = DRIVER_DESC, 1088 .id_table = atkbd_serio_ids, 1089 .interrupt = atkbd_interrupt, 1090 .connect = atkbd_connect, 1091 .reconnect = atkbd_reconnect, 1092 .disconnect = atkbd_disconnect, 1093 .cleanup = atkbd_cleanup, 1094 }; 1095 1096 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 1097 ssize_t (*handler)(struct atkbd *, char *)) 1098 { 1099 struct serio *serio = to_serio_port(dev); 1100 int retval; 1101 1102 retval = serio_pin_driver(serio); 1103 if (retval) 1104 return retval; 1105 1106 if (serio->drv != &atkbd_drv) { 1107 retval = -ENODEV; 1108 goto out; 1109 } 1110 1111 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf); 1112 1113 out: 1114 serio_unpin_driver(serio); 1115 return retval; 1116 } 1117 1118 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 1119 ssize_t (*handler)(struct atkbd *, const char *, size_t)) 1120 { 1121 struct serio *serio = to_serio_port(dev); 1122 struct atkbd *atkbd; 1123 int retval; 1124 1125 retval = serio_pin_driver(serio); 1126 if (retval) 1127 return retval; 1128 1129 if (serio->drv != &atkbd_drv) { 1130 retval = -ENODEV; 1131 goto out; 1132 } 1133 1134 atkbd = serio_get_drvdata(serio); 1135 atkbd_disable(atkbd); 1136 retval = handler(atkbd, buf, count); 1137 atkbd_enable(atkbd); 1138 1139 out: 1140 serio_unpin_driver(serio); 1141 return retval; 1142 } 1143 1144 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 1145 { 1146 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0); 1147 } 1148 1149 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 1150 { 1151 struct input_dev *old_dev, *new_dev; 1152 unsigned long value; 1153 char *rest; 1154 int err; 1155 unsigned char old_extra, old_set; 1156 1157 if (!atkbd->write) 1158 return -EIO; 1159 1160 value = simple_strtoul(buf, &rest, 10); 1161 if (*rest || value > 1) 1162 return -EINVAL; 1163 1164 if (atkbd->extra != value) { 1165 /* 1166 * Since device's properties will change we need to 1167 * unregister old device. But allocate and register 1168 * new one first to make sure we have it. 1169 */ 1170 old_dev = atkbd->dev; 1171 old_extra = atkbd->extra; 1172 old_set = atkbd->set; 1173 1174 new_dev = input_allocate_device(); 1175 if (!new_dev) 1176 return -ENOMEM; 1177 1178 atkbd->dev = new_dev; 1179 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value); 1180 atkbd_activate(atkbd); 1181 atkbd_set_keycode_table(atkbd); 1182 atkbd_set_device_attrs(atkbd); 1183 1184 err = input_register_device(atkbd->dev); 1185 if (err) { 1186 input_free_device(new_dev); 1187 1188 atkbd->dev = old_dev; 1189 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 1190 atkbd_set_keycode_table(atkbd); 1191 atkbd_set_device_attrs(atkbd); 1192 1193 return err; 1194 } 1195 input_unregister_device(old_dev); 1196 1197 } 1198 return count; 1199 } 1200 1201 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 1202 { 1203 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0); 1204 } 1205 1206 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 1207 { 1208 struct input_dev *old_dev, *new_dev; 1209 unsigned long value; 1210 char *rest; 1211 int err; 1212 unsigned char old_scroll; 1213 1214 value = simple_strtoul(buf, &rest, 10); 1215 if (*rest || value > 1) 1216 return -EINVAL; 1217 1218 if (atkbd->scroll != value) { 1219 old_dev = atkbd->dev; 1220 old_scroll = atkbd->scroll; 1221 1222 new_dev = input_allocate_device(); 1223 if (!new_dev) 1224 return -ENOMEM; 1225 1226 atkbd->dev = new_dev; 1227 atkbd->scroll = value; 1228 atkbd_set_keycode_table(atkbd); 1229 atkbd_set_device_attrs(atkbd); 1230 1231 err = input_register_device(atkbd->dev); 1232 if (err) { 1233 input_free_device(new_dev); 1234 1235 atkbd->scroll = old_scroll; 1236 atkbd->dev = old_dev; 1237 atkbd_set_keycode_table(atkbd); 1238 atkbd_set_device_attrs(atkbd); 1239 1240 return err; 1241 } 1242 input_unregister_device(old_dev); 1243 } 1244 return count; 1245 } 1246 1247 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 1248 { 1249 return sprintf(buf, "%d\n", atkbd->set); 1250 } 1251 1252 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 1253 { 1254 struct input_dev *old_dev, *new_dev; 1255 unsigned long value; 1256 char *rest; 1257 int err; 1258 unsigned char old_set, old_extra; 1259 1260 if (!atkbd->write) 1261 return -EIO; 1262 1263 value = simple_strtoul(buf, &rest, 10); 1264 if (*rest || (value != 2 && value != 3)) 1265 return -EINVAL; 1266 1267 if (atkbd->set != value) { 1268 old_dev = atkbd->dev; 1269 old_extra = atkbd->extra; 1270 old_set = atkbd->set; 1271 1272 new_dev = input_allocate_device(); 1273 if (!new_dev) 1274 return -ENOMEM; 1275 1276 atkbd->dev = new_dev; 1277 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra); 1278 atkbd_activate(atkbd); 1279 atkbd_set_keycode_table(atkbd); 1280 atkbd_set_device_attrs(atkbd); 1281 1282 err = input_register_device(atkbd->dev); 1283 if (err) { 1284 input_free_device(new_dev); 1285 1286 atkbd->dev = old_dev; 1287 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 1288 atkbd_set_keycode_table(atkbd); 1289 atkbd_set_device_attrs(atkbd); 1290 1291 return err; 1292 } 1293 input_unregister_device(old_dev); 1294 } 1295 return count; 1296 } 1297 1298 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 1299 { 1300 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0); 1301 } 1302 1303 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 1304 { 1305 struct input_dev *old_dev, *new_dev; 1306 unsigned long value; 1307 char *rest; 1308 int err; 1309 unsigned char old_softrepeat, old_softraw; 1310 1311 if (!atkbd->write) 1312 return -EIO; 1313 1314 value = simple_strtoul(buf, &rest, 10); 1315 if (*rest || value > 1) 1316 return -EINVAL; 1317 1318 if (atkbd->softrepeat != value) { 1319 old_dev = atkbd->dev; 1320 old_softrepeat = atkbd->softrepeat; 1321 old_softraw = atkbd->softraw; 1322 1323 new_dev = input_allocate_device(); 1324 if (!new_dev) 1325 return -ENOMEM; 1326 1327 atkbd->dev = new_dev; 1328 atkbd->softrepeat = value; 1329 if (atkbd->softrepeat) 1330 atkbd->softraw = 1; 1331 atkbd_set_device_attrs(atkbd); 1332 1333 err = input_register_device(atkbd->dev); 1334 if (err) { 1335 input_free_device(new_dev); 1336 1337 atkbd->dev = old_dev; 1338 atkbd->softrepeat = old_softrepeat; 1339 atkbd->softraw = old_softraw; 1340 atkbd_set_device_attrs(atkbd); 1341 1342 return err; 1343 } 1344 input_unregister_device(old_dev); 1345 } 1346 return count; 1347 } 1348 1349 1350 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 1351 { 1352 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0); 1353 } 1354 1355 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 1356 { 1357 struct input_dev *old_dev, *new_dev; 1358 unsigned long value; 1359 char *rest; 1360 int err; 1361 unsigned char old_softraw; 1362 1363 value = simple_strtoul(buf, &rest, 10); 1364 if (*rest || value > 1) 1365 return -EINVAL; 1366 1367 if (atkbd->softraw != value) { 1368 old_dev = atkbd->dev; 1369 old_softraw = atkbd->softraw; 1370 1371 new_dev = input_allocate_device(); 1372 if (!new_dev) 1373 return -ENOMEM; 1374 1375 atkbd->dev = new_dev; 1376 atkbd->softraw = value; 1377 atkbd_set_device_attrs(atkbd); 1378 1379 err = input_register_device(atkbd->dev); 1380 if (err) { 1381 input_free_device(new_dev); 1382 1383 atkbd->dev = old_dev; 1384 atkbd->softraw = old_softraw; 1385 atkbd_set_device_attrs(atkbd); 1386 1387 return err; 1388 } 1389 input_unregister_device(old_dev); 1390 } 1391 return count; 1392 } 1393 1394 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf) 1395 { 1396 return sprintf(buf, "%lu\n", atkbd->err_count); 1397 } 1398 1399 1400 static int __init atkbd_init(void) 1401 { 1402 return serio_register_driver(&atkbd_drv); 1403 } 1404 1405 static void __exit atkbd_exit(void) 1406 { 1407 serio_unregister_driver(&atkbd_drv); 1408 } 1409 1410 module_init(atkbd_init); 1411 module_exit(atkbd_exit); 1412