drivers/input/keyboard/atkbd.c

   1 /*
   2  * AT and PS/2 keyboard driver
   3  *
   4  * Copyright (c) 1999-2002 Vojtech Pavlik
   5  */
   6
   7 /*
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 as published by
  10  * the Free Software Foundation.
  11  */
  12
  13 /*
  14  * This driver can handle standard AT keyboards and PS/2 keyboards in
  15  * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
  16  * input-only controllers and AT keyboards connected over a one way RS232
  17  * converter.
  18  */
  19
  20 #include <linux/delay.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/init.h>
  25 #include <linux/input.h>
  26 #include <linux/serio.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/libps2.h>
  29 #include <linux/mutex.h>
  30 #include <linux/dmi.h>
  31
  32 #define DRIVER_DESC     "AT and PS/2 keyboard driver"
  33
  34 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  35 MODULE_DESCRIPTION(DRIVER_DESC);
  36 MODULE_LICENSE("GPL");
  37
  38 static int atkbd_set = 2;
  39 module_param_named(set, atkbd_set, int, 0);
  40 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
  41
  42 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
  43 static int atkbd_reset;
  44 #else
  45 static int atkbd_reset = 1;
  46 #endif
  47 module_param_named(reset, atkbd_reset, bool, 0);
  48 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
  49
  50 static int atkbd_softrepeat;
  51 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
  52 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
  53
  54 static int atkbd_softraw = 1;
  55 module_param_named(softraw, atkbd_softraw, bool, 0);
  56 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
  57
  58 static int atkbd_scroll;
  59 module_param_named(scroll, atkbd_scroll, bool, 0);
  60 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
  61
  62 static int atkbd_extra;
  63 module_param_named(extra, atkbd_extra, bool, 0);
  64 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
  65
  66 /*
  67  * Scancode to keycode tables. These are just the default setting, and
  68  * are loadable via a userland utility.
  69  */
  70
  71 #define ATKBD_KEYMAP_SIZE       512
  72
  73 static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
  74
  75 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
  76
  77 /* XXX: need a more general approach */
  78
  79 #include "hpps2atkbd.h" /* include the keyboard scancodes */
  80
  81 #else
  82           0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
  83           0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
  84           0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
  85           0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
  86           0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
  87           0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
  88           0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
  89          82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
  90
  91           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  92         217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
  93         173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
  94         159,  0,115,  0,164,  0,  0,116,158,  0,172,166,  0,  0,  0,142,
  95         157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
  96         226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
  97           0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
  98         110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
  99
 100           0,  0,  0, 65, 99,
 101 #endif
 102 };
 103
 104 static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
 105
 106           0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
 107         131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
 108         134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
 109         136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
 110         125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
 111         113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
 112         108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
 113          82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,
 114
 115         184,185,186,187, 74, 94, 92, 93,  0,  0,  0,125,126,127,112,  0,
 116           0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
 117         148,149,147,140
 118 };
 119
 120 static const unsigned short atkbd_unxlate_table[128] = {
 121           0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
 122          21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
 123          35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
 124          50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
 125          11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
 126         114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
 127          71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
 128          19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
 129 };
 130
 131 #define ATKBD_CMD_SETLEDS       0x10ed
 132 #define ATKBD_CMD_GSCANSET      0x11f0
 133 #define ATKBD_CMD_SSCANSET      0x10f0
 134 #define ATKBD_CMD_GETID         0x02f2
 135 #define ATKBD_CMD_SETREP        0x10f3
 136 #define ATKBD_CMD_ENABLE        0x00f4
 137 #define ATKBD_CMD_RESET_DIS     0x00f5
 138 #define ATKBD_CMD_SETALL_MBR    0x00fa
 139 #define ATKBD_CMD_RESET_BAT     0x02ff
 140 #define ATKBD_CMD_RESEND        0x00fe
 141 #define ATKBD_CMD_EX_ENABLE     0x10ea
 142 #define ATKBD_CMD_EX_SETLEDS    0x20eb
 143 #define ATKBD_CMD_OK_GETID      0x02e8
 144
 145 #define ATKBD_RET_ACK           0xfa
 146 #define ATKBD_RET_NAK           0xfe
 147 #define ATKBD_RET_BAT           0xaa
 148 #define ATKBD_RET_EMUL0         0xe0
 149 #define ATKBD_RET_EMUL1         0xe1
 150 #define ATKBD_RET_RELEASE       0xf0
 151 #define ATKBD_RET_HANJA         0xf1
 152 #define ATKBD_RET_HANGEUL       0xf2
 153 #define ATKBD_RET_ERR           0xff
 154
 155 #define ATKBD_KEY_UNKNOWN         0
 156 #define ATKBD_KEY_NULL          255
 157
 158 #define ATKBD_SCR_1             254
 159 #define ATKBD_SCR_2             253
 160 #define ATKBD_SCR_4             252
 161 #define ATKBD_SCR_8             251
 162 #define ATKBD_SCR_CLICK         250
 163 #define ATKBD_SCR_LEFT          249
 164 #define ATKBD_SCR_RIGHT         248
 165
 166 #define ATKBD_SPECIAL           ATKBD_SCR_RIGHT
 167
 168 #define ATKBD_LED_EVENT_BIT     0
 169 #define ATKBD_REP_EVENT_BIT     1
 170
 171 #define ATKBD_XL_ERR            0x01
 172 #define ATKBD_XL_BAT            0x02
 173 #define ATKBD_XL_ACK            0x04
 174 #define ATKBD_XL_NAK            0x08
 175 #define ATKBD_XL_HANGEUL        0x10
 176 #define ATKBD_XL_HANJA          0x20
 177
 178 static const struct {
 179         unsigned char keycode;
 180         unsigned char set2;
 181 } atkbd_scroll_keys[] = {
 182         { ATKBD_SCR_1,     0xc5 },
 183         { ATKBD_SCR_2,     0x9d },
 184         { ATKBD_SCR_4,     0xa4 },
 185         { ATKBD_SCR_8,     0x9b },
 186         { ATKBD_SCR_CLICK, 0xe0 },
 187         { ATKBD_SCR_LEFT,  0xcb },
 188         { ATKBD_SCR_RIGHT, 0xd2 },
 189 };
 190
 191 /*
 192  * The atkbd control structure
 193  */
 194
 195 struct atkbd {
 196
 197         struct ps2dev ps2dev;
 198         struct input_dev *dev;
 199
 200         /* Written only during init */
 201         char name[64];
 202         char phys[32];
 203
 204         unsigned short id;
 205         unsigned short keycode[ATKBD_KEYMAP_SIZE];
 206         DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
 207         unsigned char set;
 208         unsigned char translated;
 209         unsigned char extra;
 210         unsigned char write;
 211         unsigned char softrepeat;
 212         unsigned char softraw;
 213         unsigned char scroll;
 214         unsigned char enabled;
 215
 216         /* Accessed only from interrupt */
 217         unsigned char emul;
 218         unsigned char resend;
 219         unsigned char release;
 220         unsigned long xl_bit;
 221         unsigned int last;
 222         unsigned long time;
 223         unsigned long err_count;
 224
 225         struct delayed_work event_work;
 226         unsigned long event_jiffies;
 227         struct mutex event_mutex;
 228         unsigned long event_mask;
 229 };
 230
 231 /*
 232  * System-specific keymap fixup routine
 233  */
 234 static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
 235 static void *atkbd_platform_fixup_data;
 236
 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
 777 /*
 778  * Enable the keyboard to receive keystrokes.
 779  */
 780
 781         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 782                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
 783                         ps2dev->serio->phys);
 784                 return -1;
 785         }
 786
 787         return 0;
 788 }
 789
 790 /*
 791  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 792  * reboot.
 793  */
 794
 795 static void atkbd_cleanup(struct serio *serio)
 796 {
 797         struct atkbd *atkbd = serio_get_drvdata(serio);
 798
 799         atkbd_disable(atkbd);
 800         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
 801 }
 802
 803
 804 /*
 805  * atkbd_disconnect() closes and frees.
 806  */
 807
 808 static void atkbd_disconnect(struct serio *serio)
 809 {
 810         struct atkbd *atkbd = serio_get_drvdata(serio);
 811
 812         atkbd_disable(atkbd);
 813
 814         /* make sure we don't have a command in flight */
 815         cancel_delayed_work_sync(&atkbd->event_work);
 816
 817         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 818         input_unregister_device(atkbd->dev);
 819         serio_close(serio);
 820         serio_set_drvdata(serio, NULL);
 821         kfree(atkbd);
 822 }
 823
 824 /*
 825  * generate release events for the keycodes given in data
 826  */
 827 static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
 828                                                 const void *data)
 829 {
 830         const unsigned int *keys = data;
 831         unsigned int i;
 832
 833         if (atkbd->set == 2)
 834                 for (i = 0; keys[i] != -1U; i++)
 835                         __set_bit(keys[i], atkbd->force_release_mask);
 836 }
 837
 838 /*
 839  * Most special keys (Fn+F?) on Dell laptops do not generate release
 840  * events so we have to do it ourselves.
 841  */
 842 static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
 843         0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
 844 };
 845
 846 /*
 847  * Perform fixup for HP system that doesn't generate release
 848  * for its video switch
 849  */
 850 static unsigned int atkbd_hp_forced_release_keys[] = {
 851         0x94, -1U
 852 };
 853
 854 /*
 855  * Inventec system with broken key release on volume keys
 856  */
 857 static unsigned int atkbd_inventec_forced_release_keys[] = {
 858         0xae, 0xb0, -1U
 859 };
 860
 861 /*
 862  * Perform fixup for HP Pavilion ZV6100 laptop that doesn't generate release
 863  * for its volume buttons
 864  */
 865 static unsigned int atkbd_hp_zv6100_forced_release_keys[] = {
 866         0xae, 0xb0, -1U
 867 };
 868
 869 /*
 870  * Perform fixup for HP (Compaq) Presario R4000 R4100 R4200 that don't generate
 871  * release for their volume buttons
 872  */
 873 static unsigned int atkbd_hp_r4000_forced_release_keys[] = {
 874         0xae, 0xb0, -1U
 875 };
 876
 877 /*
 878  * Samsung NC10,NC20 with Fn+F? key release not working
 879  */
 880 static unsigned int atkbd_samsung_forced_release_keys[] = {
 881         0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
 882 };
 883
 884 /*
 885  * The volume up and volume down special keys on a Fujitsu Amilo PA 1510 laptop
 886  * do not generate release events so we have to do it ourselves.
 887  */
 888 static unsigned int atkbd_amilo_pa1510_forced_release_keys[] = {
 889         0xb0, 0xae, -1U
 890 };
 891
 892 /*
 893  * Amilo Pi 3525 key release for Fn+Volume keys not working
 894  */
 895 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
 896         0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
 897 };
 898
 899 /*
 900  * Amilo Xi 3650 key release for light touch bar not working
 901  */
 902 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
 903         0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
 904 };
 905
 906 /*
 907  * Soltech TA12 system with broken key release on volume keys and mute key
 908  */
 909 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
 910         0xa0, 0xae, 0xb0, -1U
 911 };
 912
 913 /*
 914  * atkbd_set_keycode_table() initializes keyboard's keycode table
 915  * according to the selected scancode set
 916  */
 917
 918 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 919 {
 920         unsigned int scancode;
 921         int i, j;
 922
 923         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 924         bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
 925
 926         if (atkbd->translated) {
 927                 for (i = 0; i < 128; i++) {
 928                         scancode = atkbd_unxlate_table[i];
 929                         atkbd->keycode[i] = atkbd_set2_keycode[scancode];
 930                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
 931                         if (atkbd->scroll)
 932                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 933                                         if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
 934                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 935                 }
 936         } else if (atkbd->set == 3) {
 937                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 938         } else {
 939                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 940
 941                 if (atkbd->scroll)
 942                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
 943                                 scancode = atkbd_scroll_keys[i].set2;
 944                                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
 945                 }
 946         }
 947
 948 /*
 949  * HANGEUL and HANJA keys do not send release events so we need to
 950  * generate such events ourselves
 951  */
 952         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
 953         atkbd->keycode[scancode] = KEY_HANGEUL;
 954         __set_bit(scancode, atkbd->force_release_mask);
 955
 956         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
 957         atkbd->keycode[scancode] = KEY_HANJA;
 958         __set_bit(scancode, atkbd->force_release_mask);
 959
 960 /*
 961  * Perform additional fixups
 962  */
 963         if (atkbd_platform_fixup)
 964                 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
 965 }
 966
 967 /*
 968  * atkbd_set_device_attrs() sets up keyboard's input device structure
 969  */
 970
 971 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 972 {
 973         struct input_dev *input_dev = atkbd->dev;
 974         int i;
 975
 976         if (atkbd->extra)
 977                 snprintf(atkbd->name, sizeof(atkbd->name),
 978                          "AT Set 2 Extra keyboard");
 979         else
 980                 snprintf(atkbd->name, sizeof(atkbd->name),
 981                          "AT %s Set %d keyboard",
 982                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
 983
 984         snprintf(atkbd->phys, sizeof(atkbd->phys),
 985                  "%s/input0", atkbd->ps2dev.serio->phys);
 986
 987         input_dev->name = atkbd->name;
 988         input_dev->phys = atkbd->phys;
 989         input_dev->id.bustype = BUS_I8042;
 990         input_dev->id.vendor = 0x0001;
 991         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
 992         input_dev->id.version = atkbd->id;
 993         input_dev->event = atkbd_event;
 994         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
 995
 996         input_set_drvdata(input_dev, atkbd);
 997
 998         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
 999                 BIT_MASK(EV_MSC);
1000
1001         if (atkbd->write) {
1002                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1003                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1004                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1005         }
1006
1007         if (atkbd->extra)
1008                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1009                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1010                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1011
1012         if (!atkbd->softrepeat) {
1013                 input_dev->rep[REP_DELAY] = 250;
1014                 input_dev->rep[REP_PERIOD] = 33;
1015         }
1016
1017         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1018                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1019
1020         if (atkbd->scroll) {
1021                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1022                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1023                         BIT_MASK(REL_HWHEEL);
1024                 __set_bit(BTN_MIDDLE, input_dev->keybit);
1025         }
1026
1027         input_dev->keycode = atkbd->keycode;
1028         input_dev->keycodesize = sizeof(unsigned short);
1029         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1030
1031         for (i = 0; i < ATKBD_KEYMAP_SIZE; i++)
1032                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
1033                         __set_bit(atkbd->keycode[i], input_dev->keybit);
1034 }
1035
1036 /*
1037  * atkbd_connect() is called when the serio module finds an interface
1038  * that isn't handled yet by an appropriate device driver. We check if
1039  * there is an AT keyboard out there and if yes, we register ourselves
1040  * to the input module.
1041  */
1042
1043 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1044 {
1045         struct atkbd *atkbd;
1046         struct input_dev *dev;
1047         int err = -ENOMEM;
1048
1049         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1050         dev = input_allocate_device();
1051         if (!atkbd || !dev)
1052                 goto fail1;
1053
1054         atkbd->dev = dev;
1055         ps2_init(&atkbd->ps2dev, serio);
1056         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1057         mutex_init(&atkbd->event_mutex);
1058
1059         switch (serio->id.type) {
1060
1061                 case SERIO_8042_XL:
1062                         atkbd->translated = 1;
1063                 case SERIO_8042:
1064                         if (serio->write)
1065                                 atkbd->write = 1;
1066                         break;
1067         }
1068
1069         atkbd->softraw = atkbd_softraw;
1070         atkbd->softrepeat = atkbd_softrepeat;
1071         atkbd->scroll = atkbd_scroll;
1072
1073         if (atkbd->softrepeat)
1074                 atkbd->softraw = 1;
1075
1076         serio_set_drvdata(serio, atkbd);
1077
1078         err = serio_open(serio, drv);
1079         if (err)
1080                 goto fail2;
1081
1082         if (atkbd->write) {
1083
1084                 if (atkbd_probe(atkbd)) {
1085                         err = -ENODEV;
1086                         goto fail3;
1087                 }
1088
1089                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1090                 atkbd_activate(atkbd);
1091
1092         } else {
1093                 atkbd->set = 2;
1094                 atkbd->id = 0xab00;
1095         }
1096
1097         atkbd_set_keycode_table(atkbd);
1098         atkbd_set_device_attrs(atkbd);
1099
1100         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1101         if (err)
1102                 goto fail3;
1103
1104         atkbd_enable(atkbd);
1105
1106         err = input_register_device(atkbd->dev);
1107         if (err)
1108                 goto fail4;
1109
1110         return 0;
1111
1112  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1113  fail3: serio_close(serio);
1114  fail2: serio_set_drvdata(serio, NULL);
1115  fail1: input_free_device(dev);
1116         kfree(atkbd);
1117         return err;
1118 }
1119
1120 /*
1121  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1122  * most likely called on resume.
1123  */
1124
1125 static int atkbd_reconnect(struct serio *serio)
1126 {
1127         struct atkbd *atkbd = serio_get_drvdata(serio);
1128         struct serio_driver *drv = serio->drv;
1129
1130         if (!atkbd || !drv) {
1131                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1132                 return -1;
1133         }
1134
1135         atkbd_disable(atkbd);
1136
1137         if (atkbd->write) {
1138                 if (atkbd_probe(atkbd))
1139                         return -1;
1140                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1141                         return -1;
1142
1143                 atkbd_activate(atkbd);
1144         }
1145
1146         atkbd_enable(atkbd);
1147
1148         return 0;
1149 }
1150
1151 static struct serio_device_id atkbd_serio_ids[] = {
1152         {
1153                 .type   = SERIO_8042,
1154                 .proto  = SERIO_ANY,
1155                 .id     = SERIO_ANY,
1156                 .extra  = SERIO_ANY,
1157         },
1158         {
1159                 .type   = SERIO_8042_XL,
1160                 .proto  = SERIO_ANY,
1161                 .id     = SERIO_ANY,
1162                 .extra  = SERIO_ANY,
1163         },
1164         {
1165                 .type   = SERIO_RS232,
1166                 .proto  = SERIO_PS2SER,
1167                 .id     = SERIO_ANY,
1168                 .extra  = SERIO_ANY,
1169         },
1170         { 0 }
1171 };
1172
1173 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1174
1175 static struct serio_driver atkbd_drv = {
1176         .driver         = {
1177                 .name   = "atkbd",
1178         },
1179         .description    = DRIVER_DESC,
1180         .id_table       = atkbd_serio_ids,
1181         .interrupt      = atkbd_interrupt,
1182         .connect        = atkbd_connect,
1183         .reconnect      = atkbd_reconnect,
1184         .disconnect     = atkbd_disconnect,
1185         .cleanup        = atkbd_cleanup,
1186 };
1187
1188 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1189                                 ssize_t (*handler)(struct atkbd *, char *))
1190 {
1191         struct serio *serio = to_serio_port(dev);
1192         int retval;
1193
1194         retval = serio_pin_driver(serio);
1195         if (retval)
1196                 return retval;
1197
1198         if (serio->drv != &atkbd_drv) {
1199                 retval = -ENODEV;
1200                 goto out;
1201         }
1202
1203         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1204
1205 out:
1206         serio_unpin_driver(serio);
1207         return retval;
1208 }
1209
1210 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1211                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1212 {
1213         struct serio *serio = to_serio_port(dev);
1214         struct atkbd *atkbd;
1215         int retval;
1216
1217         retval = serio_pin_driver(serio);
1218         if (retval)
1219                 return retval;
1220
1221         if (serio->drv != &atkbd_drv) {
1222                 retval = -ENODEV;
1223                 goto out;
1224         }
1225
1226         atkbd = serio_get_drvdata(serio);
1227         atkbd_disable(atkbd);
1228         retval = handler(atkbd, buf, count);
1229         atkbd_enable(atkbd);
1230
1231 out:
1232         serio_unpin_driver(serio);
1233         return retval;
1234 }
1235
1236 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1237 {
1238         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1239 }
1240
1241 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1242 {
1243         struct input_dev *old_dev, *new_dev;
1244         unsigned long value;
1245         int err;
1246         unsigned char old_extra, old_set;
1247
1248         if (!atkbd->write)
1249                 return -EIO;
1250
1251         if (strict_strtoul(buf, 10, &value) || value > 1)
1252                 return -EINVAL;
1253
1254         if (atkbd->extra != value) {
1255                 /*
1256                  * Since device's properties will change we need to
1257                  * unregister old device. But allocate and register
1258                  * new one first to make sure we have it.
1259                  */
1260                 old_dev = atkbd->dev;
1261                 old_extra = atkbd->extra;
1262                 old_set = atkbd->set;
1263
1264                 new_dev = input_allocate_device();
1265                 if (!new_dev)
1266                         return -ENOMEM;
1267
1268                 atkbd->dev = new_dev;
1269                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1270                 atkbd_activate(atkbd);
1271                 atkbd_set_keycode_table(atkbd);
1272                 atkbd_set_device_attrs(atkbd);
1273
1274                 err = input_register_device(atkbd->dev);
1275                 if (err) {
1276                         input_free_device(new_dev);
1277
1278                         atkbd->dev = old_dev;
1279                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1280                         atkbd_set_keycode_table(atkbd);
1281                         atkbd_set_device_attrs(atkbd);
1282
1283                         return err;
1284                 }
1285                 input_unregister_device(old_dev);
1286
1287         }
1288         return count;
1289 }
1290
1291 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1292 {
1293         size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1294                         atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1295
1296         buf[len++] = '\n';
1297         buf[len] = '\0';
1298
1299         return len;
1300 }
1301
1302 static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1303                                         const char *buf, size_t count)
1304 {
1305         /* 64 bytes on stack should be acceptable */
1306         DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1307         int err;
1308
1309         err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1310         if (err)
1311                 return err;
1312
1313         memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1314         return count;
1315 }
1316
1317
1318 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1319 {
1320         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1321 }
1322
1323 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1324 {
1325         struct input_dev *old_dev, *new_dev;
1326         unsigned long value;
1327         int err;
1328         unsigned char old_scroll;
1329
1330         if (strict_strtoul(buf, 10, &value) || value > 1)
1331                 return -EINVAL;
1332
1333         if (atkbd->scroll != value) {
1334                 old_dev = atkbd->dev;
1335                 old_scroll = atkbd->scroll;
1336
1337                 new_dev = input_allocate_device();
1338                 if (!new_dev)
1339                         return -ENOMEM;
1340
1341                 atkbd->dev = new_dev;
1342                 atkbd->scroll = value;
1343                 atkbd_set_keycode_table(atkbd);
1344                 atkbd_set_device_attrs(atkbd);
1345
1346                 err = input_register_device(atkbd->dev);
1347                 if (err) {
1348                         input_free_device(new_dev);
1349
1350                         atkbd->scroll = old_scroll;
1351                         atkbd->dev = old_dev;
1352                         atkbd_set_keycode_table(atkbd);
1353                         atkbd_set_device_attrs(atkbd);
1354
1355                         return err;
1356                 }
1357                 input_unregister_device(old_dev);
1358         }
1359         return count;
1360 }
1361
1362 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1363 {
1364         return sprintf(buf, "%d\n", atkbd->set);
1365 }
1366
1367 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1368 {
1369         struct input_dev *old_dev, *new_dev;
1370         unsigned long value;
1371         int err;
1372         unsigned char old_set, old_extra;
1373
1374         if (!atkbd->write)
1375                 return -EIO;
1376
1377         if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1378                 return -EINVAL;
1379
1380         if (atkbd->set != value) {
1381                 old_dev = atkbd->dev;
1382                 old_extra = atkbd->extra;
1383                 old_set = atkbd->set;
1384
1385                 new_dev = input_allocate_device();
1386                 if (!new_dev)
1387                         return -ENOMEM;
1388
1389                 atkbd->dev = new_dev;
1390                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1391                 atkbd_activate(atkbd);
1392                 atkbd_set_keycode_table(atkbd);
1393                 atkbd_set_device_attrs(atkbd);
1394
1395                 err = input_register_device(atkbd->dev);
1396                 if (err) {
1397                         input_free_device(new_dev);
1398
1399                         atkbd->dev = old_dev;
1400                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1401                         atkbd_set_keycode_table(atkbd);
1402                         atkbd_set_device_attrs(atkbd);
1403
1404                         return err;
1405                 }
1406                 input_unregister_device(old_dev);
1407         }
1408         return count;
1409 }
1410
1411 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1412 {
1413         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1414 }
1415
1416 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1417 {
1418         struct input_dev *old_dev, *new_dev;
1419         unsigned long value;
1420         int err;
1421         unsigned char old_softrepeat, old_softraw;
1422
1423         if (!atkbd->write)
1424                 return -EIO;
1425
1426         if (strict_strtoul(buf, 10, &value) || value > 1)
1427                 return -EINVAL;
1428
1429         if (atkbd->softrepeat != value) {
1430                 old_dev = atkbd->dev;
1431                 old_softrepeat = atkbd->softrepeat;
1432                 old_softraw = atkbd->softraw;
1433
1434                 new_dev = input_allocate_device();
1435                 if (!new_dev)
1436                         return -ENOMEM;
1437
1438                 atkbd->dev = new_dev;
1439                 atkbd->softrepeat = value;
1440                 if (atkbd->softrepeat)
1441                         atkbd->softraw = 1;
1442                 atkbd_set_device_attrs(atkbd);
1443
1444                 err = input_register_device(atkbd->dev);
1445                 if (err) {
1446                         input_free_device(new_dev);
1447
1448                         atkbd->dev = old_dev;
1449                         atkbd->softrepeat = old_softrepeat;
1450                         atkbd->softraw = old_softraw;
1451                         atkbd_set_device_attrs(atkbd);
1452
1453                         return err;
1454                 }
1455                 input_unregister_device(old_dev);
1456         }
1457         return count;
1458 }
1459
1460
1461 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1462 {
1463         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1464 }
1465
1466 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1467 {
1468         struct input_dev *old_dev, *new_dev;
1469         unsigned long value;
1470         int err;
1471         unsigned char old_softraw;
1472
1473         if (strict_strtoul(buf, 10, &value) || value > 1)
1474                 return -EINVAL;
1475
1476         if (atkbd->softraw != value) {
1477                 old_dev = atkbd->dev;
1478                 old_softraw = atkbd->softraw;
1479
1480                 new_dev = input_allocate_device();
1481                 if (!new_dev)
1482                         return -ENOMEM;
1483
1484                 atkbd->dev = new_dev;
1485                 atkbd->softraw = value;
1486                 atkbd_set_device_attrs(atkbd);
1487
1488                 err = input_register_device(atkbd->dev);
1489                 if (err) {
1490                         input_free_device(new_dev);
1491
1492                         atkbd->dev = old_dev;
1493                         atkbd->softraw = old_softraw;
1494                         atkbd_set_device_attrs(atkbd);
1495
1496                         return err;
1497                 }
1498                 input_unregister_device(old_dev);
1499         }
1500         return count;
1501 }
1502
1503 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1504 {
1505         return sprintf(buf, "%lu\n", atkbd->err_count);
1506 }
1507
1508 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1509 {
1510         atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1511         atkbd_platform_fixup_data = id->driver_data;
1512
1513         return 0;
1514 }
1515
1516 static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
1517         {
1518                 .ident = "Dell Laptop",
1519                 .matches = {
1520                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1521                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1522                 },
1523                 .callback = atkbd_setup_forced_release,
1524                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1525         },
1526         {
1527                 .ident = "Dell Laptop",
1528                 .matches = {
1529                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1530                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1531                 },
1532                 .callback = atkbd_setup_forced_release,
1533                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1534         },
1535         {
1536                 .ident = "HP 2133",
1537                 .matches = {
1538                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1539                         DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1540                 },
1541                 .callback = atkbd_setup_forced_release,
1542                 .driver_data = atkbd_hp_forced_release_keys,
1543         },
1544         {
1545                 .ident = "HP Pavilion ZV6100",
1546                 .matches = {
1547                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1548                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1549                 },
1550                 .callback = atkbd_setup_forced_release,
1551                 .driver_data = atkbd_hp_zv6100_forced_release_keys,
1552         },
1553         {
1554                 .ident = "HP Presario R4000",
1555                 .matches = {
1556                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1557                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1558                 },
1559                 .callback = atkbd_setup_forced_release,
1560                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1561         },
1562         {
1563                 .ident = "HP Presario R4100",
1564                 .matches = {
1565                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1566                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1567                 },
1568                 .callback = atkbd_setup_forced_release,
1569                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1570         },
1571         {
1572                 .ident = "HP Presario R4200",
1573                 .matches = {
1574                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1575                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1576                 },
1577                 .callback = atkbd_setup_forced_release,
1578                 .driver_data = atkbd_hp_r4000_forced_release_keys,
1579         },
1580         {
1581                 .ident = "Inventec Symphony",
1582                 .matches = {
1583                         DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1584                         DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1585                 },
1586                 .callback = atkbd_setup_forced_release,
1587                 .driver_data = atkbd_inventec_forced_release_keys,
1588         },
1589         {
1590                 .ident = "Samsung NC10",
1591                 .matches = {
1592                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1593                         DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1594                 },
1595                 .callback = atkbd_setup_forced_release,
1596                 .driver_data = atkbd_samsung_forced_release_keys,
1597         },
1598         {
1599                 .ident = "Samsung NC20",
1600                 .matches = {
1601                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1602                         DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1603                 },
1604                 .callback = atkbd_setup_forced_release,
1605                 .driver_data = atkbd_samsung_forced_release_keys,
1606         },
1607         {
1608                 .ident = "Samsung SQ45S70S",
1609                 .matches = {
1610                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1611                         DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1612                 },
1613                 .callback = atkbd_setup_forced_release,
1614                 .driver_data = atkbd_samsung_forced_release_keys,
1615         },
1616         {
1617                 .ident = "Fujitsu Amilo PA 1510",
1618                 .matches = {
1619                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1620                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1621                 },
1622                 .callback = atkbd_setup_forced_release,
1623                 .driver_data = atkbd_amilo_pa1510_forced_release_keys,
1624         },
1625         {
1626                 .ident = "Fujitsu Amilo Pi 3525",
1627                 .matches = {
1628                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1629                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1630                 },
1631                 .callback = atkbd_setup_forced_release,
1632                 .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1633         },
1634         {
1635                 .ident = "Fujitsu Amilo Xi 3650",
1636                 .matches = {
1637                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1638                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1639                 },
1640                 .callback = atkbd_setup_forced_release,
1641                 .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1642         },
1643         {
1644                 .ident = "Soltech Corporation TA12",
1645                 .matches = {
1646                         DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1647                         DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1648                 },
1649                 .callback = atkbd_setup_forced_release,
1650                 .driver_data = atkdb_soltech_ta12_forced_release_keys,
1651         },
1652         { }
1653 };
1654
1655 static int __init atkbd_init(void)
1656 {
1657         dmi_check_system(atkbd_dmi_quirk_table);
1658
1659         return serio_register_driver(&atkbd_drv);
1660 }
1661
1662 static void __exit atkbd_exit(void)
1663 {
1664         serio_unregister_driver(&atkbd_drv);
1665 }
1666
1667 module_init(atkbd_init);
1668 module_exit(atkbd_exit);