Branch data Line data Source code
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/slab.h>
23 : : #include <linux/interrupt.h>
24 : : #include <linux/init.h>
25 : : #include <linux/input.h>
26 : : #include <linux/serio.h>
27 : : #include <linux/workqueue.h>
28 : : #include <linux/libps2.h>
29 : : #include <linux/mutex.h>
30 : : #include <linux/dmi.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 bool atkbd_reset;
44 : : #else
45 : : static bool atkbd_reset = true;
46 : : #endif
47 : : module_param_named(reset, atkbd_reset, bool, 0);
48 : : MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
49 : :
50 : : static bool atkbd_softrepeat;
51 : : module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
52 : : MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
53 : :
54 : : static bool atkbd_softraw = true;
55 : : module_param_named(softraw, atkbd_softraw, bool, 0);
56 : : MODULE_PARM_DESC(softraw, "Use software generated rawmode");
57 : :
58 : : static bool 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 bool 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 : : static bool atkbd_terminal;
67 : : module_param_named(terminal, atkbd_terminal, bool, 0);
68 : : MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
69 : :
70 : : /*
71 : : * Scancode to keycode tables. These are just the default setting, and
72 : : * are loadable via a userland utility.
73 : : */
74 : :
75 : : #define ATKBD_KEYMAP_SIZE 512
76 : :
77 : : static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
78 : :
79 : : #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
80 : :
81 : : /* XXX: need a more general approach */
82 : :
83 : : #include "hpps2atkbd.h" /* include the keyboard scancodes */
84 : :
85 : : #else
86 : : 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
87 : : 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
88 : : 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
89 : : 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
90 : : 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
91 : : 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
92 : : 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
93 : : 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
94 : :
95 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
96 : : 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
97 : : 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
98 : : 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142,
99 : : 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
100 : : 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
101 : : 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
102 : : 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
103 : :
104 : : 0, 0, 0, 65, 99,
105 : : #endif
106 : : };
107 : :
108 : : static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
109 : :
110 : : 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
111 : : 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
112 : : 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
113 : : 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
114 : : 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
115 : : 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
116 : : 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
117 : : 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
118 : :
119 : : 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
120 : : 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
121 : : 148,149,147,140
122 : : };
123 : :
124 : : static const unsigned short atkbd_unxlate_table[128] = {
125 : : 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
126 : : 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
127 : : 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
128 : : 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
129 : : 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
130 : : 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
131 : : 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
132 : : 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
133 : : };
134 : :
135 : : #define ATKBD_CMD_SETLEDS 0x10ed
136 : : #define ATKBD_CMD_GSCANSET 0x11f0
137 : : #define ATKBD_CMD_SSCANSET 0x10f0
138 : : #define ATKBD_CMD_GETID 0x02f2
139 : : #define ATKBD_CMD_SETREP 0x10f3
140 : : #define ATKBD_CMD_ENABLE 0x00f4
141 : : #define ATKBD_CMD_RESET_DIS 0x00f5 /* Reset to defaults and disable */
142 : : #define ATKBD_CMD_RESET_DEF 0x00f6 /* Reset to defaults */
143 : : #define ATKBD_CMD_SETALL_MB 0x00f8 /* Set all keys to give break codes */
144 : : #define ATKBD_CMD_SETALL_MBR 0x00fa /* ... and repeat */
145 : : #define ATKBD_CMD_RESET_BAT 0x02ff
146 : : #define ATKBD_CMD_RESEND 0x00fe
147 : : #define ATKBD_CMD_EX_ENABLE 0x10ea
148 : : #define ATKBD_CMD_EX_SETLEDS 0x20eb
149 : : #define ATKBD_CMD_OK_GETID 0x02e8
150 : :
151 : : #define ATKBD_RET_ACK 0xfa
152 : : #define ATKBD_RET_NAK 0xfe
153 : : #define ATKBD_RET_BAT 0xaa
154 : : #define ATKBD_RET_EMUL0 0xe0
155 : : #define ATKBD_RET_EMUL1 0xe1
156 : : #define ATKBD_RET_RELEASE 0xf0
157 : : #define ATKBD_RET_HANJA 0xf1
158 : : #define ATKBD_RET_HANGEUL 0xf2
159 : : #define ATKBD_RET_ERR 0xff
160 : :
161 : : #define ATKBD_KEY_UNKNOWN 0
162 : : #define ATKBD_KEY_NULL 255
163 : :
164 : : #define ATKBD_SCR_1 0xfffe
165 : : #define ATKBD_SCR_2 0xfffd
166 : : #define ATKBD_SCR_4 0xfffc
167 : : #define ATKBD_SCR_8 0xfffb
168 : : #define ATKBD_SCR_CLICK 0xfffa
169 : : #define ATKBD_SCR_LEFT 0xfff9
170 : : #define ATKBD_SCR_RIGHT 0xfff8
171 : :
172 : : #define ATKBD_SPECIAL ATKBD_SCR_RIGHT
173 : :
174 : : #define ATKBD_LED_EVENT_BIT 0
175 : : #define ATKBD_REP_EVENT_BIT 1
176 : :
177 : : #define ATKBD_XL_ERR 0x01
178 : : #define ATKBD_XL_BAT 0x02
179 : : #define ATKBD_XL_ACK 0x04
180 : : #define ATKBD_XL_NAK 0x08
181 : : #define ATKBD_XL_HANGEUL 0x10
182 : : #define ATKBD_XL_HANJA 0x20
183 : :
184 : : static const struct {
185 : : unsigned short keycode;
186 : : unsigned char set2;
187 : : } atkbd_scroll_keys[] = {
188 : : { ATKBD_SCR_1, 0xc5 },
189 : : { ATKBD_SCR_2, 0x9d },
190 : : { ATKBD_SCR_4, 0xa4 },
191 : : { ATKBD_SCR_8, 0x9b },
192 : : { ATKBD_SCR_CLICK, 0xe0 },
193 : : { ATKBD_SCR_LEFT, 0xcb },
194 : : { ATKBD_SCR_RIGHT, 0xd2 },
195 : : };
196 : :
197 : : /*
198 : : * The atkbd control structure
199 : : */
200 : :
201 : : struct atkbd {
202 : :
203 : : struct ps2dev ps2dev;
204 : : struct input_dev *dev;
205 : :
206 : : /* Written only during init */
207 : : char name[64];
208 : : char phys[32];
209 : :
210 : : unsigned short id;
211 : : unsigned short keycode[ATKBD_KEYMAP_SIZE];
212 : : DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
213 : : unsigned char set;
214 : : bool translated;
215 : : bool extra;
216 : : bool write;
217 : : bool softrepeat;
218 : : bool softraw;
219 : : bool scroll;
220 : : bool enabled;
221 : :
222 : : /* Accessed only from interrupt */
223 : : unsigned char emul;
224 : : bool resend;
225 : : bool release;
226 : : unsigned long xl_bit;
227 : : unsigned int last;
228 : : unsigned long time;
229 : : unsigned long err_count;
230 : :
231 : : struct delayed_work event_work;
232 : : unsigned long event_jiffies;
233 : : unsigned long event_mask;
234 : :
235 : : /* Serializes reconnect(), attr->set() and event work */
236 : : struct mutex mutex;
237 : : };
238 : :
239 : : /*
240 : : * System-specific keymap fixup routine
241 : : */
242 : : static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
243 : : static void *atkbd_platform_fixup_data;
244 : : static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
245 : :
246 : : static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
247 : : ssize_t (*handler)(struct atkbd *, char *));
248 : : static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
249 : : ssize_t (*handler)(struct atkbd *, const char *, size_t));
250 : : #define ATKBD_DEFINE_ATTR(_name) \
251 : : static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
252 : : static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
253 : : static ssize_t atkbd_do_show_##_name(struct device *d, \
254 : : struct device_attribute *attr, char *b) \
255 : : { \
256 : : return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
257 : : } \
258 : : static ssize_t atkbd_do_set_##_name(struct device *d, \
259 : : struct device_attribute *attr, const char *b, size_t s) \
260 : : { \
261 : : return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
262 : : } \
263 : : static struct device_attribute atkbd_attr_##_name = \
264 : : __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
265 : :
266 : 0 : ATKBD_DEFINE_ATTR(extra);
267 : 0 : ATKBD_DEFINE_ATTR(force_release);
268 : 0 : ATKBD_DEFINE_ATTR(scroll);
269 : 0 : ATKBD_DEFINE_ATTR(set);
270 : 0 : ATKBD_DEFINE_ATTR(softrepeat);
271 : 0 : ATKBD_DEFINE_ATTR(softraw);
272 : :
273 : : #define ATKBD_DEFINE_RO_ATTR(_name) \
274 : : static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
275 : : static ssize_t atkbd_do_show_##_name(struct device *d, \
276 : : struct device_attribute *attr, char *b) \
277 : : { \
278 : : return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
279 : : } \
280 : : static struct device_attribute atkbd_attr_##_name = \
281 : : __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
282 : :
283 : 0 : ATKBD_DEFINE_RO_ATTR(err_count);
284 : :
285 : : static struct attribute *atkbd_attributes[] = {
286 : : &atkbd_attr_extra.attr,
287 : : &atkbd_attr_force_release.attr,
288 : : &atkbd_attr_scroll.attr,
289 : : &atkbd_attr_set.attr,
290 : : &atkbd_attr_softrepeat.attr,
291 : : &atkbd_attr_softraw.attr,
292 : : &atkbd_attr_err_count.attr,
293 : : NULL
294 : : };
295 : :
296 : : static struct attribute_group atkbd_attribute_group = {
297 : : .attrs = atkbd_attributes,
298 : : };
299 : :
300 : : static const unsigned int xl_table[] = {
301 : : ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
302 : : ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
303 : : };
304 : :
305 : : /*
306 : : * Checks if we should mangle the scancode to extract 'release' bit
307 : : * in translated mode.
308 : : */
309 : 0 : static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
310 : : {
311 : : int i;
312 : :
313 [ # # ]: 0 : if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
314 : : return false;
315 : :
316 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++)
317 [ # # ]: 0 : if (code == xl_table[i])
318 : 0 : return test_bit(i, &xl_bit);
319 : :
320 : : return true;
321 : : }
322 : :
323 : : /*
324 : : * Calculates new value of xl_bit so the driver can distinguish
325 : : * between make/break pair of scancodes for select keys and PS/2
326 : : * protocol responses.
327 : : */
328 : 0 : static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
329 : : {
330 : : int i;
331 : :
332 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
333 [ # # ]: 0 : if (!((code ^ xl_table[i]) & 0x7f)) {
334 [ # # ]: 0 : if (code & 0x80)
335 : 0 : __clear_bit(i, &atkbd->xl_bit);
336 : : else
337 : 0 : __set_bit(i, &atkbd->xl_bit);
338 : : break;
339 : : }
340 : : }
341 : 0 : }
342 : :
343 : : /*
344 : : * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
345 : : * keeping kernel 2.4 compatibility for set 2
346 : : */
347 : : static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
348 : : {
349 [ # # ][ # # ]: 0 : if (atkbd->set == 3) {
[ # # ]
350 [ # # ][ # # ]: 0 : if (atkbd->emul == 1)
[ # # ]
351 : 0 : code |= 0x100;
352 : : } else {
353 : 0 : code = (code & 0x7f) | ((code & 0x80) << 1);
354 [ # # ][ # # ]: 0 : if (atkbd->emul == 1)
[ # # ]
355 : 0 : code |= 0x80;
356 : : }
357 : :
358 : : return code;
359 : : }
360 : :
361 : : /*
362 : : * atkbd_interrupt(). Here takes place processing of data received from
363 : : * the keyboard into events.
364 : : */
365 : :
366 : 0 : static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
367 : : unsigned int flags)
368 : : {
369 : 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
370 : 0 : struct input_dev *dev = atkbd->dev;
371 : 0 : unsigned int code = data;
372 : : int scroll = 0, hscroll = 0, click = -1;
373 : : int value;
374 : : unsigned short keycode;
375 : :
376 : : dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
377 : :
378 : : #if !defined(__i386__) && !defined (__x86_64__)
379 [ # # ][ # # ]: 0 : if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
[ # # ][ # # ]
[ # # ]
380 : 0 : dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
381 : : serio_write(serio, ATKBD_CMD_RESEND);
382 : 0 : atkbd->resend = true;
383 : 0 : goto out;
384 : : }
385 : :
386 [ # # ]: 0 : if (!flags && data == ATKBD_RET_ACK)
387 : 0 : atkbd->resend = false;
388 : : #endif
389 : :
390 [ # # ]: 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
391 [ # # ]: 0 : if (ps2_handle_ack(&atkbd->ps2dev, data))
392 : : goto out;
393 : :
394 [ # # ]: 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
395 [ # # ]: 0 : if (ps2_handle_response(&atkbd->ps2dev, data))
396 : : goto out;
397 : :
398 [ # # ]: 0 : if (!atkbd->enabled)
399 : : goto out;
400 : :
401 : 0 : input_event(dev, EV_MSC, MSC_RAW, code);
402 : :
403 [ # # ]: 0 : if (atkbd_platform_scancode_fixup)
404 : 0 : code = atkbd_platform_scancode_fixup(atkbd, code);
405 : :
406 [ # # ]: 0 : if (atkbd->translated) {
407 : :
408 [ # # ][ # # ]: 0 : if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
409 : 0 : atkbd->release = code >> 7;
410 : 0 : code &= 0x7f;
411 : : }
412 : :
413 [ # # ]: 0 : if (!atkbd->emul)
414 : 0 : atkbd_calculate_xl_bit(atkbd, data);
415 : : }
416 : :
417 [ # # # # : 0 : switch (code) {
# # # ]
418 : : case ATKBD_RET_BAT:
419 : 0 : atkbd->enabled = false;
420 : 0 : serio_reconnect(atkbd->ps2dev.serio);
421 : 0 : goto out;
422 : : case ATKBD_RET_EMUL0:
423 : 0 : atkbd->emul = 1;
424 : 0 : goto out;
425 : : case ATKBD_RET_EMUL1:
426 : 0 : atkbd->emul = 2;
427 : 0 : goto out;
428 : : case ATKBD_RET_RELEASE:
429 : 0 : atkbd->release = true;
430 : 0 : goto out;
431 : : case ATKBD_RET_ACK:
432 : : case ATKBD_RET_NAK:
433 [ # # ]: 0 : if (printk_ratelimit())
434 [ # # ]: 0 : dev_warn(&serio->dev,
435 : : "Spurious %s on %s. "
436 : : "Some program might be trying to access hardware directly.\n",
437 : 0 : data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
438 : : goto out;
439 : : case ATKBD_RET_ERR:
440 : 0 : atkbd->err_count++;
441 : : dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
442 : : serio->phys);
443 : 0 : goto out;
444 : : }
445 : :
446 : : code = atkbd_compat_scancode(atkbd, code);
447 : :
448 [ # # ][ # # ]: 0 : if (atkbd->emul && --atkbd->emul)
449 : : goto out;
450 : :
451 : 0 : keycode = atkbd->keycode[code];
452 : :
453 [ # # ]: 0 : if (keycode != ATKBD_KEY_NULL)
454 : 0 : input_event(dev, EV_MSC, MSC_SCAN, code);
455 : :
456 [ # # # # : 0 : switch (keycode) {
# # # # #
# ]
457 : : case ATKBD_KEY_NULL:
458 : : break;
459 : : case ATKBD_KEY_UNKNOWN:
460 [ # # ][ # # ]: 0 : dev_warn(&serio->dev,
461 : : "Unknown key %s (%s set %d, code %#x on %s).\n",
462 : 0 : atkbd->release ? "released" : "pressed",
463 : 0 : atkbd->translated ? "translated" : "raw",
464 : 0 : atkbd->set, code, serio->phys);
465 [ # # ]: 0 : dev_warn(&serio->dev,
466 : : "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
467 : 0 : code & 0x80 ? "e0" : "", code & 0x7f);
468 : : input_sync(dev);
469 : : break;
470 : : case ATKBD_SCR_1:
471 : : scroll = 1;
472 : 0 : break;
473 : : case ATKBD_SCR_2:
474 : : scroll = 2;
475 : 0 : break;
476 : : case ATKBD_SCR_4:
477 : : scroll = 4;
478 : 0 : break;
479 : : case ATKBD_SCR_8:
480 : : scroll = 8;
481 : 0 : break;
482 : : case ATKBD_SCR_CLICK:
483 : 0 : click = !atkbd->release;
484 : 0 : break;
485 : : case ATKBD_SCR_LEFT:
486 : : hscroll = -1;
487 : 0 : break;
488 : : case ATKBD_SCR_RIGHT:
489 : : hscroll = 1;
490 : 0 : break;
491 : : default:
492 [ # # ]: 0 : if (atkbd->release) {
493 : : value = 0;
494 : 0 : atkbd->last = 0;
495 [ # # ][ # # ]: 0 : } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
496 : : /* Workaround Toshiba laptop multiple keypress */
497 [ # # ][ # # ]: 0 : value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
498 : : } else {
499 : : value = 1;
500 : 0 : atkbd->last = code;
501 : 0 : atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
502 : : }
503 : :
504 : 0 : input_event(dev, EV_KEY, keycode, value);
505 : : input_sync(dev);
506 : :
507 [ # # ][ # # ]: 0 : if (value && test_bit(code, atkbd->force_release_mask)) {
508 : : input_report_key(dev, keycode, 0);
509 : : input_sync(dev);
510 : : }
511 : : }
512 : :
513 [ # # ]: 0 : if (atkbd->scroll) {
514 [ # # ]: 0 : if (click != -1)
515 : : input_report_key(dev, BTN_MIDDLE, click);
516 [ # # ]: 0 : input_report_rel(dev, REL_WHEEL,
517 : 0 : atkbd->release ? -scroll : scroll);
518 : : input_report_rel(dev, REL_HWHEEL, hscroll);
519 : : input_sync(dev);
520 : : }
521 : :
522 : 0 : atkbd->release = false;
523 : : out:
524 : 0 : return IRQ_HANDLED;
525 : : }
526 : :
527 : 0 : static int atkbd_set_repeat_rate(struct atkbd *atkbd)
528 : : {
529 : 0 : const short period[32] =
530 : : { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
531 : : 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
532 : 0 : const short delay[4] =
533 : : { 250, 500, 750, 1000 };
534 : :
535 : 0 : struct input_dev *dev = atkbd->dev;
536 : : unsigned char param;
537 : : int i = 0, j = 0;
538 : :
539 [ # # ][ # # ]: 0 : while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
540 : 0 : i++;
541 : 0 : dev->rep[REP_PERIOD] = period[i];
542 : :
543 [ # # ][ # # ]: 0 : while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
544 : 0 : j++;
545 : 0 : dev->rep[REP_DELAY] = delay[j];
546 : :
547 : 0 : param = i | (j << 5);
548 : 0 : return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
549 : : }
550 : :
551 : 0 : static int atkbd_set_leds(struct atkbd *atkbd)
552 : : {
553 : 0 : struct input_dev *dev = atkbd->dev;
554 : : unsigned char param[2];
555 : :
556 [ # # ][ # # ]: 0 : param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
557 : : | (test_bit(LED_NUML, dev->led) ? 2 : 0)
558 : : | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
559 [ # # ]: 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
560 : : return -1;
561 : :
562 [ # # ]: 0 : if (atkbd->extra) {
563 : 0 : param[0] = 0;
564 [ # # ][ # # ]: 0 : param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
[ # # ][ # # ]
565 : : | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
566 : : | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
567 : : | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
568 : : | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
569 [ # # ]: 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
570 : : return -1;
571 : : }
572 : :
573 : : return 0;
574 : : }
575 : :
576 : : /*
577 : : * atkbd_event_work() is used to complete processing of events that
578 : : * can not be processed by input_event() which is often called from
579 : : * interrupt context.
580 : : */
581 : :
582 : 0 : static void atkbd_event_work(struct work_struct *work)
583 : : {
584 : 0 : struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
585 : :
586 : 0 : mutex_lock(&atkbd->mutex);
587 : :
588 [ # # ]: 0 : if (!atkbd->enabled) {
589 : : /*
590 : : * Serio ports are resumed asynchronously so while driver core
591 : : * thinks that device is already fully operational in reality
592 : : * it may not be ready yet. In this case we need to keep
593 : : * rescheduling till reconnect completes.
594 : : */
595 : 0 : schedule_delayed_work(&atkbd->event_work,
596 : : msecs_to_jiffies(100));
597 : : } else {
598 [ # # ]: 0 : if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
599 : 0 : atkbd_set_leds(atkbd);
600 : :
601 [ # # ]: 0 : if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
602 : 0 : atkbd_set_repeat_rate(atkbd);
603 : : }
604 : :
605 : 0 : mutex_unlock(&atkbd->mutex);
606 : 0 : }
607 : :
608 : : /*
609 : : * Schedule switch for execution. We need to throttle requests,
610 : : * otherwise keyboard may become unresponsive.
611 : : */
612 : 0 : static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
613 : : {
614 : 0 : unsigned long delay = msecs_to_jiffies(50);
615 : :
616 [ # # ]: 0 : if (time_after(jiffies, atkbd->event_jiffies + delay))
617 : : delay = 0;
618 : :
619 : 0 : atkbd->event_jiffies = jiffies;
620 : 0 : set_bit(event_bit, &atkbd->event_mask);
621 : 0 : mb();
622 : 0 : schedule_delayed_work(&atkbd->event_work, delay);
623 : 0 : }
624 : :
625 : : /*
626 : : * Event callback from the input module. Events that change the state of
627 : : * the hardware are processed here. If action can not be performed in
628 : : * interrupt context it is offloaded to atkbd_event_work.
629 : : */
630 : :
631 : 0 : static int atkbd_event(struct input_dev *dev,
632 : : unsigned int type, unsigned int code, int value)
633 : : {
634 : : struct atkbd *atkbd = input_get_drvdata(dev);
635 : :
636 [ # # ]: 0 : if (!atkbd->write)
637 : : return -1;
638 : :
639 [ # # # ]: 0 : switch (type) {
640 : :
641 : : case EV_LED:
642 : 0 : atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
643 : 0 : return 0;
644 : :
645 : : case EV_REP:
646 [ # # ]: 0 : if (!atkbd->softrepeat)
647 : 0 : atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
648 : : return 0;
649 : :
650 : : default:
651 : : return -1;
652 : : }
653 : : }
654 : :
655 : : /*
656 : : * atkbd_enable() signals that interrupt handler is allowed to
657 : : * generate input events.
658 : : */
659 : :
660 : : static inline void atkbd_enable(struct atkbd *atkbd)
661 : : {
662 : 0 : serio_pause_rx(atkbd->ps2dev.serio);
663 : 0 : atkbd->enabled = true;
664 : 0 : serio_continue_rx(atkbd->ps2dev.serio);
665 : : }
666 : :
667 : : /*
668 : : * atkbd_disable() tells input handler that all incoming data except
669 : : * for ACKs and command response should be dropped.
670 : : */
671 : :
672 : : static inline void atkbd_disable(struct atkbd *atkbd)
673 : : {
674 : 0 : serio_pause_rx(atkbd->ps2dev.serio);
675 : 0 : atkbd->enabled = false;
676 : 0 : serio_continue_rx(atkbd->ps2dev.serio);
677 : : }
678 : :
679 : 0 : static int atkbd_activate(struct atkbd *atkbd)
680 : : {
681 : 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
682 : :
683 : : /*
684 : : * Enable the keyboard to receive keystrokes.
685 : : */
686 : :
687 [ # # ]: 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
688 : 0 : dev_err(&ps2dev->serio->dev,
689 : : "Failed to enable keyboard on %s\n",
690 : 0 : ps2dev->serio->phys);
691 : 0 : return -1;
692 : : }
693 : :
694 : : return 0;
695 : : }
696 : :
697 : : /*
698 : : * atkbd_deactivate() resets and disables the keyboard from sending
699 : : * keystrokes.
700 : : */
701 : :
702 : 0 : static void atkbd_deactivate(struct atkbd *atkbd)
703 : : {
704 : 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
705 : :
706 [ # # ]: 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
707 : 0 : dev_err(&ps2dev->serio->dev,
708 : : "Failed to deactivate keyboard on %s\n",
709 : 0 : ps2dev->serio->phys);
710 : 0 : }
711 : :
712 : : /*
713 : : * atkbd_probe() probes for an AT keyboard on a serio port.
714 : : */
715 : :
716 : 0 : static int atkbd_probe(struct atkbd *atkbd)
717 : : {
718 : 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
719 : : unsigned char param[2];
720 : :
721 : : /*
722 : : * Some systems, where the bit-twiddling when testing the io-lines of the
723 : : * controller may confuse the keyboard need a full reset of the keyboard. On
724 : : * these systems the BIOS also usually doesn't do it for us.
725 : : */
726 : :
727 [ # # ]: 0 : if (atkbd_reset)
728 [ # # ]: 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
729 : 0 : dev_warn(&ps2dev->serio->dev,
730 : : "keyboard reset failed on %s\n",
731 : 0 : ps2dev->serio->phys);
732 : :
733 : : /*
734 : : * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
735 : : * Some keyboards report different values, but the first byte is always 0xab or
736 : : * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
737 : : * should make sure we don't try to set the LEDs on it.
738 : : */
739 : :
740 : 0 : param[0] = param[1] = 0xa5; /* initialize with invalid values */
741 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
742 : :
743 : : /*
744 : : * If the get ID command failed, we check if we can at least set the LEDs on
745 : : * the keyboard. This should work on every keyboard out there. It also turns
746 : : * the LEDs off, which we want anyway.
747 : : */
748 : 0 : param[0] = 0;
749 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
750 : : return -1;
751 : 0 : atkbd->id = 0xabba;
752 : 0 : return 0;
753 : : }
754 : :
755 [ # # ]: 0 : if (!ps2_is_keyboard_id(param[0]))
756 : : return -1;
757 : :
758 : 0 : atkbd->id = (param[0] << 8) | param[1];
759 : :
760 [ # # ][ # # ]: 0 : if (atkbd->id == 0xaca1 && atkbd->translated) {
761 : 0 : dev_err(&ps2dev->serio->dev,
762 : : "NCD terminal keyboards are only supported on non-translating controllers. "
763 : : "Use i8042.direct=1 to disable translation.\n");
764 : 0 : return -1;
765 : : }
766 : :
767 : : /*
768 : : * Make sure nothing is coming from the keyboard and disturbs our
769 : : * internal state.
770 : : */
771 : 0 : atkbd_deactivate(atkbd);
772 : :
773 : 0 : return 0;
774 : : }
775 : :
776 : : /*
777 : : * atkbd_select_set checks if a keyboard has a working Set 3 support, and
778 : : * sets it into that. Unfortunately there are keyboards that can be switched
779 : : * to Set 3, but don't work well in that (BTC Multimedia ...)
780 : : */
781 : :
782 : 0 : static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
783 : : {
784 : 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
785 : : unsigned char param[2];
786 : :
787 : 0 : atkbd->extra = false;
788 : : /*
789 : : * For known special keyboards we can go ahead and set the correct set.
790 : : * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
791 : : * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
792 : : */
793 : :
794 [ # # ]: 0 : if (atkbd->translated)
795 : : return 2;
796 : :
797 [ # # ]: 0 : if (atkbd->id == 0xaca1) {
798 : 0 : param[0] = 3;
799 : 0 : ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
800 : 0 : return 3;
801 : : }
802 : :
803 [ # # ]: 0 : if (allow_extra) {
804 : 0 : param[0] = 0x71;
805 [ # # ]: 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
806 : 0 : atkbd->extra = true;
807 : 0 : return 2;
808 : : }
809 : : }
810 : :
811 [ # # ]: 0 : if (atkbd_terminal) {
812 : 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
813 : 0 : return 3;
814 : : }
815 : :
816 [ # # ]: 0 : if (target_set != 3)
817 : : return 2;
818 : :
819 [ # # ]: 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
820 : 0 : atkbd->id = param[0] << 8 | param[1];
821 : 0 : return 2;
822 : : }
823 : :
824 : 0 : param[0] = 3;
825 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
826 : : return 2;
827 : :
828 : 0 : param[0] = 0;
829 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
830 : : return 2;
831 : :
832 [ # # ]: 0 : if (param[0] != 3) {
833 : 0 : param[0] = 2;
834 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
835 : : return 2;
836 : : }
837 : :
838 : 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
839 : :
840 : 0 : return 3;
841 : : }
842 : :
843 : 0 : static int atkbd_reset_state(struct atkbd *atkbd)
844 : : {
845 : 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
846 : : unsigned char param[1];
847 : :
848 : : /*
849 : : * Set the LEDs to a predefined state (all off).
850 : : */
851 : :
852 : 0 : param[0] = 0;
853 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
854 : : return -1;
855 : :
856 : : /*
857 : : * Set autorepeat to fastest possible.
858 : : */
859 : :
860 : 0 : param[0] = 0;
861 [ # # ]: 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
862 : : return -1;
863 : :
864 : 0 : return 0;
865 : : }
866 : :
867 : : /*
868 : : * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
869 : : * reboot.
870 : : */
871 : :
872 : 0 : static void atkbd_cleanup(struct serio *serio)
873 : : {
874 : : struct atkbd *atkbd = serio_get_drvdata(serio);
875 : :
876 : : atkbd_disable(atkbd);
877 : 0 : ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
878 : 0 : }
879 : :
880 : :
881 : : /*
882 : : * atkbd_disconnect() closes and frees.
883 : : */
884 : :
885 : 0 : static void atkbd_disconnect(struct serio *serio)
886 : : {
887 : : struct atkbd *atkbd = serio_get_drvdata(serio);
888 : :
889 : 0 : sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
890 : :
891 : : atkbd_disable(atkbd);
892 : :
893 : 0 : input_unregister_device(atkbd->dev);
894 : :
895 : : /*
896 : : * Make sure we don't have a command in flight.
897 : : * Note that since atkbd->enabled is false event work will keep
898 : : * rescheduling itself until it gets canceled and will not try
899 : : * accessing freed input device or serio port.
900 : : */
901 : 0 : cancel_delayed_work_sync(&atkbd->event_work);
902 : :
903 : 0 : serio_close(serio);
904 : : serio_set_drvdata(serio, NULL);
905 : 0 : kfree(atkbd);
906 : 0 : }
907 : :
908 : : /*
909 : : * generate release events for the keycodes given in data
910 : : */
911 : : static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
912 : : const void *data)
913 : : {
914 : : const unsigned int *keys = data;
915 : : unsigned int i;
916 : :
917 : : if (atkbd->set == 2)
918 : : for (i = 0; keys[i] != -1U; i++)
919 : : __set_bit(keys[i], atkbd->force_release_mask);
920 : : }
921 : :
922 : : /*
923 : : * Most special keys (Fn+F?) on Dell laptops do not generate release
924 : : * events so we have to do it ourselves.
925 : : */
926 : : static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
927 : : 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
928 : : };
929 : :
930 : : /*
931 : : * Perform fixup for HP system that doesn't generate release
932 : : * for its video switch
933 : : */
934 : : static unsigned int atkbd_hp_forced_release_keys[] = {
935 : : 0x94, -1U
936 : : };
937 : :
938 : : /*
939 : : * Samsung NC10,NC20 with Fn+F? key release not working
940 : : */
941 : : static unsigned int atkbd_samsung_forced_release_keys[] = {
942 : : 0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
943 : : };
944 : :
945 : : /*
946 : : * Amilo Pi 3525 key release for Fn+Volume keys not working
947 : : */
948 : : static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
949 : : 0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
950 : : };
951 : :
952 : : /*
953 : : * Amilo Xi 3650 key release for light touch bar not working
954 : : */
955 : : static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
956 : : 0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
957 : : };
958 : :
959 : : /*
960 : : * Soltech TA12 system with broken key release on volume keys and mute key
961 : : */
962 : : static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
963 : : 0xa0, 0xae, 0xb0, -1U
964 : : };
965 : :
966 : : /*
967 : : * Many notebooks don't send key release event for volume up/down
968 : : * keys, with key list below common among them
969 : : */
970 : : static unsigned int atkbd_volume_forced_release_keys[] = {
971 : : 0xae, 0xb0, -1U
972 : : };
973 : :
974 : : /*
975 : : * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
976 : : * they should be generating e4-e6 (0x80 | code).
977 : : */
978 : : static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
979 : : unsigned int code)
980 : : {
981 : : if (atkbd->translated && atkbd->emul == 1 &&
982 : : (code == 0x64 || code == 0x65 || code == 0x66)) {
983 : : atkbd->emul = 0;
984 : : code |= 0x80;
985 : : }
986 : :
987 : : return code;
988 : : }
989 : :
990 : : /*
991 : : * atkbd_set_keycode_table() initializes keyboard's keycode table
992 : : * according to the selected scancode set
993 : : */
994 : :
995 : 0 : static void atkbd_set_keycode_table(struct atkbd *atkbd)
996 : : {
997 : : unsigned int scancode;
998 : : int i, j;
999 : :
1000 : 0 : memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1001 : 0 : bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1002 : :
1003 [ # # ]: 0 : if (atkbd->translated) {
1004 [ # # ]: 0 : for (i = 0; i < 128; i++) {
1005 : 0 : scancode = atkbd_unxlate_table[i];
1006 : 0 : atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1007 : 0 : atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1008 [ # # ]: 0 : if (atkbd->scroll)
1009 [ # # ]: 0 : for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1010 [ # # ]: 0 : if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
1011 : 0 : atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1012 : : }
1013 [ # # ]: 0 : } else if (atkbd->set == 3) {
1014 : 0 : memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1015 : : } else {
1016 : 0 : memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1017 : :
1018 [ # # ]: 0 : if (atkbd->scroll)
1019 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
1020 : 0 : scancode = atkbd_scroll_keys[i].set2;
1021 : 0 : atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1022 : : }
1023 : : }
1024 : :
1025 : : /*
1026 : : * HANGEUL and HANJA keys do not send release events so we need to
1027 : : * generate such events ourselves
1028 : : */
1029 : : scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1030 : 0 : atkbd->keycode[scancode] = KEY_HANGEUL;
1031 : 0 : __set_bit(scancode, atkbd->force_release_mask);
1032 : :
1033 : : scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1034 : 0 : atkbd->keycode[scancode] = KEY_HANJA;
1035 : 0 : __set_bit(scancode, atkbd->force_release_mask);
1036 : :
1037 : : /*
1038 : : * Perform additional fixups
1039 : : */
1040 [ # # ]: 0 : if (atkbd_platform_fixup)
1041 : 0 : atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1042 : 0 : }
1043 : :
1044 : : /*
1045 : : * atkbd_set_device_attrs() sets up keyboard's input device structure
1046 : : */
1047 : :
1048 : 0 : static void atkbd_set_device_attrs(struct atkbd *atkbd)
1049 : : {
1050 : 0 : struct input_dev *input_dev = atkbd->dev;
1051 : : int i;
1052 : :
1053 [ # # ]: 0 : if (atkbd->extra)
1054 : 0 : snprintf(atkbd->name, sizeof(atkbd->name),
1055 : : "AT Set 2 Extra keyboard");
1056 : : else
1057 [ # # ]: 0 : snprintf(atkbd->name, sizeof(atkbd->name),
1058 : : "AT %s Set %d keyboard",
1059 : 0 : atkbd->translated ? "Translated" : "Raw", atkbd->set);
1060 : :
1061 : 0 : snprintf(atkbd->phys, sizeof(atkbd->phys),
1062 : 0 : "%s/input0", atkbd->ps2dev.serio->phys);
1063 : :
1064 : 0 : input_dev->name = atkbd->name;
1065 : 0 : input_dev->phys = atkbd->phys;
1066 : 0 : input_dev->id.bustype = BUS_I8042;
1067 : 0 : input_dev->id.vendor = 0x0001;
1068 [ # # ]: 0 : input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1069 : 0 : input_dev->id.version = atkbd->id;
1070 : 0 : input_dev->event = atkbd_event;
1071 : 0 : input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1072 : :
1073 : : input_set_drvdata(input_dev, atkbd);
1074 : :
1075 : 0 : input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1076 : : BIT_MASK(EV_MSC);
1077 : :
1078 [ # # ]: 0 : if (atkbd->write) {
1079 : 0 : input_dev->evbit[0] |= BIT_MASK(EV_LED);
1080 : 0 : input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1081 : : BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1082 : : }
1083 : :
1084 [ # # ]: 0 : if (atkbd->extra)
1085 : 0 : input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1086 : : BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1087 : : BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1088 : :
1089 [ # # ]: 0 : if (!atkbd->softrepeat) {
1090 : 0 : input_dev->rep[REP_DELAY] = 250;
1091 : 0 : input_dev->rep[REP_PERIOD] = 33;
1092 : : }
1093 : :
1094 [ # # ]: 0 : input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1095 : : BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1096 : :
1097 [ # # ]: 0 : if (atkbd->scroll) {
1098 : 0 : input_dev->evbit[0] |= BIT_MASK(EV_REL);
1099 : 0 : input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1100 : : BIT_MASK(REL_HWHEEL);
1101 : : __set_bit(BTN_MIDDLE, input_dev->keybit);
1102 : : }
1103 : :
1104 : 0 : input_dev->keycode = atkbd->keycode;
1105 : 0 : input_dev->keycodesize = sizeof(unsigned short);
1106 : 0 : input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1107 : :
1108 [ # # ]: 0 : for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1109 [ # # ]: 0 : if (atkbd->keycode[i] != KEY_RESERVED &&
1110 [ # # ]: 0 : atkbd->keycode[i] != ATKBD_KEY_NULL &&
1111 : : atkbd->keycode[i] < ATKBD_SPECIAL) {
1112 : 0 : __set_bit(atkbd->keycode[i], input_dev->keybit);
1113 : : }
1114 : : }
1115 : 0 : }
1116 : :
1117 : : /*
1118 : : * atkbd_connect() is called when the serio module finds an interface
1119 : : * that isn't handled yet by an appropriate device driver. We check if
1120 : : * there is an AT keyboard out there and if yes, we register ourselves
1121 : : * to the input module.
1122 : : */
1123 : :
1124 : 0 : static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1125 : : {
1126 : : struct atkbd *atkbd;
1127 : : struct input_dev *dev;
1128 : : int err = -ENOMEM;
1129 : :
1130 : : atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1131 : 0 : dev = input_allocate_device();
1132 [ # # ]: 0 : if (!atkbd || !dev)
1133 : : goto fail1;
1134 : :
1135 : 0 : atkbd->dev = dev;
1136 : 0 : ps2_init(&atkbd->ps2dev, serio);
1137 : 0 : INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1138 : 0 : mutex_init(&atkbd->mutex);
1139 : :
1140 [ # # # ]: 0 : switch (serio->id.type) {
1141 : :
1142 : : case SERIO_8042_XL:
1143 : 0 : atkbd->translated = true;
1144 : : /* Fall through */
1145 : :
1146 : : case SERIO_8042:
1147 [ # # ]: 0 : if (serio->write)
1148 : 0 : atkbd->write = true;
1149 : : break;
1150 : : }
1151 : :
1152 : 0 : atkbd->softraw = atkbd_softraw;
1153 : 0 : atkbd->softrepeat = atkbd_softrepeat;
1154 : 0 : atkbd->scroll = atkbd_scroll;
1155 : :
1156 [ # # ]: 0 : if (atkbd->softrepeat)
1157 : 0 : atkbd->softraw = true;
1158 : :
1159 : : serio_set_drvdata(serio, atkbd);
1160 : :
1161 : 0 : err = serio_open(serio, drv);
1162 [ # # ]: 0 : if (err)
1163 : : goto fail2;
1164 : :
1165 [ # # ]: 0 : if (atkbd->write) {
1166 : :
1167 [ # # ]: 0 : if (atkbd_probe(atkbd)) {
1168 : : err = -ENODEV;
1169 : : goto fail3;
1170 : : }
1171 : :
1172 : 0 : atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1173 : 0 : atkbd_reset_state(atkbd);
1174 : :
1175 : : } else {
1176 : 0 : atkbd->set = 2;
1177 : 0 : atkbd->id = 0xab00;
1178 : : }
1179 : :
1180 : 0 : atkbd_set_keycode_table(atkbd);
1181 : 0 : atkbd_set_device_attrs(atkbd);
1182 : :
1183 : 0 : err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1184 [ # # ]: 0 : if (err)
1185 : : goto fail3;
1186 : :
1187 : : atkbd_enable(atkbd);
1188 [ # # ]: 0 : if (serio->write)
1189 : 0 : atkbd_activate(atkbd);
1190 : :
1191 : 0 : err = input_register_device(atkbd->dev);
1192 [ # # ]: 0 : if (err)
1193 : : goto fail4;
1194 : :
1195 : : return 0;
1196 : :
1197 : 0 : fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1198 : 0 : fail3: serio_close(serio);
1199 : : fail2: serio_set_drvdata(serio, NULL);
1200 : 0 : fail1: input_free_device(dev);
1201 : 0 : kfree(atkbd);
1202 : 0 : return err;
1203 : : }
1204 : :
1205 : : /*
1206 : : * atkbd_reconnect() tries to restore keyboard into a sane state and is
1207 : : * most likely called on resume.
1208 : : */
1209 : :
1210 : 0 : static int atkbd_reconnect(struct serio *serio)
1211 : : {
1212 : : struct atkbd *atkbd = serio_get_drvdata(serio);
1213 : 0 : struct serio_driver *drv = serio->drv;
1214 : : int retval = -1;
1215 : :
1216 [ # # ]: 0 : if (!atkbd || !drv) {
1217 : : dev_dbg(&serio->dev,
1218 : : "reconnect request, but serio is disconnected, ignoring...\n");
1219 : : return -1;
1220 : : }
1221 : :
1222 : 0 : mutex_lock(&atkbd->mutex);
1223 : :
1224 : : atkbd_disable(atkbd);
1225 : :
1226 [ # # ]: 0 : if (atkbd->write) {
1227 [ # # ]: 0 : if (atkbd_probe(atkbd))
1228 : : goto out;
1229 : :
1230 [ # # ]: 0 : if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1231 : : goto out;
1232 : :
1233 : : /*
1234 : : * Restore LED state and repeat rate. While input core
1235 : : * will do this for us at resume time reconnect may happen
1236 : : * because user requested it via sysfs or simply because
1237 : : * keyboard was unplugged and plugged in again so we need
1238 : : * to do it ourselves here.
1239 : : */
1240 : 0 : atkbd_set_leds(atkbd);
1241 [ # # ]: 0 : if (!atkbd->softrepeat)
1242 : 0 : atkbd_set_repeat_rate(atkbd);
1243 : :
1244 : : }
1245 : :
1246 : : /*
1247 : : * Reset our state machine in case reconnect happened in the middle
1248 : : * of multi-byte scancode.
1249 : : */
1250 : 0 : atkbd->xl_bit = 0;
1251 : 0 : atkbd->emul = 0;
1252 : :
1253 : : atkbd_enable(atkbd);
1254 [ # # ]: 0 : if (atkbd->write)
1255 : 0 : atkbd_activate(atkbd);
1256 : :
1257 : : retval = 0;
1258 : :
1259 : : out:
1260 : 0 : mutex_unlock(&atkbd->mutex);
1261 : 0 : return retval;
1262 : : }
1263 : :
1264 : : static struct serio_device_id atkbd_serio_ids[] = {
1265 : : {
1266 : : .type = SERIO_8042,
1267 : : .proto = SERIO_ANY,
1268 : : .id = SERIO_ANY,
1269 : : .extra = SERIO_ANY,
1270 : : },
1271 : : {
1272 : : .type = SERIO_8042_XL,
1273 : : .proto = SERIO_ANY,
1274 : : .id = SERIO_ANY,
1275 : : .extra = SERIO_ANY,
1276 : : },
1277 : : {
1278 : : .type = SERIO_RS232,
1279 : : .proto = SERIO_PS2SER,
1280 : : .id = SERIO_ANY,
1281 : : .extra = SERIO_ANY,
1282 : : },
1283 : : { 0 }
1284 : : };
1285 : :
1286 : : MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1287 : :
1288 : : static struct serio_driver atkbd_drv = {
1289 : : .driver = {
1290 : : .name = "atkbd",
1291 : : },
1292 : : .description = DRIVER_DESC,
1293 : : .id_table = atkbd_serio_ids,
1294 : : .interrupt = atkbd_interrupt,
1295 : : .connect = atkbd_connect,
1296 : : .reconnect = atkbd_reconnect,
1297 : : .disconnect = atkbd_disconnect,
1298 : : .cleanup = atkbd_cleanup,
1299 : : };
1300 : :
1301 : : static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1302 : : ssize_t (*handler)(struct atkbd *, char *))
1303 : : {
1304 : : struct serio *serio = to_serio_port(dev);
1305 : : struct atkbd *atkbd = serio_get_drvdata(serio);
1306 : :
1307 : 0 : return handler(atkbd, buf);
1308 : : }
1309 : :
1310 : 0 : static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1311 : : ssize_t (*handler)(struct atkbd *, const char *, size_t))
1312 : : {
1313 : : struct serio *serio = to_serio_port(dev);
1314 : : struct atkbd *atkbd = serio_get_drvdata(serio);
1315 : : int retval;
1316 : :
1317 : 0 : retval = mutex_lock_interruptible(&atkbd->mutex);
1318 [ # # ]: 0 : if (retval)
1319 : : return retval;
1320 : :
1321 : : atkbd_disable(atkbd);
1322 : 0 : retval = handler(atkbd, buf, count);
1323 : : atkbd_enable(atkbd);
1324 : :
1325 : 0 : mutex_unlock(&atkbd->mutex);
1326 : :
1327 : 0 : return retval;
1328 : : }
1329 : :
1330 : 0 : static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1331 : : {
1332 : 0 : return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1333 : : }
1334 : :
1335 : 0 : static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1336 : : {
1337 : : struct input_dev *old_dev, *new_dev;
1338 : : unsigned int value;
1339 : : int err;
1340 : : bool old_extra;
1341 : : unsigned char old_set;
1342 : :
1343 [ # # ]: 0 : if (!atkbd->write)
1344 : : return -EIO;
1345 : :
1346 : 0 : err = kstrtouint(buf, 10, &value);
1347 [ # # ]: 0 : if (err)
1348 : : return err;
1349 : :
1350 [ # # ]: 0 : if (value > 1)
1351 : : return -EINVAL;
1352 : :
1353 [ # # ]: 0 : if (atkbd->extra != value) {
1354 : : /*
1355 : : * Since device's properties will change we need to
1356 : : * unregister old device. But allocate and register
1357 : : * new one first to make sure we have it.
1358 : : */
1359 : 0 : old_dev = atkbd->dev;
1360 : : old_extra = atkbd->extra;
1361 : 0 : old_set = atkbd->set;
1362 : :
1363 : 0 : new_dev = input_allocate_device();
1364 [ # # ]: 0 : if (!new_dev)
1365 : : return -ENOMEM;
1366 : :
1367 : 0 : atkbd->dev = new_dev;
1368 : 0 : atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1369 : 0 : atkbd_reset_state(atkbd);
1370 : 0 : atkbd_activate(atkbd);
1371 : 0 : atkbd_set_keycode_table(atkbd);
1372 : 0 : atkbd_set_device_attrs(atkbd);
1373 : :
1374 : 0 : err = input_register_device(atkbd->dev);
1375 [ # # ]: 0 : if (err) {
1376 : 0 : input_free_device(new_dev);
1377 : :
1378 : 0 : atkbd->dev = old_dev;
1379 : 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1380 : 0 : atkbd_set_keycode_table(atkbd);
1381 : 0 : atkbd_set_device_attrs(atkbd);
1382 : :
1383 : 0 : return err;
1384 : : }
1385 : 0 : input_unregister_device(old_dev);
1386 : :
1387 : : }
1388 : 0 : return count;
1389 : : }
1390 : :
1391 : 0 : static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1392 : : {
1393 : 0 : size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1394 : 0 : atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1395 : :
1396 : 0 : buf[len++] = '\n';
1397 : 0 : buf[len] = '\0';
1398 : :
1399 : 0 : return len;
1400 : : }
1401 : :
1402 : 0 : static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1403 : : const char *buf, size_t count)
1404 : : {
1405 : : /* 64 bytes on stack should be acceptable */
1406 : : DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1407 : : int err;
1408 : :
1409 : 0 : err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1410 [ # # ]: 0 : if (err)
1411 : : return err;
1412 : :
1413 : 0 : memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1414 : 0 : return count;
1415 : : }
1416 : :
1417 : :
1418 : 0 : static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1419 : : {
1420 : 0 : return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1421 : : }
1422 : :
1423 : 0 : static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1424 : : {
1425 : : struct input_dev *old_dev, *new_dev;
1426 : : unsigned int value;
1427 : : int err;
1428 : : bool old_scroll;
1429 : :
1430 : 0 : err = kstrtouint(buf, 10, &value);
1431 [ # # ]: 0 : if (err)
1432 : : return err;
1433 : :
1434 [ # # ]: 0 : if (value > 1)
1435 : : return -EINVAL;
1436 : :
1437 [ # # ]: 0 : if (atkbd->scroll != value) {
1438 : 0 : old_dev = atkbd->dev;
1439 : : old_scroll = atkbd->scroll;
1440 : :
1441 : 0 : new_dev = input_allocate_device();
1442 [ # # ]: 0 : if (!new_dev)
1443 : : return -ENOMEM;
1444 : :
1445 : 0 : atkbd->dev = new_dev;
1446 : 0 : atkbd->scroll = value;
1447 : 0 : atkbd_set_keycode_table(atkbd);
1448 : 0 : atkbd_set_device_attrs(atkbd);
1449 : :
1450 : 0 : err = input_register_device(atkbd->dev);
1451 [ # # ]: 0 : if (err) {
1452 : 0 : input_free_device(new_dev);
1453 : :
1454 : 0 : atkbd->scroll = old_scroll;
1455 : 0 : atkbd->dev = old_dev;
1456 : 0 : atkbd_set_keycode_table(atkbd);
1457 : 0 : atkbd_set_device_attrs(atkbd);
1458 : :
1459 : 0 : return err;
1460 : : }
1461 : 0 : input_unregister_device(old_dev);
1462 : : }
1463 : 0 : return count;
1464 : : }
1465 : :
1466 : 0 : static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1467 : : {
1468 : 0 : return sprintf(buf, "%d\n", atkbd->set);
1469 : : }
1470 : :
1471 : 0 : static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1472 : : {
1473 : : struct input_dev *old_dev, *new_dev;
1474 : : unsigned int value;
1475 : : int err;
1476 : : unsigned char old_set;
1477 : : bool old_extra;
1478 : :
1479 [ # # ]: 0 : if (!atkbd->write)
1480 : : return -EIO;
1481 : :
1482 : 0 : err = kstrtouint(buf, 10, &value);
1483 [ # # ]: 0 : if (err)
1484 : : return err;
1485 : :
1486 [ # # ]: 0 : if (value != 2 && value != 3)
1487 : : return -EINVAL;
1488 : :
1489 [ # # ]: 0 : if (atkbd->set != value) {
1490 : 0 : old_dev = atkbd->dev;
1491 : 0 : old_extra = atkbd->extra;
1492 : : old_set = atkbd->set;
1493 : :
1494 : 0 : new_dev = input_allocate_device();
1495 [ # # ]: 0 : if (!new_dev)
1496 : : return -ENOMEM;
1497 : :
1498 : 0 : atkbd->dev = new_dev;
1499 : 0 : atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1500 : 0 : atkbd_reset_state(atkbd);
1501 : 0 : atkbd_activate(atkbd);
1502 : 0 : atkbd_set_keycode_table(atkbd);
1503 : 0 : atkbd_set_device_attrs(atkbd);
1504 : :
1505 : 0 : err = input_register_device(atkbd->dev);
1506 [ # # ]: 0 : if (err) {
1507 : 0 : input_free_device(new_dev);
1508 : :
1509 : 0 : atkbd->dev = old_dev;
1510 : 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1511 : 0 : atkbd_set_keycode_table(atkbd);
1512 : 0 : atkbd_set_device_attrs(atkbd);
1513 : :
1514 : 0 : return err;
1515 : : }
1516 : 0 : input_unregister_device(old_dev);
1517 : : }
1518 : 0 : return count;
1519 : : }
1520 : :
1521 : 0 : static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1522 : : {
1523 : 0 : return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1524 : : }
1525 : :
1526 : 0 : static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1527 : : {
1528 : : struct input_dev *old_dev, *new_dev;
1529 : : unsigned int value;
1530 : : int err;
1531 : : bool old_softrepeat, old_softraw;
1532 : :
1533 [ # # ]: 0 : if (!atkbd->write)
1534 : : return -EIO;
1535 : :
1536 : 0 : err = kstrtouint(buf, 10, &value);
1537 [ # # ]: 0 : if (err)
1538 : : return err;
1539 : :
1540 [ # # ]: 0 : if (value > 1)
1541 : : return -EINVAL;
1542 : :
1543 [ # # ]: 0 : if (atkbd->softrepeat != value) {
1544 : 0 : old_dev = atkbd->dev;
1545 : : old_softrepeat = atkbd->softrepeat;
1546 : 0 : old_softraw = atkbd->softraw;
1547 : :
1548 : 0 : new_dev = input_allocate_device();
1549 [ # # ]: 0 : if (!new_dev)
1550 : : return -ENOMEM;
1551 : :
1552 : 0 : atkbd->dev = new_dev;
1553 : 0 : atkbd->softrepeat = value;
1554 [ # # ]: 0 : if (atkbd->softrepeat)
1555 : 0 : atkbd->softraw = true;
1556 : 0 : atkbd_set_device_attrs(atkbd);
1557 : :
1558 : 0 : err = input_register_device(atkbd->dev);
1559 [ # # ]: 0 : if (err) {
1560 : 0 : input_free_device(new_dev);
1561 : :
1562 : 0 : atkbd->dev = old_dev;
1563 : 0 : atkbd->softrepeat = old_softrepeat;
1564 : 0 : atkbd->softraw = old_softraw;
1565 : 0 : atkbd_set_device_attrs(atkbd);
1566 : :
1567 : 0 : return err;
1568 : : }
1569 : 0 : input_unregister_device(old_dev);
1570 : : }
1571 : 0 : return count;
1572 : : }
1573 : :
1574 : :
1575 : 0 : static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1576 : : {
1577 : 0 : return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1578 : : }
1579 : :
1580 : 0 : static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1581 : : {
1582 : : struct input_dev *old_dev, *new_dev;
1583 : : unsigned int value;
1584 : : int err;
1585 : : bool old_softraw;
1586 : :
1587 : 0 : err = kstrtouint(buf, 10, &value);
1588 [ # # ]: 0 : if (err)
1589 : : return err;
1590 : :
1591 [ # # ]: 0 : if (value > 1)
1592 : : return -EINVAL;
1593 : :
1594 [ # # ]: 0 : if (atkbd->softraw != value) {
1595 : 0 : old_dev = atkbd->dev;
1596 : : old_softraw = atkbd->softraw;
1597 : :
1598 : 0 : new_dev = input_allocate_device();
1599 [ # # ]: 0 : if (!new_dev)
1600 : : return -ENOMEM;
1601 : :
1602 : 0 : atkbd->dev = new_dev;
1603 : 0 : atkbd->softraw = value;
1604 : 0 : atkbd_set_device_attrs(atkbd);
1605 : :
1606 : 0 : err = input_register_device(atkbd->dev);
1607 [ # # ]: 0 : if (err) {
1608 : 0 : input_free_device(new_dev);
1609 : :
1610 : 0 : atkbd->dev = old_dev;
1611 : 0 : atkbd->softraw = old_softraw;
1612 : 0 : atkbd_set_device_attrs(atkbd);
1613 : :
1614 : 0 : return err;
1615 : : }
1616 : 0 : input_unregister_device(old_dev);
1617 : : }
1618 : 0 : return count;
1619 : : }
1620 : :
1621 : 0 : static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1622 : : {
1623 : 0 : return sprintf(buf, "%lu\n", atkbd->err_count);
1624 : : }
1625 : :
1626 : : static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1627 : : {
1628 : : atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1629 : : atkbd_platform_fixup_data = id->driver_data;
1630 : :
1631 : : return 1;
1632 : : }
1633 : :
1634 : : static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1635 : : {
1636 : : atkbd_platform_scancode_fixup = id->driver_data;
1637 : :
1638 : : return 1;
1639 : : }
1640 : :
1641 : : static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1642 : : {
1643 : : .matches = {
1644 : : DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1645 : : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1646 : : },
1647 : : .callback = atkbd_setup_forced_release,
1648 : : .driver_data = atkbd_dell_laptop_forced_release_keys,
1649 : : },
1650 : : {
1651 : : .matches = {
1652 : : DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1653 : : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1654 : : },
1655 : : .callback = atkbd_setup_forced_release,
1656 : : .driver_data = atkbd_dell_laptop_forced_release_keys,
1657 : : },
1658 : : {
1659 : : .matches = {
1660 : : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1661 : : DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1662 : : },
1663 : : .callback = atkbd_setup_forced_release,
1664 : : .driver_data = atkbd_hp_forced_release_keys,
1665 : : },
1666 : : {
1667 : : .matches = {
1668 : : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1669 : : DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1670 : : },
1671 : : .callback = atkbd_setup_forced_release,
1672 : : .driver_data = atkbd_volume_forced_release_keys,
1673 : : },
1674 : : {
1675 : : .matches = {
1676 : : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1677 : : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1678 : : },
1679 : : .callback = atkbd_setup_forced_release,
1680 : : .driver_data = atkbd_volume_forced_release_keys,
1681 : : },
1682 : : {
1683 : : .matches = {
1684 : : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1685 : : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1686 : : },
1687 : : .callback = atkbd_setup_forced_release,
1688 : : .driver_data = atkbd_volume_forced_release_keys,
1689 : : },
1690 : : {
1691 : : .matches = {
1692 : : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1693 : : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1694 : : },
1695 : : .callback = atkbd_setup_forced_release,
1696 : : .driver_data = atkbd_volume_forced_release_keys,
1697 : : },
1698 : : {
1699 : : /* Inventec Symphony */
1700 : : .matches = {
1701 : : DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1702 : : DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1703 : : },
1704 : : .callback = atkbd_setup_forced_release,
1705 : : .driver_data = atkbd_volume_forced_release_keys,
1706 : : },
1707 : : {
1708 : : /* Samsung NC10 */
1709 : : .matches = {
1710 : : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1711 : : DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1712 : : },
1713 : : .callback = atkbd_setup_forced_release,
1714 : : .driver_data = atkbd_samsung_forced_release_keys,
1715 : : },
1716 : : {
1717 : : /* Samsung NC20 */
1718 : : .matches = {
1719 : : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1720 : : DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1721 : : },
1722 : : .callback = atkbd_setup_forced_release,
1723 : : .driver_data = atkbd_samsung_forced_release_keys,
1724 : : },
1725 : : {
1726 : : /* Samsung SQ45S70S */
1727 : : .matches = {
1728 : : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1729 : : DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1730 : : },
1731 : : .callback = atkbd_setup_forced_release,
1732 : : .driver_data = atkbd_samsung_forced_release_keys,
1733 : : },
1734 : : {
1735 : : /* Fujitsu Amilo PA 1510 */
1736 : : .matches = {
1737 : : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1738 : : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1739 : : },
1740 : : .callback = atkbd_setup_forced_release,
1741 : : .driver_data = atkbd_volume_forced_release_keys,
1742 : : },
1743 : : {
1744 : : /* Fujitsu Amilo Pi 3525 */
1745 : : .matches = {
1746 : : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1747 : : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1748 : : },
1749 : : .callback = atkbd_setup_forced_release,
1750 : : .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1751 : : },
1752 : : {
1753 : : /* Fujitsu Amilo Xi 3650 */
1754 : : .matches = {
1755 : : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1756 : : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1757 : : },
1758 : : .callback = atkbd_setup_forced_release,
1759 : : .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1760 : : },
1761 : : {
1762 : : .matches = {
1763 : : DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1764 : : DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1765 : : },
1766 : : .callback = atkbd_setup_forced_release,
1767 : : .driver_data = atkdb_soltech_ta12_forced_release_keys,
1768 : : },
1769 : : {
1770 : : /* OQO Model 01+ */
1771 : : .matches = {
1772 : : DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1773 : : DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1774 : : },
1775 : : .callback = atkbd_setup_scancode_fixup,
1776 : : .driver_data = atkbd_oqo_01plus_scancode_fixup,
1777 : : },
1778 : : { }
1779 : : };
1780 : :
1781 : 0 : static int __init atkbd_init(void)
1782 : : {
1783 : : dmi_check_system(atkbd_dmi_quirk_table);
1784 : :
1785 : 0 : return serio_register_driver(&atkbd_drv);
1786 : : }
1787 : :
1788 : 0 : static void __exit atkbd_exit(void)
1789 : : {
1790 : 0 : serio_unregister_driver(&atkbd_drv);
1791 : 0 : }
1792 : :
1793 : : module_init(atkbd_init);
1794 : : module_exit(atkbd_exit);
|
