WorkStruct: Pass the work_struct pointer instead of context data
[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/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 fail;
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 fail;
971
972         if (atkbd->write) {
973
974                 if (atkbd_probe(atkbd)) {
975                         serio_close(serio);
976                         err = -ENODEV;
977                         goto fail;
978                 }
979
980                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
981                 atkbd_activate(atkbd);
982
983         } else {
984                 atkbd->set = 2;
985                 atkbd->id = 0xab00;
986         }
987
988         atkbd_set_keycode_table(atkbd);
989         atkbd_set_device_attrs(atkbd);
990
991         sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
992
993         atkbd_enable(atkbd);
994
995         input_register_device(atkbd->dev);
996
997         return 0;
998
999  fail:  serio_set_drvdata(serio, NULL);
1000         input_free_device(dev);
1001         kfree(atkbd);
1002         return err;
1003 }
1004
1005 /*
1006  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1007  * most likely called on resume.
1008  */
1009
1010 static int atkbd_reconnect(struct serio *serio)
1011 {
1012         struct atkbd *atkbd = serio_get_drvdata(serio);
1013         struct serio_driver *drv = serio->drv;
1014
1015         if (!atkbd || !drv) {
1016                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1017                 return -1;
1018         }
1019
1020         atkbd_disable(atkbd);
1021
1022         if (atkbd->write) {
1023                 if (atkbd_probe(atkbd))
1024                         return -1;
1025                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1026                         return -1;
1027
1028                 atkbd_activate(atkbd);
1029
1030 /*
1031  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1032  * to pre-resume state
1033  */
1034                 if (!atkbd->softrepeat)
1035                         atkbd_set_repeat_rate(atkbd);
1036                 atkbd_set_leds(atkbd);
1037         }
1038
1039         atkbd_enable(atkbd);
1040
1041         return 0;
1042 }
1043
1044 static struct serio_device_id atkbd_serio_ids[] = {
1045         {
1046                 .type   = SERIO_8042,
1047                 .proto  = SERIO_ANY,
1048                 .id     = SERIO_ANY,
1049                 .extra  = SERIO_ANY,
1050         },
1051         {
1052                 .type   = SERIO_8042_XL,
1053                 .proto  = SERIO_ANY,
1054                 .id     = SERIO_ANY,
1055                 .extra  = SERIO_ANY,
1056         },
1057         {
1058                 .type   = SERIO_RS232,
1059                 .proto  = SERIO_PS2SER,
1060                 .id     = SERIO_ANY,
1061                 .extra  = SERIO_ANY,
1062         },
1063         { 0 }
1064 };
1065
1066 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1067
1068 static struct serio_driver atkbd_drv = {
1069         .driver         = {
1070                 .name   = "atkbd",
1071         },
1072         .description    = DRIVER_DESC,
1073         .id_table       = atkbd_serio_ids,
1074         .interrupt      = atkbd_interrupt,
1075         .connect        = atkbd_connect,
1076         .reconnect      = atkbd_reconnect,
1077         .disconnect     = atkbd_disconnect,
1078         .cleanup        = atkbd_cleanup,
1079 };
1080
1081 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1082                                 ssize_t (*handler)(struct atkbd *, char *))
1083 {
1084         struct serio *serio = to_serio_port(dev);
1085         int retval;
1086
1087         retval = serio_pin_driver(serio);
1088         if (retval)
1089                 return retval;
1090
1091         if (serio->drv != &atkbd_drv) {
1092                 retval = -ENODEV;
1093                 goto out;
1094         }
1095
1096         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1097
1098 out:
1099         serio_unpin_driver(serio);
1100         return retval;
1101 }
1102
1103 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1104                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1105 {
1106         struct serio *serio = to_serio_port(dev);
1107         struct atkbd *atkbd;
1108         int retval;
1109
1110         retval = serio_pin_driver(serio);
1111         if (retval)
1112                 return retval;
1113
1114         if (serio->drv != &atkbd_drv) {
1115                 retval = -ENODEV;
1116                 goto out;
1117         }
1118
1119         atkbd = serio_get_drvdata(serio);
1120         atkbd_disable(atkbd);
1121         retval = handler(atkbd, buf, count);
1122         atkbd_enable(atkbd);
1123
1124 out:
1125         serio_unpin_driver(serio);
1126         return retval;
1127 }
1128
1129 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1130 {
1131         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1132 }
1133
1134 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1135 {
1136         struct input_dev *new_dev;
1137         unsigned long value;
1138         char *rest;
1139
1140         if (!atkbd->write)
1141                 return -EIO;
1142
1143         value = simple_strtoul(buf, &rest, 10);
1144         if (*rest || value > 1)
1145                 return -EINVAL;
1146
1147         if (atkbd->extra != value) {
1148                 /*
1149                  * Since device's properties will change we need to
1150                  * unregister old device. But allocate new one first
1151                  * to make sure we have it.
1152                  */
1153                 if (!(new_dev = input_allocate_device()))
1154                         return -ENOMEM;
1155                 input_unregister_device(atkbd->dev);
1156                 atkbd->dev = new_dev;
1157                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1158                 atkbd_activate(atkbd);
1159                 atkbd_set_device_attrs(atkbd);
1160                 input_register_device(atkbd->dev);
1161         }
1162         return count;
1163 }
1164
1165 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1166 {
1167         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1168 }
1169
1170 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1171 {
1172         struct input_dev *new_dev;
1173         unsigned long value;
1174         char *rest;
1175
1176         value = simple_strtoul(buf, &rest, 10);
1177         if (*rest || value > 1)
1178                 return -EINVAL;
1179
1180         if (atkbd->scroll != value) {
1181                 if (!(new_dev = input_allocate_device()))
1182                         return -ENOMEM;
1183                 input_unregister_device(atkbd->dev);
1184                 atkbd->dev = new_dev;
1185                 atkbd->scroll = value;
1186                 atkbd_set_keycode_table(atkbd);
1187                 atkbd_set_device_attrs(atkbd);
1188                 input_register_device(atkbd->dev);
1189         }
1190         return count;
1191 }
1192
1193 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1194 {
1195         return sprintf(buf, "%d\n", atkbd->set);
1196 }
1197
1198 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1199 {
1200         struct input_dev *new_dev;
1201         unsigned long value;
1202         char *rest;
1203
1204         if (!atkbd->write)
1205                 return -EIO;
1206
1207         value = simple_strtoul(buf, &rest, 10);
1208         if (*rest || (value != 2 && value != 3))
1209                 return -EINVAL;
1210
1211         if (atkbd->set != value) {
1212                 if (!(new_dev = input_allocate_device()))
1213                         return -ENOMEM;
1214                 input_unregister_device(atkbd->dev);
1215                 atkbd->dev = new_dev;
1216                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1217                 atkbd_activate(atkbd);
1218                 atkbd_set_keycode_table(atkbd);
1219                 atkbd_set_device_attrs(atkbd);
1220                 input_register_device(atkbd->dev);
1221         }
1222         return count;
1223 }
1224
1225 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1226 {
1227         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1228 }
1229
1230 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1231 {
1232         struct input_dev *new_dev;
1233         unsigned long value;
1234         char *rest;
1235
1236         if (!atkbd->write)
1237                 return -EIO;
1238
1239         value = simple_strtoul(buf, &rest, 10);
1240         if (*rest || value > 1)
1241                 return -EINVAL;
1242
1243         if (atkbd->softrepeat != value) {
1244                 if (!(new_dev = input_allocate_device()))
1245                         return -ENOMEM;
1246                 input_unregister_device(atkbd->dev);
1247                 atkbd->dev = new_dev;
1248                 atkbd->softrepeat = value;
1249                 if (atkbd->softrepeat)
1250                         atkbd->softraw = 1;
1251                 atkbd_set_device_attrs(atkbd);
1252                 input_register_device(atkbd->dev);
1253         }
1254         return count;
1255 }
1256
1257
1258 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1259 {
1260         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1261 }
1262
1263 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1264 {
1265         struct input_dev *new_dev;
1266         unsigned long value;
1267         char *rest;
1268
1269         value = simple_strtoul(buf, &rest, 10);
1270         if (*rest || value > 1)
1271                 return -EINVAL;
1272
1273         if (atkbd->softraw != value) {
1274                 if (!(new_dev = input_allocate_device()))
1275                         return -ENOMEM;
1276                 input_unregister_device(atkbd->dev);
1277                 atkbd->dev = new_dev;
1278                 atkbd->softraw = value;
1279                 atkbd_set_device_attrs(atkbd);
1280                 input_register_device(atkbd->dev);
1281         }
1282         return count;
1283 }
1284
1285 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1286 {
1287         return sprintf(buf, "%lu\n", atkbd->err_count);
1288 }
1289
1290
1291 static int __init atkbd_init(void)
1292 {
1293         serio_register_driver(&atkbd_drv);
1294         return 0;
1295 }
1296
1297 static void __exit atkbd_exit(void)
1298 {
1299         serio_unregister_driver(&atkbd_drv);
1300 }
1301
1302 module_init(atkbd_init);
1303 module_exit(atkbd_exit);