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