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