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