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