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