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 = 1; 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, 0xa9 }, 175 { ATKBD_SCR_4, 0xb6 }, 176 { ATKBD_SCR_8, 0xa7 }, 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, 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, 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 < 32 && period[i] < dev->rep[REP_PERIOD]) i++; 469 while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++; 470 dev->rep[REP_PERIOD] = period[i]; 471 dev->rep[REP_DELAY] = delay[j]; 472 param[0] = i | (j << 5); 473 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP); 474 475 return 0; 476 } 477 478 return -1; 479 } 480 481 /* 482 * atkbd_enable() signals that interrupt handler is allowed to 483 * generate input events. 484 */ 485 486 static inline void atkbd_enable(struct atkbd *atkbd) 487 { 488 serio_pause_rx(atkbd->ps2dev.serio); 489 atkbd->enabled = 1; 490 serio_continue_rx(atkbd->ps2dev.serio); 491 } 492 493 /* 494 * atkbd_disable() tells input handler that all incoming data except 495 * for ACKs and command response should be dropped. 496 */ 497 498 static inline void atkbd_disable(struct atkbd *atkbd) 499 { 500 serio_pause_rx(atkbd->ps2dev.serio); 501 atkbd->enabled = 0; 502 serio_continue_rx(atkbd->ps2dev.serio); 503 } 504 505 /* 506 * atkbd_probe() probes for an AT keyboard on a serio port. 507 */ 508 509 static int atkbd_probe(struct atkbd *atkbd) 510 { 511 struct ps2dev *ps2dev = &atkbd->ps2dev; 512 unsigned char param[2]; 513 514 /* 515 * Some systems, where the bit-twiddling when testing the io-lines of the 516 * controller may confuse the keyboard need a full reset of the keyboard. On 517 * these systems the BIOS also usually doesn't do it for us. 518 */ 519 520 if (atkbd_reset) 521 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT)) 522 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys); 523 524 /* 525 * Then we check the keyboard ID. We should get 0xab83 under normal conditions. 526 * Some keyboards report different values, but the first byte is always 0xab or 527 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this 528 * should make sure we don't try to set the LEDs on it. 529 */ 530 531 param[0] = param[1] = 0xa5; /* initialize with invalid values */ 532 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) { 533 534 /* 535 * If the get ID command failed, we check if we can at least set the LEDs on 536 * the keyboard. This should work on every keyboard out there. It also turns 537 * the LEDs off, which we want anyway. 538 */ 539 param[0] = 0; 540 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 541 return -1; 542 atkbd->id = 0xabba; 543 return 0; 544 } 545 546 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */ 547 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */ 548 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */ 549 return -1; 550 551 atkbd->id = (param[0] << 8) | param[1]; 552 553 if (atkbd->id == 0xaca1 && atkbd->translated) { 554 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n"); 555 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n"); 556 return -1; 557 } 558 559 return 0; 560 } 561 562 /* 563 * atkbd_select_set checks if a keyboard has a working Set 3 support, and 564 * sets it into that. Unfortunately there are keyboards that can be switched 565 * to Set 3, but don't work well in that (BTC Multimedia ...) 566 */ 567 568 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra) 569 { 570 struct ps2dev *ps2dev = &atkbd->ps2dev; 571 unsigned char param[2]; 572 573 atkbd->extra = 0; 574 /* 575 * For known special keyboards we can go ahead and set the correct set. 576 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and 577 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards. 578 */ 579 580 if (atkbd->translated) 581 return 2; 582 583 if (atkbd->id == 0xaca1) { 584 param[0] = 3; 585 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET); 586 return 3; 587 } 588 589 if (allow_extra) { 590 param[0] = 0x71; 591 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) { 592 atkbd->extra = 1; 593 return 2; 594 } 595 } 596 597 if (target_set != 3) 598 return 2; 599 600 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) { 601 atkbd->id = param[0] << 8 | param[1]; 602 return 2; 603 } 604 605 param[0] = 3; 606 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 607 return 2; 608 609 param[0] = 0; 610 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET)) 611 return 2; 612 613 if (param[0] != 3) { 614 param[0] = 2; 615 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 616 return 2; 617 } 618 619 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR); 620 621 return 3; 622 } 623 624 static int atkbd_activate(struct atkbd *atkbd) 625 { 626 struct ps2dev *ps2dev = &atkbd->ps2dev; 627 unsigned char param[1]; 628 629 /* 630 * Set the LEDs to a defined state. 631 */ 632 633 param[0] = 0; 634 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 635 return -1; 636 637 /* 638 * Set autorepeat to fastest possible. 639 */ 640 641 param[0] = 0; 642 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP)) 643 return -1; 644 645 /* 646 * Enable the keyboard to receive keystrokes. 647 */ 648 649 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) { 650 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n", 651 ps2dev->serio->phys); 652 return -1; 653 } 654 655 return 0; 656 } 657 658 /* 659 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a 660 * reboot. 661 */ 662 663 static void atkbd_cleanup(struct serio *serio) 664 { 665 struct atkbd *atkbd = serio_get_drvdata(serio); 666 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT); 667 } 668 669 670 /* 671 * atkbd_disconnect() closes and frees. 672 */ 673 674 static void atkbd_disconnect(struct serio *serio) 675 { 676 struct atkbd *atkbd = serio_get_drvdata(serio); 677 678 atkbd_disable(atkbd); 679 680 /* make sure we don't have a command in flight */ 681 synchronize_kernel(); 682 flush_scheduled_work(); 683 684 device_remove_file(&serio->dev, &atkbd_attr_extra); 685 device_remove_file(&serio->dev, &atkbd_attr_scroll); 686 device_remove_file(&serio->dev, &atkbd_attr_set); 687 device_remove_file(&serio->dev, &atkbd_attr_softrepeat); 688 device_remove_file(&serio->dev, &atkbd_attr_softraw); 689 690 input_unregister_device(&atkbd->dev); 691 serio_close(serio); 692 serio_set_drvdata(serio, NULL); 693 kfree(atkbd); 694 } 695 696 697 /* 698 * atkbd_set_device_attrs() initializes keyboard's keycode table 699 * according to the selected scancode set 700 */ 701 702 static void atkbd_set_keycode_table(struct atkbd *atkbd) 703 { 704 int i, j; 705 706 memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 707 708 if (atkbd->translated) { 709 for (i = 0; i < 128; i++) { 710 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]]; 711 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80]; 712 if (atkbd->scroll) 713 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++) 714 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2) 715 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode; 716 } 717 } else if (atkbd->set == 3) { 718 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode)); 719 } else { 720 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode)); 721 722 if (atkbd->scroll) 723 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) 724 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode; 725 } 726 } 727 728 /* 729 * atkbd_set_device_attrs() sets up keyboard's input device structure 730 */ 731 732 static void atkbd_set_device_attrs(struct atkbd *atkbd) 733 { 734 int i; 735 736 memset(&atkbd->dev, 0, sizeof(struct input_dev)); 737 738 init_input_dev(&atkbd->dev); 739 740 atkbd->dev.name = atkbd->name; 741 atkbd->dev.phys = atkbd->phys; 742 atkbd->dev.id.bustype = BUS_I8042; 743 atkbd->dev.id.vendor = 0x0001; 744 atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set; 745 atkbd->dev.id.version = atkbd->id; 746 atkbd->dev.event = atkbd_event; 747 atkbd->dev.private = atkbd; 748 atkbd->dev.dev = &atkbd->ps2dev.serio->dev; 749 750 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC); 751 752 if (atkbd->write) { 753 atkbd->dev.evbit[0] |= BIT(EV_LED); 754 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL); 755 } 756 757 if (atkbd->extra) 758 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) | 759 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC); 760 761 if (!atkbd->softrepeat) { 762 atkbd->dev.rep[REP_DELAY] = 250; 763 atkbd->dev.rep[REP_PERIOD] = 33; 764 } 765 766 atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN); 767 768 if (atkbd->scroll) { 769 atkbd->dev.evbit[0] |= BIT(EV_REL); 770 atkbd->dev.relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL); 771 set_bit(BTN_MIDDLE, atkbd->dev.keybit); 772 } 773 774 atkbd->dev.keycode = atkbd->keycode; 775 atkbd->dev.keycodesize = sizeof(unsigned char); 776 atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode); 777 778 for (i = 0; i < 512; i++) 779 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL) 780 set_bit(atkbd->keycode[i], atkbd->dev.keybit); 781 } 782 783 /* 784 * atkbd_connect() is called when the serio module finds an interface 785 * that isn't handled yet by an appropriate device driver. We check if 786 * there is an AT keyboard out there and if yes, we register ourselves 787 * to the input module. 788 */ 789 790 static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 791 { 792 struct atkbd *atkbd; 793 int err; 794 795 if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL))) 796 return - ENOMEM; 797 798 memset(atkbd, 0, sizeof(struct atkbd)); 799 800 ps2_init(&atkbd->ps2dev, serio); 801 802 switch (serio->id.type) { 803 804 case SERIO_8042_XL: 805 atkbd->translated = 1; 806 case SERIO_8042: 807 if (serio->write) 808 atkbd->write = 1; 809 break; 810 } 811 812 atkbd->softraw = atkbd_softraw; 813 atkbd->softrepeat = atkbd_softrepeat; 814 atkbd->scroll = atkbd_scroll; 815 816 if (!atkbd->write) 817 atkbd->softrepeat = 1; 818 819 if (atkbd->softrepeat) 820 atkbd->softraw = 1; 821 822 serio_set_drvdata(serio, atkbd); 823 824 err = serio_open(serio, drv); 825 if (err) { 826 serio_set_drvdata(serio, NULL); 827 kfree(atkbd); 828 return err; 829 } 830 831 if (atkbd->write) { 832 833 if (atkbd_probe(atkbd)) { 834 serio_close(serio); 835 serio_set_drvdata(serio, NULL); 836 kfree(atkbd); 837 return -ENODEV; 838 } 839 840 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra); 841 atkbd_activate(atkbd); 842 843 } else { 844 atkbd->set = 2; 845 atkbd->id = 0xab00; 846 } 847 848 if (atkbd->extra) 849 sprintf(atkbd->name, "AT Set 2 Extra keyboard"); 850 else 851 sprintf(atkbd->name, "AT %s Set %d keyboard", 852 atkbd->translated ? "Translated" : "Raw", atkbd->set); 853 854 sprintf(atkbd->phys, "%s/input0", serio->phys); 855 856 atkbd_set_keycode_table(atkbd); 857 atkbd_set_device_attrs(atkbd); 858 859 input_register_device(&atkbd->dev); 860 861 device_create_file(&serio->dev, &atkbd_attr_extra); 862 device_create_file(&serio->dev, &atkbd_attr_scroll); 863 device_create_file(&serio->dev, &atkbd_attr_set); 864 device_create_file(&serio->dev, &atkbd_attr_softrepeat); 865 device_create_file(&serio->dev, &atkbd_attr_softraw); 866 867 atkbd_enable(atkbd); 868 869 printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys); 870 871 return 0; 872 } 873 874 /* 875 * atkbd_reconnect() tries to restore keyboard into a sane state and is 876 * most likely called on resume. 877 */ 878 879 static int atkbd_reconnect(struct serio *serio) 880 { 881 struct atkbd *atkbd = serio_get_drvdata(serio); 882 struct serio_driver *drv = serio->drv; 883 unsigned char param[1]; 884 885 if (!atkbd || !drv) { 886 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n"); 887 return -1; 888 } 889 890 atkbd_disable(atkbd); 891 892 if (atkbd->write) { 893 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0) 894 | (test_bit(LED_NUML, atkbd->dev.led) ? 2 : 0) 895 | (test_bit(LED_CAPSL, atkbd->dev.led) ? 4 : 0); 896 897 if (atkbd_probe(atkbd)) 898 return -1; 899 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra)) 900 return -1; 901 902 atkbd_activate(atkbd); 903 904 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS)) 905 return -1; 906 } 907 908 atkbd_enable(atkbd); 909 910 return 0; 911 } 912 913 static struct serio_device_id atkbd_serio_ids[] = { 914 { 915 .type = SERIO_8042, 916 .proto = SERIO_ANY, 917 .id = SERIO_ANY, 918 .extra = SERIO_ANY, 919 }, 920 { 921 .type = SERIO_8042_XL, 922 .proto = SERIO_ANY, 923 .id = SERIO_ANY, 924 .extra = SERIO_ANY, 925 }, 926 { 927 .type = SERIO_RS232, 928 .proto = SERIO_PS2SER, 929 .id = SERIO_ANY, 930 .extra = SERIO_ANY, 931 }, 932 { 0 } 933 }; 934 935 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids); 936 937 static struct serio_driver atkbd_drv = { 938 .driver = { 939 .name = "atkbd", 940 }, 941 .description = DRIVER_DESC, 942 .id_table = atkbd_serio_ids, 943 .interrupt = atkbd_interrupt, 944 .connect = atkbd_connect, 945 .reconnect = atkbd_reconnect, 946 .disconnect = atkbd_disconnect, 947 .cleanup = atkbd_cleanup, 948 }; 949 950 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 951 ssize_t (*handler)(struct atkbd *, char *)) 952 { 953 struct serio *serio = to_serio_port(dev); 954 int retval; 955 956 retval = serio_pin_driver(serio); 957 if (retval) 958 return retval; 959 960 if (serio->drv != &atkbd_drv) { 961 retval = -ENODEV; 962 goto out; 963 } 964 965 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf); 966 967 out: 968 serio_unpin_driver(serio); 969 return retval; 970 } 971 972 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 973 ssize_t (*handler)(struct atkbd *, const char *, size_t)) 974 { 975 struct serio *serio = to_serio_port(dev); 976 struct atkbd *atkbd; 977 int retval; 978 979 retval = serio_pin_driver(serio); 980 if (retval) 981 return retval; 982 983 if (serio->drv != &atkbd_drv) { 984 retval = -ENODEV; 985 goto out; 986 } 987 988 atkbd = serio_get_drvdata(serio); 989 atkbd_disable(atkbd); 990 retval = handler(atkbd, buf, count); 991 atkbd_enable(atkbd); 992 993 out: 994 serio_unpin_driver(serio); 995 return retval; 996 } 997 998 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 999 { 1000 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0); 1001 } 1002 1003 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 1004 { 1005 unsigned long value; 1006 char *rest; 1007 1008 if (!atkbd->write) 1009 return -EIO; 1010 1011 value = simple_strtoul(buf, &rest, 10); 1012 if (*rest || value > 1) 1013 return -EINVAL; 1014 1015 if (atkbd->extra != value) { 1016 /* unregister device as it's properties will change */ 1017 input_unregister_device(&atkbd->dev); 1018 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value); 1019 atkbd_activate(atkbd); 1020 atkbd_set_device_attrs(atkbd); 1021 input_register_device(&atkbd->dev); 1022 } 1023 return count; 1024 } 1025 1026 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 1027 { 1028 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0); 1029 } 1030 1031 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 1032 { 1033 unsigned long value; 1034 char *rest; 1035 1036 value = simple_strtoul(buf, &rest, 10); 1037 if (*rest || value > 1) 1038 return -EINVAL; 1039 1040 if (atkbd->scroll != value) { 1041 /* unregister device as it's properties will change */ 1042 input_unregister_device(&atkbd->dev); 1043 atkbd->scroll = value; 1044 atkbd_set_keycode_table(atkbd); 1045 atkbd_set_device_attrs(atkbd); 1046 input_register_device(&atkbd->dev); 1047 } 1048 return count; 1049 } 1050 1051 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 1052 { 1053 return sprintf(buf, "%d\n", atkbd->set); 1054 } 1055 1056 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 1057 { 1058 unsigned long value; 1059 char *rest; 1060 1061 if (!atkbd->write) 1062 return -EIO; 1063 1064 value = simple_strtoul(buf, &rest, 10); 1065 if (*rest || (value != 2 && value != 3)) 1066 return -EINVAL; 1067 1068 if (atkbd->set != value) { 1069 /* unregister device as it's properties will change */ 1070 input_unregister_device(&atkbd->dev); 1071 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra); 1072 atkbd_activate(atkbd); 1073 atkbd_set_keycode_table(atkbd); 1074 atkbd_set_device_attrs(atkbd); 1075 input_register_device(&atkbd->dev); 1076 } 1077 return count; 1078 } 1079 1080 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 1081 { 1082 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0); 1083 } 1084 1085 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 1086 { 1087 unsigned long value; 1088 char *rest; 1089 1090 if (!atkbd->write) 1091 return -EIO; 1092 1093 value = simple_strtoul(buf, &rest, 10); 1094 if (*rest || value > 1) 1095 return -EINVAL; 1096 1097 if (atkbd->softrepeat != value) { 1098 /* unregister device as it's properties will change */ 1099 input_unregister_device(&atkbd->dev); 1100 atkbd->softrepeat = value; 1101 if (atkbd->softrepeat) 1102 atkbd->softraw = 1; 1103 atkbd_set_device_attrs(atkbd); 1104 input_register_device(&atkbd->dev); 1105 } 1106 1107 return count; 1108 } 1109 1110 1111 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 1112 { 1113 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0); 1114 } 1115 1116 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 1117 { 1118 unsigned long value; 1119 char *rest; 1120 1121 value = simple_strtoul(buf, &rest, 10); 1122 if (*rest || value > 1) 1123 return -EINVAL; 1124 1125 if (atkbd->softraw != value) { 1126 /* unregister device as it's properties will change */ 1127 input_unregister_device(&atkbd->dev); 1128 atkbd->softraw = value; 1129 atkbd_set_device_attrs(atkbd); 1130 input_register_device(&atkbd->dev); 1131 } 1132 return count; 1133 } 1134 1135 1136 static int __init atkbd_init(void) 1137 { 1138 serio_register_driver(&atkbd_drv); 1139 return 0; 1140 } 1141 1142 static void __exit atkbd_exit(void) 1143 { 1144 serio_unregister_driver(&atkbd_drv); 1145 } 1146 1147 module_init(atkbd_init); 1148 module_exit(atkbd_exit); 1149