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 = 0; 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_HANGUEL 0xf1 154 #define ATKBD_RET_HANJA 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 static struct { 174 unsigned char keycode; 175 unsigned char set2; 176 } atkbd_scroll_keys[] = { 177 { ATKBD_SCR_1, 0xc5 }, 178 { ATKBD_SCR_2, 0x9d }, 179 { ATKBD_SCR_4, 0xa4 }, 180 { ATKBD_SCR_8, 0x9b }, 181 { ATKBD_SCR_CLICK, 0xe0 }, 182 { ATKBD_SCR_LEFT, 0xcb }, 183 { ATKBD_SCR_RIGHT, 0xd2 }, 184 }; 185 186 /* 187 * The atkbd control structure 188 */ 189 190 struct atkbd { 191 192 struct ps2dev ps2dev; 193 struct input_dev *dev; 194 195 /* Written only during init */ 196 char name[64]; 197 char phys[32]; 198 199 unsigned short id; 200 unsigned char keycode[512]; 201 unsigned char set; 202 unsigned char translated; 203 unsigned char extra; 204 unsigned char write; 205 unsigned char softrepeat; 206 unsigned char softraw; 207 unsigned char scroll; 208 unsigned char enabled; 209 210 /* Accessed only from interrupt */ 211 unsigned char emul; 212 unsigned char resend; 213 unsigned char release; 214 unsigned char bat_xl; 215 unsigned char err_xl; 216 unsigned int last; 217 unsigned long time; 218 219 struct work_struct event_work; 220 struct mutex event_mutex; 221 unsigned long event_mask; 222 }; 223 224 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 225 ssize_t (*handler)(struct atkbd *, char *)); 226 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 227 ssize_t (*handler)(struct atkbd *, const char *, size_t)); 228 #define ATKBD_DEFINE_ATTR(_name) \ 229 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 230 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \ 231 static ssize_t atkbd_do_show_##_name(struct device *d, struct device_attribute *attr, char *b) \ 232 { \ 233 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 234 } \ 235 static ssize_t atkbd_do_set_##_name(struct device *d, struct device_attribute *attr, const char *b, size_t s) \ 236 { \ 237 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \ 238 } \ 239 static struct device_attribute atkbd_attr_##_name = \ 240 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name); 241 242 ATKBD_DEFINE_ATTR(extra); 243 ATKBD_DEFINE_ATTR(scroll); 244 ATKBD_DEFINE_ATTR(set); 245 ATKBD_DEFINE_ATTR(softrepeat); 246 ATKBD_DEFINE_ATTR(softraw); 247 248 249 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value) 250 { 251 input_regs(dev, regs); 252 if (value == 3) { 253 input_report_key(dev, code, 1); 254 input_sync(dev); 255 input_report_key(dev, code, 0); 256 } else 257 input_event(dev, EV_KEY, code, value); 258 input_sync(dev); 259 } 260 261 /* 262 * atkbd_interrupt(). Here takes place processing of data received from 263 * the keyboard into events. 264 */ 265 266 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 267 unsigned int flags, struct pt_regs *regs) 268 { 269 struct atkbd *atkbd = serio_get_drvdata(serio); 270 unsigned int code = data; 271 int scroll = 0, hscroll = 0, click = -1; 272 int value; 273 274 #ifdef ATKBD_DEBUG 275 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags); 276 #endif 277 278 #if !defined(__i386__) && !defined (__x86_64__) 279 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) { 280 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags); 281 serio_write(serio, ATKBD_CMD_RESEND); 282 atkbd->resend = 1; 283 goto out; 284 } 285 286 if (!flags && data == ATKBD_RET_ACK) 287 atkbd->resend = 0; 288 #endif 289 290 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK)) 291 if (ps2_handle_ack(&atkbd->ps2dev, data)) 292 goto out; 293 294 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD)) 295 if (ps2_handle_response(&atkbd->ps2dev, data)) 296 goto out; 297 298 if (!atkbd->enabled) 299 goto out; 300 301 input_event(atkbd->dev, EV_MSC, MSC_RAW, code); 302 303 if (atkbd->translated) { 304 305 if (atkbd->emul || 306 (code != ATKBD_RET_EMUL0 && code != ATKBD_RET_EMUL1 && 307 code != ATKBD_RET_HANGUEL && code != ATKBD_RET_HANJA && 308 (code != ATKBD_RET_ERR || atkbd->err_xl) && 309 (code != ATKBD_RET_BAT || atkbd->bat_xl))) { 310 atkbd->release = code >> 7; 311 code &= 0x7f; 312 } 313 314 if (!atkbd->emul) { 315 if ((code & 0x7f) == (ATKBD_RET_BAT & 0x7f)) 316 atkbd->bat_xl = !(data >> 7); 317 if ((code & 0x7f) == (ATKBD_RET_ERR & 0x7f)) 318 atkbd->err_xl = !(data >> 7); 319 } 320 } 321 322 switch (code) { 323 case ATKBD_RET_BAT: 324 atkbd->enabled = 0; 325 serio_reconnect(atkbd->ps2dev.serio); 326 goto out; 327 case ATKBD_RET_EMUL0: 328 atkbd->emul = 1; 329 goto out; 330 case ATKBD_RET_EMUL1: 331 atkbd->emul = 2; 332 goto out; 333 case ATKBD_RET_RELEASE: 334 atkbd->release = 1; 335 goto out; 336 case ATKBD_RET_HANGUEL: 337 atkbd_report_key(atkbd->dev, regs, KEY_HANGUEL, 3); 338 goto out; 339 case ATKBD_RET_HANJA: 340 atkbd_report_key(atkbd->dev, regs, KEY_HANJA, 3); 341 goto out; 342 case ATKBD_RET_ERR: 343 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys); 344 goto out; 345 } 346 347 if (atkbd->set != 3) 348 code = (code & 0x7f) | ((code & 0x80) << 1); 349 if (atkbd->emul) { 350 if (--atkbd->emul) 351 goto out; 352 code |= (atkbd->set != 3) ? 0x80 : 0x100; 353 } 354 355 if (atkbd->keycode[code] != ATKBD_KEY_NULL) 356 input_event(atkbd->dev, EV_MSC, MSC_SCAN, code); 357 358 switch (atkbd->keycode[code]) { 359 case ATKBD_KEY_NULL: 360 break; 361 case ATKBD_KEY_UNKNOWN: 362 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) { 363 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, " 364 "like XFree86, might be trying access hardware directly.\n", 365 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys); 366 } else { 367 printk(KERN_WARNING "atkbd.c: Unknown key %s " 368 "(%s set %d, code %#x on %s).\n", 369 atkbd->release ? "released" : "pressed", 370 atkbd->translated ? "translated" : "raw", 371 atkbd->set, code, serio->phys); 372 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' " 373 "to make it known.\n", 374 code & 0x80 ? "e0" : "", code & 0x7f); 375 } 376 input_sync(atkbd->dev); 377 break; 378 case ATKBD_SCR_1: 379 scroll = 1 - atkbd->release * 2; 380 break; 381 case ATKBD_SCR_2: 382 scroll = 2 - atkbd->release * 4; 383 break; 384 case ATKBD_SCR_4: 385 scroll = 4 - atkbd->release * 8; 386 break; 387 case ATKBD_SCR_8: 388 scroll = 8 - atkbd->release * 16; 389 break; 390 case ATKBD_SCR_CLICK: 391 click = !atkbd->release; 392 break; 393 case ATKBD_SCR_LEFT: 394 hscroll = -1; 395 break; 396 case ATKBD_SCR_RIGHT: 397 hscroll = 1; 398 break; 399 default: 400 value = atkbd->release ? 0 : 401 (1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev->key))); 402 403 switch (value) { /* Workaround Toshiba laptop multiple keypress */ 404 case 0: 405 atkbd->last = 0; 406 break; 407 case 1: 408 atkbd->last = code; 409 atkbd->time = jiffies + msecs_to_jiffies(atkbd->dev->rep[REP_DELAY]) / 2; 410 break; 411 case 2: 412 if (!time_after(jiffies, atkbd->time) && atkbd->last == code) 413 value = 1; 414 break; 415 } 416 417 atkbd_report_key(atkbd->dev, regs, atkbd->keycode[code], value); 418 } 419 420 if (atkbd->scroll) { 421 input_regs(atkbd->dev, regs); 422 if (click != -1) 423 input_report_key(atkbd->dev, BTN_MIDDLE, click); 424 input_report_rel(atkbd->dev, REL_WHEEL, scroll); 425 input_report_rel(atkbd->dev, REL_HWHEEL, hscroll); 426 input_sync(atkbd->dev); 427 } 428 429 atkbd->release = 0; 430 out: 431 return IRQ_HANDLED; 432 } 433 434 /* 435 * atkbd_event_work() is used to complete processing of events that 436 * can not be processed by input_event() which is often called from 437 * interrupt context. 438 */ 439 440 static void atkbd_event_work(void *data) 441 { 442 const short period[32] = 443 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125, 444 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 }; 445 const short delay[4] = 446 { 250, 500, 750, 1000 }; 447 448 struct atkbd *atkbd = data; 449 struct input_dev *dev = atkbd->dev; 450 unsigned char param[2]; 451 int i, j; 452 453 mutex_lock(&atkbd->event_mutex); 454 455 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask)) { 456 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0) 457 | (test_bit(LED_NUML, dev->led) ? 2 : 0) 458 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0); 459 ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS); 460 461 if (atkbd->extra) { 462 param[0] = 0; 463 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0) 464 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0) 465 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0) 466 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0) 467 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0); 468 ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS); 469 } 470 } 471 472 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask)) { 473 i = j = 0; 474 while (i < 31 && period[i] < dev->rep[REP_PERIOD]) 475 i++; 476 while (j < 3 && delay[j] < dev->rep[REP_DELAY]) 477 j++; 478 dev->rep[REP_PERIOD] = period[i]; 479 dev->rep[REP_DELAY] = delay[j]; 480 param[0] = i | (j << 5); 481 ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP); 482 } 483 484 mutex_unlock(&atkbd->event_mutex); 485 } 486 487 /* 488 * Event callback from the input module. Events that change the state of 489 * the hardware are processed here. If action can not be performed in 490 * interrupt context it is offloaded to atkbd_event_work. 491 */ 492 493 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 494 { 495 struct atkbd *atkbd = dev->private; 496 497 if (!atkbd->write) 498 return -1; 499 500 switch (type) { 501 502 case EV_LED: 503 set_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask); 504 wmb(); 505 schedule_work(&atkbd->event_work); 506 return 0; 507 508 case EV_REP: 509 510 if (!atkbd->softrepeat) { 511 set_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask); 512 wmb(); 513 schedule_work(&atkbd->event_work); 514 } 515 516 return 0; 517 } 518 519 return -1; 520 } 521 522 /* 523 * atkbd_enable() signals that interrupt handler is allowed to 524 * generate input events. 525 */ 526 527 static inline void atkbd_enable(struct atkbd *atkbd) 528 { 529 serio_pause_rx(atkbd->ps2dev.serio); 530 atkbd->enabled = 1; 531 serio_continue_rx(atkbd->ps2dev.serio); 532 } 533 534 /* 535 * atkbd_disable() tells input handler that all incoming data except 536 * for ACKs and command response should be dropped. 537 */ 538 539 static inline void atkbd_disable(struct atkbd *atkbd) 540 { 541 serio_pause_rx(atkbd->ps2dev.serio); 542 atkbd->enabled = 0; 543 serio_continue_rx(atkbd->ps2dev.serio); 544 } 545 546 /* 547 * atkbd_probe() probes for an AT keyboard on a serio port. 548 */ 549 550 static int atkbd_probe(struct atkbd *atkbd) 551 { 552 struct ps2dev *ps2dev = &atkbd->ps2dev; 553 unsigned char param[2]; 554 555 /* 556 * Some systems, where the bit-twiddling when testing the io-lines of the 557 * controller may confuse the keyboard need a full reset of the keyboard. On 558 * these systems the BIOS also usually doesn't do it for us. 559 */ 560 561 if (atkbd_reset) 562 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT)) 563 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys); 564 565 /* 566 * Then we check the keyboard ID. We should get 0xab83 under normal conditions. 567 * Some keyboards report different values, but the first byte is always 0xab or 568 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this 569 * should make sure we don't try to set the LEDs on it. 570 */ 571 572 param[0] = param[1] = 0xa5; /* initialize with invalid values */ 573 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) { 574 575 /* 576 * If the get ID command failed, we check if we can at least set the LEDs on 577 * the keyboard. This should work on every keyboard out there. It also turns 578 * the LEDs off, which we want anyway. 579 */ 580 param[0] = 0; 581 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 582 return -1; 583 atkbd->id = 0xabba; 584 return 0; 585 } 586 587 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */ 588 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */ 589 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */ 590 return -1; 591 592 atkbd->id = (param[0] << 8) | param[1]; 593 594 if (atkbd->id == 0xaca1 && atkbd->translated) { 595 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n"); 596 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n"); 597 return -1; 598 } 599 600 return 0; 601 } 602 603 /* 604 * atkbd_select_set checks if a keyboard has a working Set 3 support, and 605 * sets it into that. Unfortunately there are keyboards that can be switched 606 * to Set 3, but don't work well in that (BTC Multimedia ...) 607 */ 608 609 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra) 610 { 611 struct ps2dev *ps2dev = &atkbd->ps2dev; 612 unsigned char param[2]; 613 614 atkbd->extra = 0; 615 /* 616 * For known special keyboards we can go ahead and set the correct set. 617 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and 618 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards. 619 */ 620 621 if (atkbd->translated) 622 return 2; 623 624 if (atkbd->id == 0xaca1) { 625 param[0] = 3; 626 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET); 627 return 3; 628 } 629 630 if (allow_extra) { 631 param[0] = 0x71; 632 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) { 633 atkbd->extra = 1; 634 return 2; 635 } 636 } 637 638 if (target_set != 3) 639 return 2; 640 641 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) { 642 atkbd->id = param[0] << 8 | param[1]; 643 return 2; 644 } 645 646 param[0] = 3; 647 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 648 return 2; 649 650 param[0] = 0; 651 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET)) 652 return 2; 653 654 if (param[0] != 3) { 655 param[0] = 2; 656 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 657 return 2; 658 } 659 660 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR); 661 662 return 3; 663 } 664 665 static int atkbd_activate(struct atkbd *atkbd) 666 { 667 struct ps2dev *ps2dev = &atkbd->ps2dev; 668 unsigned char param[1]; 669 670 /* 671 * Set the LEDs to a defined state. 672 */ 673 674 param[0] = 0; 675 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 676 return -1; 677 678 /* 679 * Set autorepeat to fastest possible. 680 */ 681 682 param[0] = 0; 683 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP)) 684 return -1; 685 686 /* 687 * Enable the keyboard to receive keystrokes. 688 */ 689 690 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) { 691 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n", 692 ps2dev->serio->phys); 693 return -1; 694 } 695 696 return 0; 697 } 698 699 /* 700 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a 701 * reboot. 702 */ 703 704 static void atkbd_cleanup(struct serio *serio) 705 { 706 struct atkbd *atkbd = serio_get_drvdata(serio); 707 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT); 708 } 709 710 711 /* 712 * atkbd_disconnect() closes and frees. 713 */ 714 715 static void atkbd_disconnect(struct serio *serio) 716 { 717 struct atkbd *atkbd = serio_get_drvdata(serio); 718 719 atkbd_disable(atkbd); 720 721 /* make sure we don't have a command in flight */ 722 synchronize_sched(); /* Allow atkbd_interrupt()s to complete. */ 723 flush_scheduled_work(); 724 725 device_remove_file(&serio->dev, &atkbd_attr_extra); 726 device_remove_file(&serio->dev, &atkbd_attr_scroll); 727 device_remove_file(&serio->dev, &atkbd_attr_set); 728 device_remove_file(&serio->dev, &atkbd_attr_softrepeat); 729 device_remove_file(&serio->dev, &atkbd_attr_softraw); 730 731 input_unregister_device(atkbd->dev); 732 serio_close(serio); 733 serio_set_drvdata(serio, NULL); 734 kfree(atkbd); 735 } 736 737 738 /* 739 * atkbd_set_keycode_table() initializes keyboard's keycode table 740 * according to the selected scancode set 741 */ 742 743 static void atkbd_set_keycode_table(struct atkbd *atkbd) 744 { 745 int i, j; 746 747 memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 748 749 if (atkbd->translated) { 750 for (i = 0; i < 128; i++) { 751 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]]; 752 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80]; 753 if (atkbd->scroll) 754 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++) 755 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2) 756 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode; 757 } 758 } else if (atkbd->set == 3) { 759 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode)); 760 } else { 761 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode)); 762 763 if (atkbd->scroll) 764 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) 765 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode; 766 } 767 } 768 769 /* 770 * atkbd_set_device_attrs() sets up keyboard's input device structure 771 */ 772 773 static void atkbd_set_device_attrs(struct atkbd *atkbd) 774 { 775 struct input_dev *input_dev = atkbd->dev; 776 int i; 777 778 if (atkbd->extra) 779 sprintf(atkbd->name, "AT Set 2 Extra keyboard"); 780 else 781 sprintf(atkbd->name, "AT %s Set %d keyboard", 782 atkbd->translated ? "Translated" : "Raw", atkbd->set); 783 784 sprintf(atkbd->phys, "%s/input0", atkbd->ps2dev.serio->phys); 785 786 input_dev->name = atkbd->name; 787 input_dev->phys = atkbd->phys; 788 input_dev->id.bustype = BUS_I8042; 789 input_dev->id.vendor = 0x0001; 790 input_dev->id.product = atkbd->translated ? 1 : atkbd->set; 791 input_dev->id.version = atkbd->id; 792 input_dev->event = atkbd_event; 793 input_dev->private = atkbd; 794 input_dev->cdev.dev = &atkbd->ps2dev.serio->dev; 795 796 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC); 797 798 if (atkbd->write) { 799 input_dev->evbit[0] |= BIT(EV_LED); 800 input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL); 801 } 802 803 if (atkbd->extra) 804 input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) | 805 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC); 806 807 if (!atkbd->softrepeat) { 808 input_dev->rep[REP_DELAY] = 250; 809 input_dev->rep[REP_PERIOD] = 33; 810 } 811 812 input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN); 813 814 if (atkbd->scroll) { 815 input_dev->evbit[0] |= BIT(EV_REL); 816 input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL); 817 set_bit(BTN_MIDDLE, input_dev->keybit); 818 } 819 820 input_dev->keycode = atkbd->keycode; 821 input_dev->keycodesize = sizeof(unsigned char); 822 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode); 823 824 for (i = 0; i < 512; i++) 825 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL) 826 set_bit(atkbd->keycode[i], input_dev->keybit); 827 } 828 829 /* 830 * atkbd_connect() is called when the serio module finds an interface 831 * that isn't handled yet by an appropriate device driver. We check if 832 * there is an AT keyboard out there and if yes, we register ourselves 833 * to the input module. 834 */ 835 836 static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 837 { 838 struct atkbd *atkbd; 839 struct input_dev *dev; 840 int err = -ENOMEM; 841 842 atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL); 843 dev = input_allocate_device(); 844 if (!atkbd || !dev) 845 goto fail; 846 847 atkbd->dev = dev; 848 ps2_init(&atkbd->ps2dev, serio); 849 INIT_WORK(&atkbd->event_work, atkbd_event_work, atkbd); 850 mutex_init(&atkbd->event_mutex); 851 852 switch (serio->id.type) { 853 854 case SERIO_8042_XL: 855 atkbd->translated = 1; 856 case SERIO_8042: 857 if (serio->write) 858 atkbd->write = 1; 859 break; 860 } 861 862 atkbd->softraw = atkbd_softraw; 863 atkbd->softrepeat = atkbd_softrepeat; 864 atkbd->scroll = atkbd_scroll; 865 866 if (atkbd->softrepeat) 867 atkbd->softraw = 1; 868 869 serio_set_drvdata(serio, atkbd); 870 871 err = serio_open(serio, drv); 872 if (err) 873 goto fail; 874 875 if (atkbd->write) { 876 877 if (atkbd_probe(atkbd)) { 878 serio_close(serio); 879 err = -ENODEV; 880 goto fail; 881 } 882 883 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra); 884 atkbd_activate(atkbd); 885 886 } else { 887 atkbd->set = 2; 888 atkbd->id = 0xab00; 889 } 890 891 atkbd_set_keycode_table(atkbd); 892 atkbd_set_device_attrs(atkbd); 893 894 device_create_file(&serio->dev, &atkbd_attr_extra); 895 device_create_file(&serio->dev, &atkbd_attr_scroll); 896 device_create_file(&serio->dev, &atkbd_attr_set); 897 device_create_file(&serio->dev, &atkbd_attr_softrepeat); 898 device_create_file(&serio->dev, &atkbd_attr_softraw); 899 900 atkbd_enable(atkbd); 901 902 input_register_device(atkbd->dev); 903 904 return 0; 905 906 fail: serio_set_drvdata(serio, NULL); 907 input_free_device(dev); 908 kfree(atkbd); 909 return err; 910 } 911 912 /* 913 * atkbd_reconnect() tries to restore keyboard into a sane state and is 914 * most likely called on resume. 915 */ 916 917 static int atkbd_reconnect(struct serio *serio) 918 { 919 struct atkbd *atkbd = serio_get_drvdata(serio); 920 struct serio_driver *drv = serio->drv; 921 unsigned char param[1]; 922 923 if (!atkbd || !drv) { 924 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n"); 925 return -1; 926 } 927 928 atkbd_disable(atkbd); 929 930 if (atkbd->write) { 931 param[0] = (test_bit(LED_SCROLLL, atkbd->dev->led) ? 1 : 0) 932 | (test_bit(LED_NUML, atkbd->dev->led) ? 2 : 0) 933 | (test_bit(LED_CAPSL, atkbd->dev->led) ? 4 : 0); 934 935 if (atkbd_probe(atkbd)) 936 return -1; 937 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra)) 938 return -1; 939 940 atkbd_activate(atkbd); 941 942 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS)) 943 return -1; 944 } 945 946 atkbd_enable(atkbd); 947 948 return 0; 949 } 950 951 static struct serio_device_id atkbd_serio_ids[] = { 952 { 953 .type = SERIO_8042, 954 .proto = SERIO_ANY, 955 .id = SERIO_ANY, 956 .extra = SERIO_ANY, 957 }, 958 { 959 .type = SERIO_8042_XL, 960 .proto = SERIO_ANY, 961 .id = SERIO_ANY, 962 .extra = SERIO_ANY, 963 }, 964 { 965 .type = SERIO_RS232, 966 .proto = SERIO_PS2SER, 967 .id = SERIO_ANY, 968 .extra = SERIO_ANY, 969 }, 970 { 0 } 971 }; 972 973 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids); 974 975 static struct serio_driver atkbd_drv = { 976 .driver = { 977 .name = "atkbd", 978 }, 979 .description = DRIVER_DESC, 980 .id_table = atkbd_serio_ids, 981 .interrupt = atkbd_interrupt, 982 .connect = atkbd_connect, 983 .reconnect = atkbd_reconnect, 984 .disconnect = atkbd_disconnect, 985 .cleanup = atkbd_cleanup, 986 }; 987 988 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 989 ssize_t (*handler)(struct atkbd *, char *)) 990 { 991 struct serio *serio = to_serio_port(dev); 992 int retval; 993 994 retval = serio_pin_driver(serio); 995 if (retval) 996 return retval; 997 998 if (serio->drv != &atkbd_drv) { 999 retval = -ENODEV; 1000 goto out; 1001 } 1002 1003 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf); 1004 1005 out: 1006 serio_unpin_driver(serio); 1007 return retval; 1008 } 1009 1010 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 1011 ssize_t (*handler)(struct atkbd *, const char *, size_t)) 1012 { 1013 struct serio *serio = to_serio_port(dev); 1014 struct atkbd *atkbd; 1015 int retval; 1016 1017 retval = serio_pin_driver(serio); 1018 if (retval) 1019 return retval; 1020 1021 if (serio->drv != &atkbd_drv) { 1022 retval = -ENODEV; 1023 goto out; 1024 } 1025 1026 atkbd = serio_get_drvdata(serio); 1027 atkbd_disable(atkbd); 1028 retval = handler(atkbd, buf, count); 1029 atkbd_enable(atkbd); 1030 1031 out: 1032 serio_unpin_driver(serio); 1033 return retval; 1034 } 1035 1036 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 1037 { 1038 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0); 1039 } 1040 1041 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 1042 { 1043 struct input_dev *new_dev; 1044 unsigned long value; 1045 char *rest; 1046 1047 if (!atkbd->write) 1048 return -EIO; 1049 1050 value = simple_strtoul(buf, &rest, 10); 1051 if (*rest || value > 1) 1052 return -EINVAL; 1053 1054 if (atkbd->extra != value) { 1055 /* 1056 * Since device's properties will change we need to 1057 * unregister old device. But allocate new one first 1058 * to make sure we have it. 1059 */ 1060 if (!(new_dev = input_allocate_device())) 1061 return -ENOMEM; 1062 input_unregister_device(atkbd->dev); 1063 atkbd->dev = new_dev; 1064 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value); 1065 atkbd_activate(atkbd); 1066 atkbd_set_device_attrs(atkbd); 1067 input_register_device(atkbd->dev); 1068 } 1069 return count; 1070 } 1071 1072 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 1073 { 1074 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0); 1075 } 1076 1077 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 1078 { 1079 struct input_dev *new_dev; 1080 unsigned long value; 1081 char *rest; 1082 1083 value = simple_strtoul(buf, &rest, 10); 1084 if (*rest || value > 1) 1085 return -EINVAL; 1086 1087 if (atkbd->scroll != value) { 1088 if (!(new_dev = input_allocate_device())) 1089 return -ENOMEM; 1090 input_unregister_device(atkbd->dev); 1091 atkbd->dev = new_dev; 1092 atkbd->scroll = value; 1093 atkbd_set_keycode_table(atkbd); 1094 atkbd_set_device_attrs(atkbd); 1095 input_register_device(atkbd->dev); 1096 } 1097 return count; 1098 } 1099 1100 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 1101 { 1102 return sprintf(buf, "%d\n", atkbd->set); 1103 } 1104 1105 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 1106 { 1107 struct input_dev *new_dev; 1108 unsigned long value; 1109 char *rest; 1110 1111 if (!atkbd->write) 1112 return -EIO; 1113 1114 value = simple_strtoul(buf, &rest, 10); 1115 if (*rest || (value != 2 && value != 3)) 1116 return -EINVAL; 1117 1118 if (atkbd->set != value) { 1119 if (!(new_dev = input_allocate_device())) 1120 return -ENOMEM; 1121 input_unregister_device(atkbd->dev); 1122 atkbd->dev = new_dev; 1123 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra); 1124 atkbd_activate(atkbd); 1125 atkbd_set_keycode_table(atkbd); 1126 atkbd_set_device_attrs(atkbd); 1127 input_register_device(atkbd->dev); 1128 } 1129 return count; 1130 } 1131 1132 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 1133 { 1134 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0); 1135 } 1136 1137 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 1138 { 1139 struct input_dev *new_dev; 1140 unsigned long value; 1141 char *rest; 1142 1143 if (!atkbd->write) 1144 return -EIO; 1145 1146 value = simple_strtoul(buf, &rest, 10); 1147 if (*rest || value > 1) 1148 return -EINVAL; 1149 1150 if (atkbd->softrepeat != value) { 1151 if (!(new_dev = input_allocate_device())) 1152 return -ENOMEM; 1153 input_unregister_device(atkbd->dev); 1154 atkbd->dev = new_dev; 1155 atkbd->softrepeat = value; 1156 if (atkbd->softrepeat) 1157 atkbd->softraw = 1; 1158 atkbd_set_device_attrs(atkbd); 1159 input_register_device(atkbd->dev); 1160 } 1161 return count; 1162 } 1163 1164 1165 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 1166 { 1167 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0); 1168 } 1169 1170 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 1171 { 1172 struct input_dev *new_dev; 1173 unsigned long value; 1174 char *rest; 1175 1176 value = simple_strtoul(buf, &rest, 10); 1177 if (*rest || value > 1) 1178 return -EINVAL; 1179 1180 if (atkbd->softraw != value) { 1181 if (!(new_dev = input_allocate_device())) 1182 return -ENOMEM; 1183 input_unregister_device(atkbd->dev); 1184 atkbd->dev = new_dev; 1185 atkbd->softraw = value; 1186 atkbd_set_device_attrs(atkbd); 1187 input_register_device(atkbd->dev); 1188 } 1189 return count; 1190 } 1191 1192 1193 static int __init atkbd_init(void) 1194 { 1195 serio_register_driver(&atkbd_drv); 1196 return 0; 1197 } 1198 1199 static void __exit atkbd_exit(void) 1200 { 1201 serio_unregister_driver(&atkbd_drv); 1202 } 1203 1204 module_init(atkbd_init); 1205 module_exit(atkbd_exit); 1206