Input: Fix fast scrolling scancodes in atkbd.c
[linux-3.10.git] / drivers / input / keyboard / atkbd.c
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,     0x9d },
175         { ATKBD_SCR_4,     0xa4 },
176         { ATKBD_SCR_8,     0x9b },
177         { ATKBD_SCR_CLICK, 0xe0 },
178         { ATKBD_SCR_LEFT,  0xcb },
179         { ATKBD_SCR_RIGHT, 0xd2 },
180 };
181
182 /*
183  * The atkbd control structure
184  */
185
186 struct atkbd {
187
188         struct ps2dev   ps2dev;
189
190         /* Written only during init */
191         char name[64];
192         char phys[32];
193         struct input_dev dev;
194
195         unsigned short id;
196         unsigned char keycode[512];
197         unsigned char set;
198         unsigned char translated;
199         unsigned char extra;
200         unsigned char write;
201         unsigned char softrepeat;
202         unsigned char softraw;
203         unsigned char scroll;
204         unsigned char enabled;
205
206         /* Accessed only from interrupt */
207         unsigned char emul;
208         unsigned char resend;
209         unsigned char release;
210         unsigned char bat_xl;
211         unsigned 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);