drivers/input/keyboard/atkbd.c

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