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