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