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