Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/input/keyboard/atkbd.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us