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