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