git.oblomov.eu Git - linux-2.6/blob - drivers/input/keyboard/atkbd.c

   1 /*
   2  * AT and PS/2 keyboard driver
   3  *
   4  * Copyright (c) 1999-2002 Vojtech Pavlik
   5  */
   6
   7 /*
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 as published by
  10  * the Free Software Foundation.
  11  */
  12
  13 /*
  14  * This driver can handle standard AT keyboards and PS/2 keyboards in
  15  * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
  16  * input-only controllers and AT keyboards connected over a one way RS232
  17  * converter.
  18  */
  19
  20 #include <linux/delay.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/init.h>
  25 #include <linux/input.h>
  26 #include <linux/serio.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/libps2.h>
  29 #include <linux/mutex.h>
  30 #include <linux/dmi.h>
  31
  32 #define DRIVER_DESC     "AT and PS/2 keyboard driver"
  33
  34 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  35 MODULE_DESCRIPTION(DRIVER_DESC);
  36 MODULE_LICENSE("GPL");
  37
  38 static int atkbd_set = 2;
  39 module_param_named(set, atkbd_set, int, 0);
  40 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
  41
  42 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
  43 static int atkbd_reset;
  44 #else
  45 static int atkbd_reset = 1;
  46 #endif
  47 module_param_named(reset, atkbd_reset, bool, 0);
  48 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
  49
  50 static int atkbd_softrepeat;
  51 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
  52 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
  53
  54 static int atkbd_softraw = 1;
  55 module_param_named(softraw, atkbd_softraw, bool, 0);
  56 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
  57
  58 static int atkbd_scroll;
  59 module_param_named(scroll, atkbd_scroll, bool, 0);
  60 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
  61
  62 static int atkbd_extra;
  63 module_param_named(extra, atkbd_extra, bool, 0);
  64 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
  65
  66 /*
  67  * Scancode to keycode tables. These are just the default setting, and
  68  * are loadable via a userland utility.
  69  */
  70
  71 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 Pi 3525 key release for Fn+Volume keys not working
 899  */
 900 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
 901         0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
 902 };
 903
 904 /*
 905  * Amilo Xi 3650 key release for light touch bar not working
 906  */
 907 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
 908         0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
 909 };
 910
 911 /*
 912  * atkbd_set_keycode_table() initializes keyboard's keycode table
 913  * according to the selected scancode set
 914  */
 915
 916 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 917 {
 918         unsigned int scancode;
 919         int i, j;
 920
 921         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 922         bitmap_zero(atkbd->force_release_mask, 512);
 923
 924         if (atkbd->translated) {
 925                 for (i = 0; i < 128; i++) {
 926                         scancode = atkbd_unxlate_table[i];
 927                         atkbd->keycode[i] = atkbd_set2_keycode[scancode];
 928                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
 929                         if (atkbd->scroll)
 930                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 931                                         if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
 932                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 933                 }
 934         } else if (atkbd->set == 3) {
 935                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 936         } else {
 937                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 938
 939                 if (atkbd->scroll)
 940                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
 941                                 scancode = atkbd_scroll_keys[i].set2;
 942                                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
 943                 }
 944         }
 945
 946 /*
 947  * HANGEUL and HANJA keys do not send release events so we need to
 948  * generate such events ourselves
 949  */
 950         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
 951         atkbd->keycode[scancode] = KEY_HANGEUL;
 952         __set_bit(scancode, atkbd->force_release_mask);
 953
 954         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
 955         atkbd->keycode[scancode] = KEY_HANJA;
 956         __set_bit(scancode, atkbd->force_release_mask);
 957
 958 /*
 959  * Perform additional fixups
 960  */
 961         if (atkbd_platform_fixup)
 962                 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
 963 }
 964
 965 /*
 966  * atkbd_set_device_attrs() sets up keyboard's input device structure
 967  */
 968
 969 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 970 {
 971         struct input_dev *input_dev = atkbd->dev;
 972         int i;
 973
 974         if (atkbd->extra)
 975                 snprintf(atkbd->name, sizeof(atkbd->name),
 976                          "AT Set 2 Extra keyboard");
 977         else
 978                 snprintf(atkbd->name, sizeof(atkbd->name),
 979                          "AT %s Set %d keyboard",
 980                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
 981
 982         snprintf(atkbd->phys, sizeof(atkbd->phys),
 983                  "%s/input0", atkbd->ps2dev.serio->phys);
 984
 985         input_dev->name = atkbd->name;
 986         input_dev->phys = atkbd->phys;
 987         input_dev->id.bustype = BUS_I8042;
 988         input_dev->id.vendor = 0x0001;
 989         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
 990         input_dev->id.version = atkbd->id;
 991         input_dev->event = atkbd_event;
 992         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
 993
 994         input_set_drvdata(input_dev, atkbd);
 995
 996         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
 997                 BIT_MASK(EV_MSC);
 998
 999         if (atkbd->write) {
1000                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1001                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1002                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1003         }
1004
1005         if (atkbd->extra)
1006                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1007                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1008                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1009
1010         if (!atkbd->softrepeat) {
1011                 input_dev->rep[REP_DELAY] = 250;
1012                 input_dev->rep[REP_PERIOD] = 33;
1013         }
1014
1015         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1016                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1017
1018         if (atkbd->scroll) {
1019                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1020                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1021                         BIT_MASK(REL_HWHEEL);
1022                 __set_bit(BTN_MIDDLE, input_dev->keybit);
1023         }
1024
1025         input_dev->keycode = atkbd->keycode;
1026         input_dev->keycodesize = sizeof(unsigned short);
1027         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1028
1029         for (i = 0; i < 512; i++)
1030                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
1031                         __set_bit(atkbd->keycode[i], input_dev->keybit);
1032 }
1033
1034 /*
1035  * atkbd_connect() is called when the serio module finds an interface
1036  * that isn't handled yet by an appropriate device driver. We check if
1037  * there is an AT keyboard out there and if yes, we register ourselves
1038  * to the input module.
1039  */
1040
1041 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1042 {
1043         struct atkbd *atkbd;
1044         struct input_dev *dev;
1045         int err = -ENOMEM;
1046
1047         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1048         dev = input_allocate_device();
1049         if (!atkbd || !dev)
1050                 goto fail1;
1051
1052         atkbd->dev = dev;
1053         ps2_init(&atkbd->ps2dev, serio);
1054         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1055         mutex_init(&atkbd->event_mutex);
1056
1057         switch (serio->id.type) {
1058
1059                 case SERIO_8042_XL:
1060                         atkbd->translated = 1;
1061                 case SERIO_8042:
1062                         if (serio->write)
1063                                 atkbd->write = 1;
1064                         break;
1065         }
1066
1067         atkbd->softraw = atkbd_softraw;
1068         atkbd->softrepeat = atkbd_softrepeat;
1069         atkbd->scroll = atkbd_scroll;
1070
1071         if (atkbd->softrepeat)
1072                 atkbd->softraw = 1;
1073
1074         serio_set_drvdata(serio, atkbd);
1075
1076         err = serio_open(serio, drv);
1077         if (err)
1078                 goto fail2;
1079
1080         if (atkbd->write) {
1081
1082                 if (atkbd_probe(atkbd)) {
1083                         err = -ENODEV;
1084                         goto fail3;
1085                 }
1086
1087                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1088                 atkbd_activate(atkbd);
1089
1090         } else {
1091                 atkbd->set = 2;
1092                 atkbd->id = 0xab00;
1093         }
1094
1095         atkbd_set_keycode_table(atkbd);
1096         atkbd_set_device_attrs(atkbd);
1097
1098         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1099         if (err)
1100                 goto fail3;
1101
1102         atkbd_enable(atkbd);
1103
1104         err = input_register_device(atkbd->dev);
1105         if (err)
1106                 goto fail4;
1107
1108         return 0;
1109
1110  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1111  fail3: serio_close(serio);
1112  fail2: serio_set_drvdata(serio, NULL);
1113  fail1: input_free_device(dev);
1114         kfree(atkbd);
1115         return err;
1116 }
1117
1118 /*
1119  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1120  * most likely called on resume.
1121  */
1122
1123 static int atkbd_reconnect(struct serio *serio)
1124 {
1125         struct atkbd *atkbd = serio_get_drvdata(serio);
1126         struct serio_driver *drv = serio->drv;
1127
1128         if (!atkbd || !drv) {
1129                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1130                 return -1;
1131         }
1132
1133         atkbd_disable(atkbd);
1134
1135         if (atkbd->write) {
1136                 if (atkbd_probe(atkbd))
1137                         return -1;
1138                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1139                         return -1;
1140
1141                 atkbd_activate(atkbd);
1142
1143 /*
1144  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1145  * to pre-resume state
1146  */
1147                 if (!atkbd->softrepeat)
1148                         atkbd_set_repeat_rate(atkbd);
1149                 atkbd_set_leds(atkbd);
1150         }
1151
1152         atkbd_enable(atkbd);
1153
1154         return 0;
1155 }
1156
1157 static struct serio_device_id atkbd_serio_ids[] = {
1158         {
1159                 .type   = SERIO_8042,
1160                 .proto  = SERIO_ANY,
1161                 .id     = SERIO_ANY,
1162                 .extra  = SERIO_ANY,
1163         },
1164         {
1165                 .type   = SERIO_8042_XL,
1166                 .proto  = SERIO_ANY,
1167                 .id     = SERIO_ANY,
1168                 .extra  = SERIO_ANY,
1169         },
1170         {
1171                 .type   = SERIO_RS232,
1172                 .proto  = SERIO_PS2SER,
1173                 .id     = SERIO_ANY,
1174                 .extra  = SERIO_ANY,
1175         },
1176         { 0 }
1177 };
1178
1179 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1180
1181 static struct serio_driver atkbd_drv = {
1182         .driver         = {
1183                 .name   = "atkbd",
1184         },
1185         .description    = DRIVER_DESC,
1186         .id_table       = atkbd_serio_ids,
1187         .interrupt      = atkbd_interrupt,
1188         .connect        = atkbd_connect,
1189         .reconnect      = atkbd_reconnect,
1190         .disconnect     = atkbd_disconnect,
1191         .cleanup        = atkbd_cleanup,
1192 };
1193
1194 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1195                                 ssize_t (*handler)(struct atkbd *, char *))
1196 {
1197         struct serio *serio = to_serio_port(dev);
1198         int retval;
1199
1200         retval = serio_pin_driver(serio);
1201         if (retval)
1202                 return retval;
1203
1204         if (serio->drv != &atkbd_drv) {
1205                 retval = -ENODEV;
1206                 goto out;
1207         }
1208
1209         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1210
1211 out:
1212         serio_unpin_driver(serio);
1213         return retval;
1214 }
1215
1216 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1217                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1218 {
1219         struct serio *serio = to_serio_port(dev);
1220         struct atkbd *atkbd;
1221         int retval;
1222
1223         retval = serio_pin_driver(serio);
1224         if (retval)
1225                 return retval;
1226
1227         if (serio->drv != &atkbd_drv) {
1228                 retval = -ENODEV;
1229                 goto out;
1230         }
1231
1232         atkbd = serio_get_drvdata(serio);
1233         atkbd_disable(atkbd);
1234         retval = handler(atkbd, buf, count);
1235         atkbd_enable(atkbd);
1236
1237 out:
1238         serio_unpin_driver(serio);
1239         return retval;
1240 }
1241
1242 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1243 {
1244         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1245 }
1246
1247 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1248 {
1249         struct input_dev *old_dev, *new_dev;
1250         unsigned long value;
1251         int err;
1252         unsigned char old_extra, old_set;
1253
1254         if (!atkbd->write)
1255                 return -EIO;
1256
1257         if (strict_strtoul(buf, 10, &value) || value > 1)
1258                 return -EINVAL;
1259
1260         if (atkbd->extra != value) {
1261                 /*
1262                  * Since device's properties will change we need to
1263                  * unregister old device. But allocate and register
1264                  * new one first to make sure we have it.
1265                  */
1266                 old_dev = atkbd->dev;
1267                 old_extra = atkbd->extra;
1268                 old_set = atkbd->set;
1269
1270                 new_dev = input_allocate_device();
1271                 if (!new_dev)
1272                         return -ENOMEM;
1273
1274                 atkbd->dev = new_dev;
1275                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1276                 atkbd_activate(atkbd);
1277                 atkbd_set_keycode_table(atkbd);
1278                 atkbd_set_device_attrs(atkbd);
1279
1280                 err = input_register_device(atkbd->dev);
1281                 if (err) {
1282                         input_free_device(new_dev);
1283
1284                         atkbd->dev = old_dev;
1285                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1286                         atkbd_set_keycode_table(atkbd);
1287                         atkbd_set_device_attrs(atkbd);
1288
1289                         return err;
1290                 }
1291                 input_unregister_device(old_dev);
1292
1293         }
1294         return count;
1295 }
1296
1297 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1298 {
1299         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1300 }
1301
1302 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1303 {
1304         struct input_dev *old_dev, *new_dev;
1305         unsigned long value;
1306         int err;
1307         unsigned char old_scroll;
1308
1309         if (strict_strtoul(buf, 10, &value) || value > 1)
1310                 return -EINVAL;
1311
1312         if (atkbd->scroll != value) {
1313                 old_dev = atkbd->dev;
1314                 old_scroll = atkbd->scroll;
1315
1316                 new_dev = input_allocate_device();
1317                 if (!new_dev)
1318                         return -ENOMEM;
1319
1320                 atkbd->dev = new_dev;
1321                 atkbd->scroll = value;
1322                 atkbd_set_keycode_table(atkbd);
1323                 atkbd_set_device_attrs(atkbd);
1324
1325                 err = input_register_device(atkbd->dev);
1326                 if (err) {
1327                         input_free_device(new_dev);
1328
1329                         atkbd->scroll = old_scroll;
1330                         atkbd->dev = old_dev;
1331                         atkbd_set_keycode_table(atkbd);
1332                         atkbd_set_device_attrs(atkbd);
1333
1334                         return err;
1335                 }
1336                 input_unregister_device(old_dev);
1337         }
1338         return count;
1339 }
1340
1341 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1342 {
1343         return sprintf(buf, "%d\n", atkbd->set);
1344 }
1345
1346 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1347 {
1348         struct input_dev *old_dev, *new_dev;
1349         unsigned long value;
1350         int err;
1351         unsigned char old_set, old_extra;
1352
1353         if (!atkbd->write)
1354                 return -EIO;
1355
1356         if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1357                 return -EINVAL;
1358
1359         if (atkbd->set != value) {
1360                 old_dev = atkbd->dev;
1361                 old_extra = atkbd->extra;
1362                 old_set = atkbd->set;
1363
1364                 new_dev = input_allocate_device();
1365                 if (!new_dev)
1366                         return -ENOMEM;
1367
1368                 atkbd->dev = new_dev;
1369                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1370                 atkbd_activate(atkbd);
1371                 atkbd_set_keycode_table(atkbd);
1372                 atkbd_set_device_attrs(atkbd);
1373
1374                 err = input_register_device(atkbd->dev);
1375                 if (err) {
1376                         input_free_device(new_dev);
1377
1378                         atkbd->dev = old_dev;
1379                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1380                         atkbd_set_keycode_table(atkbd);
1381                         atkbd_set_device_attrs(atkbd);
1382
1383                         return err;
1384                 }
1385                 input_unregister_device(old_dev);
1386         }
1387         return count;
1388 }
1389
1390 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1391 {
1392         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1393 }
1394
1395 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1396 {
1397         struct input_dev *old_dev, *new_dev;
1398         unsigned long value;
1399         int err;
1400         unsigned char old_softrepeat, old_softraw;
1401
1402         if (!atkbd->write)
1403                 return -EIO;
1404
1405         if (strict_strtoul(buf, 10, &value) || value > 1)
1406                 return -EINVAL;
1407
1408         if (atkbd->softrepeat != value) {
1409                 old_dev = atkbd->dev;
1410                 old_softrepeat = atkbd->softrepeat;
1411                 old_softraw = atkbd->softraw;
1412
1413                 new_dev = input_allocate_device();
1414                 if (!new_dev)
1415                         return -ENOMEM;
1416
1417                 atkbd->dev = new_dev;
1418                 atkbd->softrepeat = value;
1419                 if (atkbd->softrepeat)
1420                         atkbd->softraw = 1;
1421                 atkbd_set_device_attrs(atkbd);
1422
1423                 err = input_register_device(atkbd->dev);
1424                 if (err) {
1425                         input_free_device(new_dev);
1426
1427                         atkbd->dev = old_dev;
1428                         atkbd->softrepeat = old_softrepeat;
1429                         atkbd->softraw = old_softraw;
1430                         atkbd_set_device_attrs(atkbd);
1431
1432                         return err;
1433                 }
1434                 input_unregister_device(old_dev);
1435         }
1436         return count;
1437 }
1438
1439
1440 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1441 {
1442         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1443 }
1444
1445 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1446 {
1447         struct input_dev *old_dev, *new_dev;
1448         unsigned long value;
1449         int err;
1450         unsigned char old_softraw;
1451
1452         if (strict_strtoul(buf, 10, &value) || value > 1)
1453                 return -EINVAL;
1454
1455         if (atkbd->softraw != value) {
1456                 old_dev = atkbd->dev;
1457                 old_softraw = atkbd->softraw;
1458
1459                 new_dev = input_allocate_device();
1460                 if (!new_dev)
1461                         return -ENOMEM;
1462
1463                 atkbd->dev = new_dev;
1464                 atkbd->softraw = value;
1465                 atkbd_set_device_attrs(atkbd);
1466
1467                 err = input_register_device(atkbd->dev);
1468                 if (err) {
1469                         input_free_device(new_dev);
1470
1471                         atkbd->dev = old_dev;
1472                         atkbd->softraw = old_softraw;
1473                         atkbd_set_device_attrs(atkbd);
1474
1475                         return err;
1476                 }
1477                 input_unregister_device(old_dev);
1478         }
1479         return count;
1480 }
1481
1482 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1483 {
1484         return sprintf(buf, "%lu\n", atkbd->err_count);
1485 }
1486
1487 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1488 {
1489         atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1490         atkbd_platform_fixup_data = id->driver_data;
1491
1492         return 0;
1493 }
1494
1495 static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
1496         {
1497                 .ident = "Dell Laptop",
1498                 .matches = {
1499                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1500                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1501                 },
1502                 .callback = atkbd_setup_forced_release,
1503                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1504         },
1505         {
1506                 .ident = "Dell Laptop",
1507                 .matches = {
1508                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1509                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1510                 },
1511                 .callback = atkbd_setup_forced_release,
1512                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1513         },
1514         {
1515                 .ident = "HP 2133",
1516                 .matches = {
1517                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1518                         DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1519                 },
1520                 .callback = atkbd_setup_forced_release,
1521                 .driver_data = atkbd_hp_forced_release_keys,
1522         },
1523         {
1524                 .ident = "HP Pavilion ZV6100",
1525                 .matches = {
1526                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1527                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1528                 },
1529                 .callback = atkbd_setup_forced_release,
1530                 .driver_data = atkbd_hp_zv6100_forced_release_keys,
1531         },
1532         {
1533                 .ident = "Inventec Symphony",
1534                 .matches = {
1535                         DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1536                         DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1537                 },
1538                 .callback = atkbd_setup_forced_release,
1539                 .driver_data = atkbd_inventec_forced_release_keys,
1540         },
1541         {
1542                 .ident = "Samsung NC10",
1543                 .matches = {
1544                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1545                         DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1546                 },
1547                 .callback = atkbd_setup_forced_release,
1548                 .driver_data = atkbd_samsung_forced_release_keys,
1549         },
1550         {
1551                 .ident = "Samsung NC20",
1552                 .matches = {
1553                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1554                         DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1555                 },
1556                 .callback = atkbd_setup_forced_release,
1557                 .driver_data = atkbd_samsung_forced_release_keys,
1558         },
1559         {
1560                 .ident = "Samsung SQ45S70S",
1561                 .matches = {
1562                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1563                         DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1564                 },
1565                 .callback = atkbd_setup_forced_release,
1566                 .driver_data = atkbd_samsung_forced_release_keys,
1567         },
1568         {
1569                 .ident = "Fujitsu Amilo PA 1510",
1570                 .matches = {
1571                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1572                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1573                 },
1574                 .callback = atkbd_setup_forced_release,
1575                 .driver_data = atkbd_amilo_pa1510_forced_release_keys,
1576         },
1577         {
1578                 .ident = "Fujitsu Amilo Pi 3525",
1579                 .matches = {
1580                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1581                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1582                 },
1583                 .callback = atkbd_setup_forced_release,
1584                 .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1585         },
1586         {
1587                 .ident = "Fujitsu Amilo Xi 3650",
1588                 .matches = {
1589                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1590                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1591                 },
1592                 .callback = atkbd_setup_forced_release,
1593                 .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1594         },
1595         { }
1596 };
1597
1598 static int __init atkbd_init(void)
1599 {
1600         dmi_check_system(atkbd_dmi_quirk_table);
1601
1602         return serio_register_driver(&atkbd_drv);
1603 }
1604
1605 static void __exit atkbd_exit(void)
1606 {
1607         serio_unregister_driver(&atkbd_drv);
1608 }
1609
1610 module_init(atkbd_init);
1611 module_exit(atkbd_exit);