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