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