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