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