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