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