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