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