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