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_activate(struct atkbd *atkbd)
 774 {
 775         struct ps2dev *ps2dev = &atkbd->ps2dev;
 776         unsigned char param[1];
 777
 778 /*
 779  * Set the LEDs to a defined state.
 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 /*
 795  * Enable the keyboard to receive keystrokes.
 796  */
 797
 798         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 799                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
 800                         ps2dev->serio->phys);
 801                 return -1;
 802         }
 803
 804         return 0;
 805 }
 806
 807 /*
 808  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 809  * reboot.
 810  */
 811
 812 static void atkbd_cleanup(struct serio *serio)
 813 {
 814         struct atkbd *atkbd = serio_get_drvdata(serio);
 815
 816         atkbd_disable(atkbd);
 817         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
 818 }
 819
 820
 821 /*
 822  * atkbd_disconnect() closes and frees.
 823  */
 824
 825 static void atkbd_disconnect(struct serio *serio)
 826 {
 827         struct atkbd *atkbd = serio_get_drvdata(serio);
 828
 829         atkbd_disable(atkbd);
 830
 831         /* make sure we don't have a command in flight */
 832         cancel_delayed_work_sync(&atkbd->event_work);
 833
 834         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 835         input_unregister_device(atkbd->dev);
 836         serio_close(serio);
 837         serio_set_drvdata(serio, NULL);
 838         kfree(atkbd);
 839 }
 840
 841 /*
 842  * generate release events for the keycodes given in data
 843  */
 844 static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
 845                                                 const void *data)
 846 {
 847         const unsigned int *keys = data;
 848         unsigned int i;
 849
 850         if (atkbd->set == 2)
 851                 for (i = 0; keys[i] != -1U; i++)
 852                         __set_bit(keys[i], atkbd->force_release_mask);
 853 }
 854
 855 /*
 856  * Most special keys (Fn+F?) on Dell laptops do not generate release
 857  * events so we have to do it ourselves.
 858  */
 859 static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
 860         0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
 861 };
 862
 863 /*
 864  * Perform fixup for HP system that doesn't generate release
 865  * for its video switch
 866  */
 867 static unsigned int atkbd_hp_forced_release_keys[] = {
 868         0x94, -1U
 869 };
 870
 871 /*
 872  * Inventec system with broken key release on volume keys
 873  */
 874 static unsigned int atkbd_inventec_forced_release_keys[] = {
 875         0xae, 0xb0, -1U
 876 };
 877
 878 /*
 879  * Perform fixup for HP Pavilion ZV6100 laptop that doesn't generate release
 880  * for its volume buttons
 881  */
 882 static unsigned int atkbd_hp_zv6100_forced_release_keys[] = {
 883         0xae, 0xb0, -1U
 884 };
 885
 886 /*
 887  * Perform fixup for HP (Compaq) Presario R4000 R4100 R4200 that don't generate
 888  * release for their volume buttons
 889  */
 890 static unsigned int atkbd_hp_r4000_forced_release_keys[] = {
 891         0xae, 0xb0, -1U
 892 };
 893
 894 /*
 895  * Samsung NC10,NC20 with Fn+F? key release not working
 896  */
 897 static unsigned int atkbd_samsung_forced_release_keys[] = {
 898         0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
 899 };
 900
 901 /*
 902  * The volume up and volume down special keys on a Fujitsu Amilo PA 1510 laptop
 903  * do not generate release events so we have to do it ourselves.
 904  */
 905 static unsigned int atkbd_amilo_pa1510_forced_release_keys[] = {
 906         0xb0, 0xae, -1U
 907 };
 908
 909 /*
 910  * Amilo Pi 3525 key release for Fn+Volume keys not working
 911  */
 912 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
 913         0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
 914 };
 915
 916 /*
 917  * Amilo Xi 3650 key release for light touch bar not working
 918  */
 919 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
 920         0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
 921 };
 922
 923 /*
 924  * Soltech TA12 system with broken key release on volume keys and mute key
 925  */
 926 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
 927         0xa0, 0xae, 0xb0, -1U
 928 };
 929
 930 /*
 931  * atkbd_set_keycode_table() initializes keyboard's keycode table
 932  * according to the selected scancode set
 933  */
 934
 935 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 936 {
 937         unsigned int scancode;
 938         int i, j;
 939
 940         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 941         bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
 942
 943         if (atkbd->translated) {
 944                 for (i = 0; i < 128; i++) {
 945                         scancode = atkbd_unxlate_table[i];
 946                         atkbd->keycode[i] = atkbd_set2_keycode[scancode];
 947                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
 948                         if (atkbd->scroll)
 949                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 950                                         if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
 951                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 952                 }
 953         } else if (atkbd->set == 3) {
 954                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 955         } else {
 956                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 957
 958                 if (atkbd->scroll)
 959                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
 960                                 scancode = atkbd_scroll_keys[i].set2;
 961                                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
 962                 }
 963         }
 964
 965 /*
 966  * HANGEUL and HANJA keys do not send release events so we need to
 967  * generate such events ourselves
 968  */
 969         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
 970         atkbd->keycode[scancode] = KEY_HANGEUL;
 971         __set_bit(scancode, atkbd->force_release_mask);
 972
 973         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
 974         atkbd->keycode[scancode] = KEY_HANJA;
 975         __set_bit(scancode, atkbd->force_release_mask);
 976
 977 /*
 978  * Perform additional fixups
 979  */
 980         if (atkbd_platform_fixup)
 981                 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
 982 }
 983
 984 /*
 985  * atkbd_set_device_attrs() sets up keyboard's input device structure
 986  */
 987
 988 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 989 {
 990         struct input_dev *input_dev = atkbd->dev;
 991         int i;
 992
 993         if (atkbd->extra)
 994                 snprintf(atkbd->name, sizeof(atkbd->name),
 995                          "AT Set 2 Extra keyboard");
 996         else
 997                 snprintf(atkbd->name, sizeof(atkbd->name),
 998                          "AT %s Set %d keyboard",
 999                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
1000
1001         snprintf(atkbd->phys, sizeof(atkbd->phys),
1002                  "%s/input0", atkbd->ps2dev.serio->phys);
1003
1004         input_dev->name = atkbd->name;
1005         input_dev->phys = atkbd->phys;
1006         input_dev->id.bustype = BUS_I8042;
1007         input_dev->id.vendor = 0x0001;
1008         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1009         input_dev->id.version = atkbd->id;
1010         input_dev->event = atkbd_event;
1011         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1012
1013         input_set_drvdata(input_dev, atkbd);
1014
1015         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1016                 BIT_MASK(EV_MSC);
1017
1018         if (atkbd->write) {
1019                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1020                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1021                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1022         }
1023
1024         if (atkbd->extra)
1025                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1026                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1027                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1028
1029         if (!atkbd->softrepeat) {
1030                 input_dev->rep[REP_DELAY] = 250;
1031                 input_dev->rep[REP_PERIOD] = 33;
1032         }
1033
1034         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1035                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1036
1037         if (atkbd->scroll) {
1038                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1039                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1040                         BIT_MASK(REL_HWHEEL);
1041                 __set_bit(BTN_MIDDLE, input_dev->keybit);
1042         }
1043
1044         input_dev->keycode = atkbd->keycode;
1045         input_dev->keycodesize = sizeof(unsigned short);
1046         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1047
1048         for (i = 0; i < ATKBD_KEYMAP_SIZE; i++)
1049                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
1050                         __set_bit(atkbd->keycode[i], input_dev->keybit);
1051 }
1052
1053 /*
1054  * atkbd_connect() is called when the serio module finds an interface
1055  * that isn't handled yet by an appropriate device driver. We check if
1056  * there is an AT keyboard out there and if yes, we register ourselves
1057  * to the input module.
1058  */
1059
1060 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1061 {
1062         struct atkbd *atkbd;
1063         struct input_dev *dev;
1064         int err = -ENOMEM;
1065
1066         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1067         dev = input_allocate_device();
1068         if (!atkbd || !dev)
1069                 goto fail1;
1070
1071         atkbd->dev = dev;
1072         ps2_init(&atkbd->ps2dev, serio);
1073         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1074         mutex_init(&atkbd->event_mutex);
1075
1076         switch (serio->id.type) {
1077
1078                 case SERIO_8042_XL:
1079                         atkbd->translated = 1;
1080                 case SERIO_8042:
1081                         if (serio->write)
1082                                 atkbd->write = 1;
1083                         break;
1084         }
1085
1086         atkbd->softraw = atkbd_softraw;
1087         atkbd->softrepeat = atkbd_softrepeat;
1088         atkbd->scroll = atkbd_scroll;
1089
1090         if (atkbd->softrepeat)
1091                 atkbd->softraw = 1;
1092
1093         serio_set_drvdata(serio, atkbd);
1094
1095         err = serio_open(serio, drv);
1096         if (err)
1097                 goto fail2;
1098
1099         if (atkbd->write) {
1100
1101                 if (atkbd_probe(atkbd)) {
1102                         err = -ENODEV;
1103                         goto fail3;
1104                 }
1105
1106                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1107                 atkbd_activate(atkbd);
1108
1109         } else {
1110                 atkbd->set = 2;
1111                 atkbd->id = 0xab00;
1112         }
1113
1114         atkbd_set_keycode_table(atkbd);
1115         atkbd_set_device_attrs(atkbd);
1116
1117         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1118         if (err)
1119                 goto fail3;
1120
1121         atkbd_enable(atkbd);
1122
1123         err = input_register_device(atkbd->dev);
1124         if (err)
1125                 goto fail4;
1126
1127         return 0;
1128
1129  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1130  fail3: serio_close(serio);
1131  fail2: serio_set_drvdata(serio, NULL);
1132  fail1: input_free_device(dev);
1133         kfree(atkbd);
1134         return err;
1135 }
1136
1137 /*
1138  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1139  * most likely called on resume.
1140  */
1141
1142 static int atkbd_reconnect(struct serio *serio)
1143 {
1144         struct atkbd *atkbd = serio_get_drvdata(serio);
1145         struct serio_driver *drv = serio->drv;
1146
1147         if (!atkbd || !drv) {
1148                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1149                 return -1;
1150         }
1151
1152         atkbd_disable(atkbd);
1153
1154         if (atkbd->write) {
1155                 if (atkbd_probe(atkbd))
1156                         return -1;
1157                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1158                         return -1;
1159
1160                 atkbd_activate(atkbd);
1161
1162 /*
1163  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1164  * to pre-resume state
1165  */
1166                 if (!atkbd->softrepeat)
1167                         atkbd_set_repeat_rate(atkbd);
1168                 atkbd_set_leds(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_activate(atkbd);
1296                 atkbd_set_keycode_table(atkbd);
1297                 atkbd_set_device_attrs(atkbd);
1298
1299                 err = input_register_device(atkbd->dev);
1300                 if (err) {
1301                         input_free_device(new_dev);
1302
1303                         atkbd->dev = old_dev;
1304                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1305                         atkbd_set_keycode_table(atkbd);
1306                         atkbd_set_device_attrs(atkbd);
1307
1308                         return err;
1309                 }
1310                 input_unregister_device(old_dev);
1311
1312         }
1313         return count;
1314 }
1315
1316 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1317 {
1318         size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1319                         atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1320
1321         buf[len++] = '\n';
1322         buf[len] = '\0';
1323
1324         return len;
1325 }
1326
1327 static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1328                                         const char *buf, size_t count)
1329 {
1330         /* 64 bytes on stack should be acceptable */
1331         DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1332         int err;
1333
1334         err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1335         if (err)
1336                 return err;
1337
1338         memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1339         return count;
1340 }
1341
1342
1343 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1344 {
1345         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1346 }
1347
1348 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1349 {
1350         struct input_dev *old_dev, *new_dev;
1351         unsigned long value;
1352         int err;
1353         unsigned char old_scroll;
1354
1355         if (strict_strtoul(buf, 10, &value) || value > 1)
1356                 return -EINVAL;
1357
1358         if (atkbd->scroll != value) {
1359                 old_dev = atkbd->dev;
1360                 old_scroll = atkbd->scroll;
1361
1362                 new_dev = input_allocate_device();
1363                 if (!new_dev)
1364                         return -ENOMEM;
1365
1366                 atkbd->dev = new_dev;
1367                 atkbd->scroll = value;
1368                 atkbd_set_keycode_table(atkbd);
1369                 atkbd_set_device_attrs(atkbd);
1370
1371                 err = input_register_device(atkbd->dev);
1372                 if (err) {
1373                         input_free_device(new_dev);
1374
1375                         atkbd->scroll = old_scroll;
1376                         atkbd->dev = old_dev;
1377                         atkbd_set_keycode_table(atkbd);
1378                         atkbd_set_device_attrs(atkbd);
1379
1380                         return err;
1381                 }
1382                 input_unregister_device(old_dev);
1383         }
1384         return count;
1385 }
1386
1387 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1388 {
1389         return sprintf(buf, "%d\n", atkbd->set);
1390 }
1391
1392 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1393 {
1394         struct input_dev *old_dev, *new_dev;
1395         unsigned long value;
1396         int err;
1397         unsigned char old_set, old_extra;
1398
1399         if (!atkbd->write)
1400                 return -EIO;
1401
1402         if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1403                 return -EINVAL;
1404
1405         if (atkbd->set != value) {
1406                 old_dev = atkbd->dev;
1407                 old_extra = atkbd->extra;
1408                 old_set = atkbd->set;
1409
1410                 new_dev = input_allocate_device();
1411                 if (!new_dev)
1412                         return -ENOMEM;
1413
1414                 atkbd->dev = new_dev;
1415                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1416                 atkbd_activate(atkbd);
1417                 atkbd_set_keycode_table(atkbd);
1418                 atkbd_set_device_attrs(atkbd);
1419
1420                 err = input_register_device(atkbd->dev);
1421                 if (err) {
1422                         input_free_device(new_dev);
1423
1424                         atkbd->dev = old_dev;
1425                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1426                         atkbd_set_keycode_table(atkbd);
1427                         atkbd_set_device_attrs(atkbd);
1428
1429                         return err;
1430                 }
1431                 input_unregister_device(old_dev);
1432         }
1433         return count;
1434 }
1435
1436 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1437 {
1438         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1439 }
1440
1441 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1442 {
1443         struct input_dev *old_dev, *new_dev;
1444         unsigned long value;
1445         int err;
1446         unsigned char old_softrepeat, old_softraw;
1447
1448         if (!atkbd->write)
1449                 return -EIO;
1450
1451         if (strict_strtoul(buf, 10, &value) || value > 1)
1452                 return -EINVAL;
1453
1454         if (atkbd->softrepeat != value) {
1455                 old_dev = atkbd->dev;
1456                 old_softrepeat = atkbd->softrepeat;
1457                 old_softraw = atkbd->softraw;
1458
1459                 new_dev = input_allocate_device();
1460                 if (!new_dev)
1461                         return -ENOMEM;
1462
1463                 atkbd->dev = new_dev;
1464                 atkbd->softrepeat = value;
1465                 if (atkbd->softrepeat)
1466                         atkbd->softraw = 1;
1467                 atkbd_set_device_attrs(atkbd);
1468
1469                 err = input_register_device(atkbd->dev);
1470                 if (err) {
1471                         input_free_device(new_dev);
1472
1473                         atkbd->dev = old_dev;
1474                         atkbd->softrepeat = old_softrepeat;
1475                         atkbd->softraw = old_softraw;
1476                         atkbd_set_device_attrs(atkbd);
1477
1478                         return err;
1479                 }
1480                 input_unregister_device(old_dev);
1481         }
1482         return count;
1483 }
1484
1485
1486 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1487 {
1488         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1489 }
1490
1491 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1492 {
1493         struct input_dev *old_dev, *new_dev;
1494         unsigned long value;
1495         int err;
1496         unsigned char old_softraw;
1497
1498         if (strict_strtoul(buf, 10, &value) || value > 1)
1499                 return -EINVAL;
1500
1501         if (atkbd->softraw != value) {
1502                 old_dev = atkbd->dev;
1503                 old_softraw = atkbd->softraw;
1504
1505                 new_dev = input_allocate_device();
1506                 if (!new_dev)
1507                         return -ENOMEM;
1508
1509                 atkbd->dev = new_dev;
1510                 atkbd->softraw = value;
1511                 atkbd_set_device_attrs(atkbd);
1512
1513                 err = input_register_device(atkbd->dev);
1514                 if (err) {
1515                         input_free_device(new_dev);
1516
1517                         atkbd->dev = old_dev;
1518                         atkbd->softraw = old_softraw;
1519                         atkbd_set_device_attrs(atkbd);
1520
1521                         return err;
1522                 }
1523                 input_unregister_device(old_dev);
1524         }
1525         return count;
1526 }
1527
1528 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1529 {
1530         return sprintf(buf, "%lu\n", atkbd->err_count);
1531 }
1532
1533 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1534 {
1535         atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1536         atkbd_platform_fixup_data = id->driver_data;
1537
1538         return 0;
1539 }
1540
1541 static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
1542         {
1543                 .ident = "Dell Laptop",
1544                 .matches = {
1545                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1546                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1547                 },
1548                 .callback = atkbd_setup_forced_release,
1549                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1550         },
1551         {
1552                 .ident = "Dell Laptop",
1553                 .matches = {
1554                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1555                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1556                 },
1557                 .callback = atkbd_setup_forced_release,
1558                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1559         },
1560         {
1561                 .ident = "HP 2133",
1562                 .matches = {
1563                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1564                         DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1565                 },
1566                 .callback = atkbd_setup_forced_release,
1567                 .driver_data = atkbd_hp_forced_release_keys,
1568         },
1569         {
1570                 .ident = "HP Pavilion ZV6100",
1571                 .matches = {
1572                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1573                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1574                 },
1575                 .callback = atkbd_setup_forced_release,
1576                 .driver_data = atkbd_hp_zv6100_forced_release_keys,
1577         },
1578         {
1579                 .ident = "HP Presario R4000",
1580                 .matches = {
1581                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1582                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1583                 },
1584                 .callback = atkbd_setup_forced_release,
1585                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1586         },
1587         {
1588                 .ident = "HP Presario R4100",
1589                 .matches = {
1590                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1591                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1592                 },
1593                 .callback = atkbd_setup_forced_release,
1594                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1595         },
1596         {
1597                 .ident = "HP Presario R4200",
1598                 .matches = {
1599                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1600                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1601                 },
1602                 .callback = atkbd_setup_forced_release,
1603                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1604         },
1605         {
1606                 .ident = "Inventec Symphony",
1607                 .matches = {
1608                         DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1609                         DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1610                 },
1611                 .callback = atkbd_setup_forced_release,
1612                 .driver_data = atkbd_inventec_forced_release_keys,
1613         },
1614         {
1615                 .ident = "Samsung NC10",
1616                 .matches = {
1617                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1618                         DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1619                 },
1620                 .callback = atkbd_setup_forced_release,
1621                 .driver_data = atkbd_samsung_forced_release_keys,
1622         },
1623         {
1624                 .ident = "Samsung NC20",
1625                 .matches = {
1626                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1627                         DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1628                 },
1629                 .callback = atkbd_setup_forced_release,
1630                 .driver_data = atkbd_samsung_forced_release_keys,
1631         },
1632         {
1633                 .ident = "Samsung SQ45S70S",
1634                 .matches = {
1635                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1636                         DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1637                 },
1638                 .callback = atkbd_setup_forced_release,
1639                 .driver_data = atkbd_samsung_forced_release_keys,
1640         },
1641         {
1642                 .ident = "Fujitsu Amilo PA 1510",
1643                 .matches = {
1644                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1645                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1646                 },
1647                 .callback = atkbd_setup_forced_release,
1648                 .driver_data = atkbd_amilo_pa1510_forced_release_keys,
1649         },
1650         {
1651                 .ident = "Fujitsu Amilo Pi 3525",
1652                 .matches = {
1653                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1654                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1655                 },
1656                 .callback = atkbd_setup_forced_release,
1657                 .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1658         },
1659         {
1660                 .ident = "Fujitsu Amilo Xi 3650",
1661                 .matches = {
1662                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1663                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1664                 },
1665                 .callback = atkbd_setup_forced_release,
1666                 .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1667         },
1668         {
1669                 .ident = "Soltech Corporation TA12",
1670                 .matches = {
1671                         DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1672                         DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1673                 },
1674                 .callback = atkbd_setup_forced_release,
1675                 .driver_data = atkdb_soltech_ta12_forced_release_keys,
1676         },
1677         { }
1678 };
1679
1680 static int __init atkbd_init(void)
1681 {
1682         dmi_check_system(atkbd_dmi_quirk_table);
1683
1684         return serio_register_driver(&atkbd_drv);
1685 }
1686
1687 static void __exit atkbd_exit(void)
1688 {
1689         serio_unregister_driver(&atkbd_drv);
1690 }
1691
1692 module_init(atkbd_init);
1693 module_exit(atkbd_exit);