drivers/input/keyboard/atkbd.c

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