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