Input: atkbd - add keyboard quirk for HP Pavilion ZV6100 laptop
[linux-2.6] / 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/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/init.h>
25 #include <linux/input.h>
26 #include <linux/serio.h>
27 #include <linux/workqueue.h>
28 #include <linux/libps2.h>
29 #include <linux/mutex.h>
30 #include <linux/dmi.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;
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 /*
67  * Scancode to keycode tables. These are just the default setting, and
68  * are loadable via an userland utility.
69  */
70
71 static const unsigned short atkbd_set2_keycode[512] = {
72
73 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
74
75 /* XXX: need a more general approach */
76
77 #include "hpps2atkbd.h" /* include the keyboard scancodes */
78
79 #else
80           0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
81           0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
82           0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
83           0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
84           0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
85           0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
86           0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
87          82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
88
89           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
90         217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
91         173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
92         159,  0,115,  0,164,  0,  0,116,158,  0,172,166,  0,  0,  0,142,
93         157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
94         226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
95           0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
96         110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
97
98           0,  0,  0, 65, 99,
99 #endif
100 };
101
102 static const unsigned short atkbd_set3_keycode[512] = {
103
104           0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
105         131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
106         134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
107         136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
108         125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
109         113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
110         108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
111          82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,
112
113         184,185,186,187, 74, 94, 92, 93,  0,  0,  0,125,126,127,112,  0,
114           0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
115         148,149,147,140
116 };
117
118 static const unsigned short atkbd_unxlate_table[128] = {
119           0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
120          21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
121          35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
122          50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
123          11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
124         114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
125          71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
126          19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
127 };
128
129 #define ATKBD_CMD_SETLEDS       0x10ed
130 #define ATKBD_CMD_GSCANSET      0x11f0
131 #define ATKBD_CMD_SSCANSET      0x10f0
132 #define ATKBD_CMD_GETID         0x02f2
133 #define ATKBD_CMD_SETREP        0x10f3
134 #define ATKBD_CMD_ENABLE        0x00f4
135 #define ATKBD_CMD_RESET_DIS     0x00f5
136 #define ATKBD_CMD_SETALL_MBR    0x00fa
137 #define ATKBD_CMD_RESET_BAT     0x02ff
138 #define ATKBD_CMD_RESEND        0x00fe
139 #define ATKBD_CMD_EX_ENABLE     0x10ea
140 #define ATKBD_CMD_EX_SETLEDS    0x20eb
141 #define ATKBD_CMD_OK_GETID      0x02e8
142
143 #define ATKBD_RET_ACK           0xfa
144 #define ATKBD_RET_NAK           0xfe
145 #define ATKBD_RET_BAT           0xaa
146 #define ATKBD_RET_EMUL0         0xe0
147 #define ATKBD_RET_EMUL1         0xe1
148 #define ATKBD_RET_RELEASE       0xf0
149 #define ATKBD_RET_HANJA         0xf1
150 #define ATKBD_RET_HANGEUL       0xf2
151 #define ATKBD_RET_ERR           0xff
152
153 #define ATKBD_KEY_UNKNOWN         0
154 #define ATKBD_KEY_NULL          255
155
156 #define ATKBD_SCR_1             254
157 #define ATKBD_SCR_2             253
158 #define ATKBD_SCR_4             252
159 #define ATKBD_SCR_8             251
160 #define ATKBD_SCR_CLICK         250
161 #define ATKBD_SCR_LEFT          249
162 #define ATKBD_SCR_RIGHT         248
163
164 #define ATKBD_SPECIAL           ATKBD_SCR_RIGHT
165
166 #define ATKBD_LED_EVENT_BIT     0
167 #define ATKBD_REP_EVENT_BIT     1
168
169 #define ATKBD_XL_ERR            0x01
170 #define ATKBD_XL_BAT            0x02
171 #define ATKBD_XL_ACK            0x04
172 #define ATKBD_XL_NAK            0x08
173 #define ATKBD_XL_HANGEUL        0x10
174 #define ATKBD_XL_HANJA          0x20
175
176 static const struct {
177         unsigned char keycode;
178         unsigned char set2;
179 } atkbd_scroll_keys[] = {
180         { ATKBD_SCR_1,     0xc5 },
181         { ATKBD_SCR_2,     0x9d },
182         { ATKBD_SCR_4,     0xa4 },
183         { ATKBD_SCR_8,     0x9b },
184         { ATKBD_SCR_CLICK, 0xe0 },
185         { ATKBD_SCR_LEFT,  0xcb },
186         { ATKBD_SCR_RIGHT, 0xd2 },
187 };
188
189 /*
190  * The atkbd control structure
191  */
192
193 struct atkbd {
194
195         struct ps2dev ps2dev;
196         struct input_dev *dev;
197
198         /* Written only during init */
199         char name[64];
200         char phys[32];
201
202         unsigned short id;
203         unsigned short keycode[512];
204         DECLARE_BITMAP(force_release_mask, 512);
205         unsigned char set;
206         unsigned char translated;
207         unsigned char extra;
208         unsigned char write;
209         unsigned char softrepeat;
210         unsigned char softraw;
211         unsigned char scroll;
212         unsigned char enabled;
213
214         /* Accessed only from interrupt */
215         unsigned char emul;
216         unsigned char resend;
217         unsigned char release;
218         unsigned long xl_bit;
219         unsigned int last;
220         unsigned long time;
221         unsigned long err_count;
222
223         struct delayed_work event_work;
224         unsigned long event_jiffies;
225         struct mutex event_mutex;
226         unsigned long event_mask;
227 };
228
229 /*
230  * System-specific ketymap fixup routine
231  */
232 static void (*atkbd_platform_fixup)(struct atkbd *);
233
234 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
235                                 ssize_t (*handler)(struct atkbd *, char *));
236 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
237                                 ssize_t (*handler)(struct atkbd *, const char *, size_t));
238 #define ATKBD_DEFINE_ATTR(_name)                                                \
239 static ssize_t atkbd_show_##_name(struct atkbd *, char *);                      \
240 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);         \
241 static ssize_t atkbd_do_show_##_name(struct device *d,                          \
242                                 struct device_attribute *attr, char *b)         \
243 {                                                                               \
244         return atkbd_attr_show_helper(d, b, atkbd_show_##_name);                \
245 }                                                                               \
246 static ssize_t atkbd_do_set_##_name(struct device *d,                           \
247                         struct device_attribute *attr, const char *b, size_t s) \
248 {                                                                               \
249         return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);               \
250 }                                                                               \
251 static struct device_attribute atkbd_attr_##_name =                             \
252         __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
253
254 ATKBD_DEFINE_ATTR(extra);
255 ATKBD_DEFINE_ATTR(scroll);
256 ATKBD_DEFINE_ATTR(set);
257 ATKBD_DEFINE_ATTR(softrepeat);
258 ATKBD_DEFINE_ATTR(softraw);
259
260 #define ATKBD_DEFINE_RO_ATTR(_name)                                             \
261 static ssize_t atkbd_show_##_name(struct atkbd *, char *);                      \
262 static ssize_t atkbd_do_show_##_name(struct device *d,                          \
263                                 struct device_attribute *attr, char *b)         \
264 {                                                                               \
265         return atkbd_attr_show_helper(d, b, atkbd_show_##_name);                \
266 }                                                                               \
267 static struct device_attribute atkbd_attr_##_name =                             \
268         __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
269
270 ATKBD_DEFINE_RO_ATTR(err_count);
271
272 static struct attribute *atkbd_attributes[] = {
273         &atkbd_attr_extra.attr,
274         &atkbd_attr_scroll.attr,
275         &atkbd_attr_set.attr,
276         &atkbd_attr_softrepeat.attr,
277         &atkbd_attr_softraw.attr,
278         &atkbd_attr_err_count.attr,
279         NULL
280 };
281
282 static struct attribute_group atkbd_attribute_group = {
283         .attrs  = atkbd_attributes,
284 };
285
286 static const unsigned int xl_table[] = {
287         ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
288         ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
289 };
290
291 /*
292  * Checks if we should mangle the scancode to extract 'release' bit
293  * in translated mode.
294  */
295 static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
296 {
297         int i;
298
299         if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
300                 return 0;
301
302         for (i = 0; i < ARRAY_SIZE(xl_table); i++)
303                 if (code == xl_table[i])
304                         return test_bit(i, &xl_bit);
305
306         return 1;
307 }
308
309 /*
310  * Calculates new value of xl_bit so the driver can distinguish
311  * between make/break pair of scancodes for select keys and PS/2
312  * protocol responses.
313  */
314 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
315 {
316         int i;
317
318         for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
319                 if (!((code ^ xl_table[i]) & 0x7f)) {
320                         if (code & 0x80)
321                                 __clear_bit(i, &atkbd->xl_bit);
322                         else
323                                 __set_bit(i, &atkbd->xl_bit);
324                         break;
325                 }
326         }
327 }
328
329 /*
330  * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
331  * keeping kernel 2.4 compatibility for set 2
332  */
333 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
334 {
335         if (atkbd->set == 3) {
336                 if (atkbd->emul == 1)
337                         code |= 0x100;
338         } else {
339                 code = (code & 0x7f) | ((code & 0x80) << 1);
340                 if (atkbd->emul == 1)
341                         code |= 0x80;
342         }
343
344         return code;
345 }
346
347 /*
348  * atkbd_interrupt(). Here takes place processing of data received from
349  * the keyboard into events.
350  */
351
352 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
353                         unsigned int flags)
354 {
355         struct atkbd *atkbd = serio_get_drvdata(serio);
356         struct input_dev *dev = atkbd->dev;
357         unsigned int code = data;
358         int scroll = 0, hscroll = 0, click = -1;
359         int value;
360         unsigned short keycode;
361
362 #ifdef ATKBD_DEBUG
363         printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
364 #endif
365
366 #if !defined(__i386__) && !defined (__x86_64__)
367         if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
368                 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
369                 serio_write(serio, ATKBD_CMD_RESEND);
370                 atkbd->resend = 1;
371                 goto out;
372         }
373
374         if (!flags && data == ATKBD_RET_ACK)
375                 atkbd->resend = 0;
376 #endif
377
378         if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
379                 if  (ps2_handle_ack(&atkbd->ps2dev, data))
380                         goto out;
381
382         if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
383                 if  (ps2_handle_response(&atkbd->ps2dev, data))
384                         goto out;
385
386         if (!atkbd->enabled)
387                 goto out;
388
389         input_event(dev, EV_MSC, MSC_RAW, code);
390
391         if (atkbd->translated) {
392
393                 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
394                         atkbd->release = code >> 7;
395                         code &= 0x7f;
396                 }
397
398                 if (!atkbd->emul)
399                         atkbd_calculate_xl_bit(atkbd, data);
400         }
401
402         switch (code) {
403                 case ATKBD_RET_BAT:
404                         atkbd->enabled = 0;
405                         serio_reconnect(atkbd->ps2dev.serio);
406                         goto out;
407                 case ATKBD_RET_EMUL0:
408                         atkbd->emul = 1;
409                         goto out;
410                 case ATKBD_RET_EMUL1:
411                         atkbd->emul = 2;
412                         goto out;
413                 case ATKBD_RET_RELEASE:
414                         atkbd->release = 1;
415                         goto out;
416                 case ATKBD_RET_ACK:
417                 case ATKBD_RET_NAK:
418                         if (printk_ratelimit())
419                                 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. "
420                                        "Some program might be trying access hardware directly.\n",
421                                        data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
422                         goto out;
423                 case ATKBD_RET_ERR:
424                         atkbd->err_count++;
425 #ifdef ATKBD_DEBUG
426                         printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
427 #endif
428                         goto out;
429         }
430
431         code = atkbd_compat_scancode(atkbd, code);
432
433         if (atkbd->emul && --atkbd->emul)
434                 goto out;
435
436         keycode = atkbd->keycode[code];
437
438         if (keycode != ATKBD_KEY_NULL)
439                 input_event(dev, EV_MSC, MSC_SCAN, code);
440
441         switch (keycode) {
442                 case ATKBD_KEY_NULL:
443                         break;
444                 case ATKBD_KEY_UNKNOWN:
445                         printk(KERN_WARNING
446                                "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n",
447                                atkbd->release ? "released" : "pressed",
448                                atkbd->translated ? "translated" : "raw",
449                                atkbd->set, code, serio->phys);
450                         printk(KERN_WARNING
451                                "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
452                                code & 0x80 ? "e0" : "", code & 0x7f);
453                         input_sync(dev);
454                         break;
455                 case ATKBD_SCR_1:
456                         scroll = 1 - atkbd->release * 2;
457                         break;
458                 case ATKBD_SCR_2:
459                         scroll = 2 - atkbd->release * 4;
460                         break;
461                 case ATKBD_SCR_4:
462                         scroll = 4 - atkbd->release * 8;
463                         break;
464                 case ATKBD_SCR_8:
465                         scroll = 8 - atkbd->release * 16;
466                         break;
467                 case ATKBD_SCR_CLICK:
468                         click = !atkbd->release;
469                         break;
470                 case ATKBD_SCR_LEFT:
471                         hscroll = -1;
472                         break;
473                 case ATKBD_SCR_RIGHT:
474                         hscroll = 1;
475                         break;
476                 default:
477                         if (atkbd->release) {
478                                 value = 0;
479                                 atkbd->last = 0;
480                         } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
481                                 /* Workaround Toshiba laptop multiple keypress */
482                                 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
483                         } else {
484                                 value = 1;
485                                 atkbd->last = code;
486                                 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
487                         }
488
489                         input_event(dev, EV_KEY, keycode, value);
490                         input_sync(dev);
491
492                         if (value && test_bit(code, atkbd->force_release_mask)) {
493                                 input_report_key(dev, keycode, 0);
494                                 input_sync(dev);
495                         }
496         }
497
498         if (atkbd->scroll) {
499                 if (click != -1)
500                         input_report_key(dev, BTN_MIDDLE, click);
501                 input_report_rel(dev, REL_WHEEL, scroll);
502                 input_report_rel(dev, REL_HWHEEL, hscroll);
503                 input_sync(dev);
504         }
505
506         atkbd->release = 0;
507 out:
508         return IRQ_HANDLED;
509 }
510
511 static int atkbd_set_repeat_rate(struct atkbd *atkbd)
512 {
513         const short period[32] =
514                 { 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
515                  133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
516         const short delay[4] =
517                 { 250, 500, 750, 1000 };
518
519         struct input_dev *dev = atkbd->dev;
520         unsigned char param;
521         int i = 0, j = 0;
522
523         while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
524                 i++;
525         dev->rep[REP_PERIOD] = period[i];
526
527         while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
528                 j++;
529         dev->rep[REP_DELAY] = delay[j];
530
531         param = i | (j << 5);
532         return ps2_command(&atkbd->ps2dev, &param, ATKBD_CMD_SETREP);
533 }
534
535 static int atkbd_set_leds(struct atkbd *atkbd)
536 {
537         struct input_dev *dev = atkbd->dev;
538         unsigned char param[2];
539
540         param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
541                  | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
542                  | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
543         if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
544                 return -1;
545
546         if (atkbd->extra) {
547                 param[0] = 0;
548                 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
549                          | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
550                          | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
551                          | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
552                          | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
553                 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
554                         return -1;
555         }
556
557         return 0;
558 }
559
560 /*
561  * atkbd_event_work() is used to complete processing of events that
562  * can not be processed by input_event() which is often called from
563  * interrupt context.
564  */
565
566 static void atkbd_event_work(struct work_struct *work)
567 {
568         struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
569
570         mutex_lock(&atkbd->event_mutex);
571
572         if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
573                 atkbd_set_leds(atkbd);
574
575         if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
576                 atkbd_set_repeat_rate(atkbd);
577
578         mutex_unlock(&atkbd->event_mutex);
579 }
580
581 /*
582  * Schedule switch for execution. We need to throttle requests,
583  * otherwise keyboard may become unresponsive.
584  */
585 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
586 {
587         unsigned long delay = msecs_to_jiffies(50);
588
589         if (time_after(jiffies, atkbd->event_jiffies + delay))
590                 delay = 0;
591
592         atkbd->event_jiffies = jiffies;
593         set_bit(event_bit, &atkbd->event_mask);
594         wmb();
595         schedule_delayed_work(&atkbd->event_work, delay);
596 }
597
598 /*
599  * Event callback from the input module. Events that change the state of
600  * the hardware are processed here. If action can not be performed in
601  * interrupt context it is offloaded to atkbd_event_work.
602  */
603
604 static int atkbd_event(struct input_dev *dev,
605                         unsigned int type, unsigned int code, int value)
606 {
607         struct atkbd *atkbd = input_get_drvdata(dev);
608
609         if (!atkbd->write)
610                 return -1;
611
612         switch (type) {
613
614                 case EV_LED:
615                         atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
616                         return 0;
617
618                 case EV_REP:
619                         if (!atkbd->softrepeat)
620                                 atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
621                         return 0;
622         }
623
624         return -1;
625 }
626
627 /*
628  * atkbd_enable() signals that interrupt handler is allowed to
629  * generate input events.
630  */
631
632 static inline void atkbd_enable(struct atkbd *atkbd)
633 {
634         serio_pause_rx(atkbd->ps2dev.serio);
635         atkbd->enabled = 1;
636         serio_continue_rx(atkbd->ps2dev.serio);
637 }
638
639 /*
640  * atkbd_disable() tells input handler that all incoming data except
641  * for ACKs and command response should be dropped.
642  */
643
644 static inline void atkbd_disable(struct atkbd *atkbd)
645 {
646         serio_pause_rx(atkbd->ps2dev.serio);
647         atkbd->enabled = 0;
648         serio_continue_rx(atkbd->ps2dev.serio);
649 }
650
651 /*
652  * atkbd_probe() probes for an AT keyboard on a serio port.
653  */
654
655 static int atkbd_probe(struct atkbd *atkbd)
656 {
657         struct ps2dev *ps2dev = &atkbd->ps2dev;
658         unsigned char param[2];
659
660 /*
661  * Some systems, where the bit-twiddling when testing the io-lines of the
662  * controller may confuse the keyboard need a full reset of the keyboard. On
663  * these systems the BIOS also usually doesn't do it for us.
664  */
665
666         if (atkbd_reset)
667                 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
668                         printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
669
670 /*
671  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
672  * Some keyboards report different values, but the first byte is always 0xab or
673  * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
674  * should make sure we don't try to set the LEDs on it.
675  */
676
677         param[0] = param[1] = 0xa5;     /* initialize with invalid values */
678         if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
679
680 /*
681  * If the get ID command failed, we check if we can at least set the LEDs on
682  * the keyboard. This should work on every keyboard out there. It also turns
683  * the LEDs off, which we want anyway.
684  */
685                 param[0] = 0;
686                 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
687                         return -1;
688                 atkbd->id = 0xabba;
689                 return 0;
690         }
691
692         if (!ps2_is_keyboard_id(param[0]))
693                 return -1;
694
695         atkbd->id = (param[0] << 8) | param[1];
696
697         if (atkbd->id == 0xaca1 && atkbd->translated) {
698                 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
699                 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
700                 return -1;
701         }
702
703         return 0;
704 }
705
706 /*
707  * atkbd_select_set checks if a keyboard has a working Set 3 support, and
708  * sets it into that. Unfortunately there are keyboards that can be switched
709  * to Set 3, but don't work well in that (BTC Multimedia ...)
710  */
711
712 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
713 {
714         struct ps2dev *ps2dev = &atkbd->ps2dev;
715         unsigned char param[2];
716
717         atkbd->extra = 0;
718 /*
719  * For known special keyboards we can go ahead and set the correct set.
720  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
721  * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
722  */
723
724         if (atkbd->translated)
725                 return 2;
726
727         if (atkbd->id == 0xaca1) {
728                 param[0] = 3;
729                 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
730                 return 3;
731         }
732
733         if (allow_extra) {
734                 param[0] = 0x71;
735                 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
736                         atkbd->extra = 1;
737                         return 2;
738                 }
739         }
740
741         if (target_set != 3)
742                 return 2;
743
744         if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
745                 atkbd->id = param[0] << 8 | param[1];
746                 return 2;
747         }
748
749         param[0] = 3;
750         if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
751                 return 2;
752
753         param[0] = 0;
754         if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
755                 return 2;
756
757         if (param[0] != 3) {
758                 param[0] = 2;
759                 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
760                 return 2;
761         }
762
763         ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
764
765         return 3;
766 }
767
768 static int atkbd_activate(struct atkbd *atkbd)
769 {
770         struct ps2dev *ps2dev = &atkbd->ps2dev;
771         unsigned char param[1];
772
773 /*
774  * Set the LEDs to a defined state.
775  */
776
777         param[0] = 0;
778         if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
779                 return -1;
780
781 /*
782  * Set autorepeat to fastest possible.
783  */
784
785         param[0] = 0;
786         if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
787                 return -1;
788
789 /*
790  * Enable the keyboard to receive keystrokes.
791  */
792
793         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
794                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
795                         ps2dev->serio->phys);
796                 return -1;
797         }
798
799         return 0;
800 }
801
802 /*
803  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
804  * reboot.
805  */
806
807 static void atkbd_cleanup(struct serio *serio)
808 {
809         struct atkbd *atkbd = serio_get_drvdata(serio);
810
811         atkbd_disable(atkbd);
812         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
813 }
814
815
816 /*
817  * atkbd_disconnect() closes and frees.
818  */
819
820 static void atkbd_disconnect(struct serio *serio)
821 {
822         struct atkbd *atkbd = serio_get_drvdata(serio);
823
824         atkbd_disable(atkbd);
825
826         /* make sure we don't have a command in flight */
827         cancel_delayed_work_sync(&atkbd->event_work);
828
829         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
830         input_unregister_device(atkbd->dev);
831         serio_close(serio);
832         serio_set_drvdata(serio, NULL);
833         kfree(atkbd);
834 }
835
836 /*
837  * Most special keys (Fn+F?) on Dell laptops do not generate release
838  * events so we have to do it ourselves.
839  */
840 static void atkbd_dell_laptop_keymap_fixup(struct atkbd *atkbd)
841 {
842         const unsigned int forced_release_keys[] = {
843                 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93,
844         };
845         int i;
846
847         if (atkbd->set == 2)
848                 for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
849                         __set_bit(forced_release_keys[i],
850                                   atkbd->force_release_mask);
851 }
852
853 /*
854  * Perform fixup for HP system that doesn't generate release
855  * for its video switch
856  */
857 static void atkbd_hp_keymap_fixup(struct atkbd *atkbd)
858 {
859         const unsigned int forced_release_keys[] = {
860                 0x94,
861         };
862         int i;
863
864         if (atkbd->set == 2)
865                 for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
866                         __set_bit(forced_release_keys[i],
867                                         atkbd->force_release_mask);
868 }
869
870 /*
871  * Inventec system with broken key release on volume keys
872  */
873 static void atkbd_inventec_keymap_fixup(struct atkbd *atkbd)
874 {
875         const unsigned int forced_release_keys[] = {
876                 0xae, 0xb0,
877         };
878         int i;
879
880         if (atkbd->set == 2)
881                 for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
882                         __set_bit(forced_release_keys[i],
883                                   atkbd->force_release_mask);
884 }
885
886 /*
887  * Perform fixup for HP Pavilion ZV6100 laptop that doesn't generate release
888  * for its volume buttons
889  */
890 static void atkbd_hp_zv6100_keymap_fixup(struct atkbd *atkbd)
891 {
892         const unsigned int forced_release_keys[] = {
893                 0xae, 0xb0,
894         };
895         int i;
896
897         if (atkbd->set == 2)
898                 for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
899                         __set_bit(forced_release_keys[i],
900                                         atkbd->force_release_mask);
901 }
902
903 /*
904  * atkbd_set_keycode_table() initializes keyboard's keycode table
905  * according to the selected scancode set
906  */
907
908 static void atkbd_set_keycode_table(struct atkbd *atkbd)
909 {
910         unsigned int scancode;
911         int i, j;
912
913         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
914         bitmap_zero(atkbd->force_release_mask, 512);
915
916         if (atkbd->translated) {
917                 for (i = 0; i < 128; i++) {
918                         scancode = atkbd_unxlate_table[i];
919                         atkbd->keycode[i] = atkbd_set2_keycode[scancode];
920                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
921                         if (atkbd->scroll)
922                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
923                                         if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
924                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
925                 }
926         } else if (atkbd->set == 3) {
927                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
928         } else {
929                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
930
931                 if (atkbd->scroll)
932                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
933                                 scancode = atkbd_scroll_keys[i].set2;
934                                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
935                 }
936         }
937
938 /*
939  * HANGEUL and HANJA keys do not send release events so we need to
940  * generate such events ourselves
941  */
942         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
943         atkbd->keycode[scancode] = KEY_HANGEUL;
944         __set_bit(scancode, atkbd->force_release_mask);
945
946         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
947         atkbd->keycode[scancode] = KEY_HANJA;
948         __set_bit(scancode, atkbd->force_release_mask);
949
950 /*
951  * Perform additional fixups
952  */
953         if (atkbd_platform_fixup)
954                 atkbd_platform_fixup(atkbd);
955 }
956
957 /*
958  * atkbd_set_device_attrs() sets up keyboard's input device structure
959  */
960
961 static void atkbd_set_device_attrs(struct atkbd *atkbd)
962 {
963         struct input_dev *input_dev = atkbd->dev;
964         int i;
965
966         if (atkbd->extra)
967                 snprintf(atkbd->name, sizeof(atkbd->name),
968                          "AT Set 2 Extra keyboard");
969         else
970                 snprintf(atkbd->name, sizeof(atkbd->name),
971                          "AT %s Set %d keyboard",
972                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
973
974         snprintf(atkbd->phys, sizeof(atkbd->phys),
975                  "%s/input0", atkbd->ps2dev.serio->phys);
976
977         input_dev->name = atkbd->name;
978         input_dev->phys = atkbd->phys;
979         input_dev->id.bustype = BUS_I8042;
980         input_dev->id.vendor = 0x0001;
981         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
982         input_dev->id.version = atkbd->id;
983         input_dev->event = atkbd_event;
984         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
985
986         input_set_drvdata(input_dev, atkbd);
987
988         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
989                 BIT_MASK(EV_MSC);
990
991         if (atkbd->write) {
992                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
993                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
994                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
995         }
996
997         if (atkbd->extra)
998                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
999                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1000                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1001
1002         if (!atkbd->softrepeat) {
1003                 input_dev->rep[REP_DELAY] = 250;
1004                 input_dev->rep[REP_PERIOD] = 33;
1005         }
1006
1007         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1008                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1009
1010         if (atkbd->scroll) {
1011                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1012                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1013                         BIT_MASK(REL_HWHEEL);
1014                 __set_bit(BTN_MIDDLE, input_dev->keybit);
1015         }
1016
1017         input_dev->keycode = atkbd->keycode;
1018         input_dev->keycodesize = sizeof(unsigned short);
1019         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1020
1021         for (i = 0; i < 512; i++)
1022                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
1023                         __set_bit(atkbd->keycode[i], input_dev->keybit);
1024 }
1025
1026 /*
1027  * atkbd_connect() is called when the serio module finds an interface
1028  * that isn't handled yet by an appropriate device driver. We check if
1029  * there is an AT keyboard out there and if yes, we register ourselves
1030  * to the input module.
1031  */
1032
1033 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1034 {
1035         struct atkbd *atkbd;
1036         struct input_dev *dev;
1037         int err = -ENOMEM;
1038
1039         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1040         dev = input_allocate_device();
1041         if (!atkbd || !dev)
1042                 goto fail1;
1043
1044         atkbd->dev = dev;
1045         ps2_init(&atkbd->ps2dev, serio);
1046         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1047         mutex_init(&atkbd->event_mutex);
1048
1049         switch (serio->id.type) {
1050
1051                 case SERIO_8042_XL:
1052                         atkbd->translated = 1;
1053                 case SERIO_8042:
1054                         if (serio->write)
1055                                 atkbd->write = 1;
1056                         break;
1057         }
1058
1059         atkbd->softraw = atkbd_softraw;
1060         atkbd->softrepeat = atkbd_softrepeat;
1061         atkbd->scroll = atkbd_scroll;
1062
1063         if (atkbd->softrepeat)
1064                 atkbd->softraw = 1;
1065
1066         serio_set_drvdata(serio, atkbd);
1067
1068         err = serio_open(serio, drv);
1069         if (err)
1070                 goto fail2;
1071
1072         if (atkbd->write) {
1073
1074                 if (atkbd_probe(atkbd)) {
1075                         err = -ENODEV;
1076                         goto fail3;
1077                 }
1078
1079                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1080                 atkbd_activate(atkbd);
1081
1082         } else {
1083                 atkbd->set = 2;
1084                 atkbd->id = 0xab00;
1085         }
1086
1087         atkbd_set_keycode_table(atkbd);
1088         atkbd_set_device_attrs(atkbd);
1089
1090         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1091         if (err)
1092                 goto fail3;
1093
1094         atkbd_enable(atkbd);
1095
1096         err = input_register_device(atkbd->dev);
1097         if (err)
1098                 goto fail4;
1099
1100         return 0;
1101
1102  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1103  fail3: serio_close(serio);
1104  fail2: serio_set_drvdata(serio, NULL);
1105  fail1: input_free_device(dev);
1106         kfree(atkbd);
1107         return err;
1108 }
1109
1110 /*
1111  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1112  * most likely called on resume.
1113  */
1114
1115 static int atkbd_reconnect(struct serio *serio)
1116 {
1117         struct atkbd *atkbd = serio_get_drvdata(serio);
1118         struct serio_driver *drv = serio->drv;
1119
1120         if (!atkbd || !drv) {
1121                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1122                 return -1;
1123         }
1124
1125         atkbd_disable(atkbd);
1126
1127         if (atkbd->write) {
1128                 if (atkbd_probe(atkbd))
1129                         return -1;
1130                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1131                         return -1;
1132
1133                 atkbd_activate(atkbd);
1134
1135 /*
1136  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1137  * to pre-resume state
1138  */
1139                 if (!atkbd->softrepeat)
1140                         atkbd_set_repeat_rate(atkbd);
1141                 atkbd_set_leds(atkbd);
1142         }
1143
1144         atkbd_enable(atkbd);
1145
1146         return 0;
1147 }
1148
1149 static struct serio_device_id atkbd_serio_ids[] = {
1150         {
1151                 .type   = SERIO_8042,
1152                 .proto  = SERIO_ANY,
1153                 .id     = SERIO_ANY,
1154                 .extra  = SERIO_ANY,
1155         },
1156         {
1157                 .type   = SERIO_8042_XL,
1158                 .proto  = SERIO_ANY,
1159                 .id     = SERIO_ANY,
1160                 .extra  = SERIO_ANY,
1161         },
1162         {
1163                 .type   = SERIO_RS232,
1164                 .proto  = SERIO_PS2SER,
1165                 .id     = SERIO_ANY,
1166                 .extra  = SERIO_ANY,
1167         },
1168         { 0 }
1169 };
1170
1171 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1172
1173 static struct serio_driver atkbd_drv = {
1174         .driver         = {
1175                 .name   = "atkbd",
1176         },
1177         .description    = DRIVER_DESC,
1178         .id_table       = atkbd_serio_ids,
1179         .interrupt      = atkbd_interrupt,
1180         .connect        = atkbd_connect,
1181         .reconnect      = atkbd_reconnect,
1182         .disconnect     = atkbd_disconnect,
1183         .cleanup        = atkbd_cleanup,
1184 };
1185
1186 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1187                                 ssize_t (*handler)(struct atkbd *, char *))
1188 {
1189         struct serio *serio = to_serio_port(dev);
1190         int retval;
1191
1192         retval = serio_pin_driver(serio);
1193         if (retval)
1194                 return retval;
1195
1196         if (serio->drv != &atkbd_drv) {
1197                 retval = -ENODEV;
1198                 goto out;
1199         }
1200
1201         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1202
1203 out:
1204         serio_unpin_driver(serio);
1205         return retval;
1206 }
1207
1208 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1209                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1210 {
1211         struct serio *serio = to_serio_port(dev);
1212         struct atkbd *atkbd;
1213         int retval;
1214
1215         retval = serio_pin_driver(serio);
1216         if (retval)
1217                 return retval;
1218
1219         if (serio->drv != &atkbd_drv) {
1220                 retval = -ENODEV;
1221                 goto out;
1222         }
1223
1224         atkbd = serio_get_drvdata(serio);
1225         atkbd_disable(atkbd);
1226         retval = handler(atkbd, buf, count);
1227         atkbd_enable(atkbd);
1228
1229 out:
1230         serio_unpin_driver(serio);
1231         return retval;
1232 }
1233
1234 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1235 {
1236         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1237 }
1238
1239 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1240 {
1241         struct input_dev *old_dev, *new_dev;
1242         unsigned long value;
1243         int err;
1244         unsigned char old_extra, old_set;
1245
1246         if (!atkbd->write)
1247                 return -EIO;
1248
1249         if (strict_strtoul(buf, 10, &value) || value > 1)
1250                 return -EINVAL;
1251
1252         if (atkbd->extra != value) {
1253                 /*
1254                  * Since device's properties will change we need to
1255                  * unregister old device. But allocate and register
1256                  * new one first to make sure we have it.
1257                  */
1258                 old_dev = atkbd->dev;
1259                 old_extra = atkbd->extra;
1260                 old_set = atkbd->set;
1261
1262                 new_dev = input_allocate_device();
1263                 if (!new_dev)
1264                         return -ENOMEM;
1265
1266                 atkbd->dev = new_dev;
1267                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1268                 atkbd_activate(atkbd);
1269                 atkbd_set_keycode_table(atkbd);
1270                 atkbd_set_device_attrs(atkbd);
1271
1272                 err = input_register_device(atkbd->dev);
1273                 if (err) {
1274                         input_free_device(new_dev);
1275
1276                         atkbd->dev = old_dev;
1277                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1278                         atkbd_set_keycode_table(atkbd);
1279                         atkbd_set_device_attrs(atkbd);
1280
1281                         return err;
1282                 }
1283                 input_unregister_device(old_dev);
1284
1285         }
1286         return count;
1287 }
1288
1289 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1290 {
1291         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1292 }
1293
1294 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1295 {
1296         struct input_dev *old_dev, *new_dev;
1297         unsigned long value;
1298         int err;
1299         unsigned char old_scroll;
1300
1301         if (strict_strtoul(buf, 10, &value) || value > 1)
1302                 return -EINVAL;
1303
1304         if (atkbd->scroll != value) {
1305                 old_dev = atkbd->dev;
1306                 old_scroll = atkbd->scroll;
1307
1308                 new_dev = input_allocate_device();
1309                 if (!new_dev)
1310                         return -ENOMEM;
1311
1312                 atkbd->dev = new_dev;
1313                 atkbd->scroll = value;
1314                 atkbd_set_keycode_table(atkbd);
1315                 atkbd_set_device_attrs(atkbd);
1316
1317                 err = input_register_device(atkbd->dev);
1318                 if (err) {
1319                         input_free_device(new_dev);
1320
1321                         atkbd->scroll = old_scroll;
1322                         atkbd->dev = old_dev;
1323                         atkbd_set_keycode_table(atkbd);
1324                         atkbd_set_device_attrs(atkbd);
1325
1326                         return err;
1327                 }
1328                 input_unregister_device(old_dev);
1329         }
1330         return count;
1331 }
1332
1333 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1334 {
1335         return sprintf(buf, "%d\n", atkbd->set);
1336 }
1337
1338 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1339 {
1340         struct input_dev *old_dev, *new_dev;
1341         unsigned long value;
1342         int err;
1343         unsigned char old_set, old_extra;
1344
1345         if (!atkbd->write)
1346                 return -EIO;
1347
1348         if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1349                 return -EINVAL;
1350
1351         if (atkbd->set != value) {
1352                 old_dev = atkbd->dev;
1353                 old_extra = atkbd->extra;
1354                 old_set = atkbd->set;
1355
1356                 new_dev = input_allocate_device();
1357                 if (!new_dev)
1358                         return -ENOMEM;
1359
1360                 atkbd->dev = new_dev;
1361                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1362                 atkbd_activate(atkbd);
1363                 atkbd_set_keycode_table(atkbd);
1364                 atkbd_set_device_attrs(atkbd);
1365
1366                 err = input_register_device(atkbd->dev);
1367                 if (err) {
1368                         input_free_device(new_dev);
1369
1370                         atkbd->dev = old_dev;
1371                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1372                         atkbd_set_keycode_table(atkbd);
1373                         atkbd_set_device_attrs(atkbd);
1374
1375                         return err;
1376                 }
1377                 input_unregister_device(old_dev);
1378         }
1379         return count;
1380 }
1381
1382 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1383 {
1384         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1385 }
1386
1387 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1388 {
1389         struct input_dev *old_dev, *new_dev;
1390         unsigned long value;
1391         int err;
1392         unsigned char old_softrepeat, old_softraw;
1393
1394         if (!atkbd->write)
1395                 return -EIO;
1396
1397         if (strict_strtoul(buf, 10, &value) || value > 1)
1398                 return -EINVAL;
1399
1400         if (atkbd->softrepeat != value) {
1401                 old_dev = atkbd->dev;
1402                 old_softrepeat = atkbd->softrepeat;
1403                 old_softraw = atkbd->softraw;
1404
1405                 new_dev = input_allocate_device();
1406                 if (!new_dev)
1407                         return -ENOMEM;
1408
1409                 atkbd->dev = new_dev;
1410                 atkbd->softrepeat = value;
1411                 if (atkbd->softrepeat)
1412                         atkbd->softraw = 1;
1413                 atkbd_set_device_attrs(atkbd);
1414
1415                 err = input_register_device(atkbd->dev);
1416                 if (err) {
1417                         input_free_device(new_dev);
1418
1419                         atkbd->dev = old_dev;
1420                         atkbd->softrepeat = old_softrepeat;
1421                         atkbd->softraw = old_softraw;
1422                         atkbd_set_device_attrs(atkbd);
1423
1424                         return err;
1425                 }
1426                 input_unregister_device(old_dev);
1427         }
1428         return count;
1429 }
1430
1431
1432 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1433 {
1434         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1435 }
1436
1437 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1438 {
1439         struct input_dev *old_dev, *new_dev;
1440         unsigned long value;
1441         int err;
1442         unsigned char old_softraw;
1443
1444         if (strict_strtoul(buf, 10, &value) || value > 1)
1445                 return -EINVAL;
1446
1447         if (atkbd->softraw != value) {
1448                 old_dev = atkbd->dev;
1449                 old_softraw = atkbd->softraw;
1450
1451                 new_dev = input_allocate_device();
1452                 if (!new_dev)
1453                         return -ENOMEM;
1454
1455                 atkbd->dev = new_dev;
1456                 atkbd->softraw = value;
1457                 atkbd_set_device_attrs(atkbd);
1458
1459                 err = input_register_device(atkbd->dev);
1460                 if (err) {
1461                         input_free_device(new_dev);
1462
1463                         atkbd->dev = old_dev;
1464                         atkbd->softraw = old_softraw;
1465                         atkbd_set_device_attrs(atkbd);
1466
1467                         return err;
1468                 }
1469                 input_unregister_device(old_dev);
1470         }
1471         return count;
1472 }
1473
1474 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1475 {
1476         return sprintf(buf, "%lu\n", atkbd->err_count);
1477 }
1478
1479 static int __init atkbd_setup_fixup(const struct dmi_system_id *id)
1480 {
1481         atkbd_platform_fixup = id->driver_data;
1482         return 0;
1483 }
1484
1485 static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
1486         {
1487                 .ident = "Dell Laptop",
1488                 .matches = {
1489                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1490                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1491                 },
1492                 .callback = atkbd_setup_fixup,
1493                 .driver_data = atkbd_dell_laptop_keymap_fixup,
1494         },
1495         {
1496                 .ident = "HP 2133",
1497                 .matches = {
1498                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1499                         DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1500                 },
1501                 .callback = atkbd_setup_fixup,
1502                 .driver_data = atkbd_hp_keymap_fixup,
1503         },
1504         {
1505                 .ident = "HP Pavilion ZV6100",
1506                 .matches = {
1507                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1508                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1509                 },
1510                 .callback = atkbd_setup_fixup,
1511                 .driver_data = atkbd_hp_zv6100_keymap_fixup,
1512         },
1513         {
1514                 .ident = "Inventec Symphony",
1515                 .matches = {
1516                         DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1517                         DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1518                 },
1519                 .callback = atkbd_setup_fixup,
1520                 .driver_data = atkbd_inventec_keymap_fixup,
1521         },
1522         { }
1523 };
1524
1525 static int __init atkbd_init(void)
1526 {
1527         dmi_check_system(atkbd_dmi_quirk_table);
1528
1529         return serio_register_driver(&atkbd_drv);
1530 }
1531
1532 static void __exit atkbd_exit(void)
1533 {
1534         serio_unregister_driver(&atkbd_drv);
1535 }
1536
1537 module_init(atkbd_init);
1538 module_exit(atkbd_exit);