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