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