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