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