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