?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kbuild: fix silentoldconfig with make O=
[linux-2.6/verdex.git] / drivers / input / keyboard / atkbd.c
blob1ad8c2ee7dbf337b4417e93cfcf158a42895700a
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);
Verdex Pro support