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