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 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 /*
 680  * atkbd_probe() probes for an AT keyboard on a serio port.
 681  */
 682
 683 static int atkbd_probe(struct atkbd *atkbd)
 684 {
 685         struct ps2dev *ps2dev = &atkbd->ps2dev;
 686         unsigned char param[2];
 687
 688 /*
 689  * Some systems, where the bit-twiddling when testing the io-lines of the
 690  * controller may confuse the keyboard need a full reset of the keyboard. On
 691  * these systems the BIOS also usually doesn't do it for us.
 692  */
 693
 694         if (atkbd_reset)
 695                 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
 696                         dev_warn(&ps2dev->serio->dev,
 697                                  "keyboard reset failed on %s\n",
 698                                  ps2dev->serio->phys);
 699
 700 /*
 701  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
 702  * Some keyboards report different values, but the first byte is always 0xab or
 703  * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
 704  * should make sure we don't try to set the LEDs on it.
 705  */
 706
 707         param[0] = param[1] = 0xa5;     /* initialize with invalid values */
 708         if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
 709
 710 /*
 711  * If the get ID command failed, we check if we can at least set the LEDs on
 712  * the keyboard. This should work on every keyboard out there. It also turns
 713  * the LEDs off, which we want anyway.
 714  */
 715                 param[0] = 0;
 716                 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 717                         return -1;
 718                 atkbd->id = 0xabba;
 719                 return 0;
 720         }
 721
 722         if (!ps2_is_keyboard_id(param[0]))
 723                 return -1;
 724
 725         atkbd->id = (param[0] << 8) | param[1];
 726
 727         if (atkbd->id == 0xaca1 && atkbd->translated) {
 728                 dev_err(&ps2dev->serio->dev,
 729                         "NCD terminal keyboards are only supported on non-translating controlelrs. "
 730                         "Use i8042.direct=1 to disable translation.\n");
 731                 return -1;
 732         }
 733
 734         return 0;
 735 }
 736
 737 /*
 738  * atkbd_select_set checks if a keyboard has a working Set 3 support, and
 739  * sets it into that. Unfortunately there are keyboards that can be switched
 740  * to Set 3, but don't work well in that (BTC Multimedia ...)
 741  */
 742
 743 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
 744 {
 745         struct ps2dev *ps2dev = &atkbd->ps2dev;
 746         unsigned char param[2];
 747
 748         atkbd->extra = false;
 749 /*
 750  * For known special keyboards we can go ahead and set the correct set.
 751  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
 752  * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
 753  */
 754
 755         if (atkbd->translated)
 756                 return 2;
 757
 758         if (atkbd->id == 0xaca1) {
 759                 param[0] = 3;
 760                 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
 761                 return 3;
 762         }
 763
 764         if (allow_extra) {
 765                 param[0] = 0x71;
 766                 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
 767                         atkbd->extra = true;
 768                         return 2;
 769                 }
 770         }
 771
 772         if (atkbd_terminal) {
 773                 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
 774                 return 3;
 775         }
 776
 777         if (target_set != 3)
 778                 return 2;
 779
 780         if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
 781                 atkbd->id = param[0] << 8 | param[1];
 782                 return 2;
 783         }
 784
 785         param[0] = 3;
 786         if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 787                 return 2;
 788
 789         param[0] = 0;
 790         if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
 791                 return 2;
 792
 793         if (param[0] != 3) {
 794                 param[0] = 2;
 795                 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 796                 return 2;
 797         }
 798
 799         ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
 800
 801         return 3;
 802 }
 803
 804 static int atkbd_reset_state(struct atkbd *atkbd)
 805 {
 806         struct ps2dev *ps2dev = &atkbd->ps2dev;
 807         unsigned char param[1];
 808
 809 /*
 810  * Set the LEDs to a predefined state (all off).
 811  */
 812
 813         param[0] = 0;
 814         if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 815                 return -1;
 816
 817 /*
 818  * Set autorepeat to fastest possible.
 819  */
 820
 821         param[0] = 0;
 822         if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
 823                 return -1;
 824
 825         return 0;
 826 }
 827
 828 static int atkbd_activate(struct atkbd *atkbd)
 829 {
 830         struct ps2dev *ps2dev = &atkbd->ps2dev;
 831
 832 /*
 833  * Enable the keyboard to receive keystrokes.
 834  */
 835
 836         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 837                 dev_err(&ps2dev->serio->dev,
 838                         "Failed to enable keyboard on %s\n",
 839                         ps2dev->serio->phys);
 840                 return -1;
 841         }
 842
 843         return 0;
 844 }
 845
 846 /*
 847  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 848  * reboot.
 849  */
 850
 851 static void atkbd_cleanup(struct serio *serio)
 852 {
 853         struct atkbd *atkbd = serio_get_drvdata(serio);
 854
 855         atkbd_disable(atkbd);
 856         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
 857 }
 858
 859
 860 /*
 861  * atkbd_disconnect() closes and frees.
 862  */
 863
 864 static void atkbd_disconnect(struct serio *serio)
 865 {
 866         struct atkbd *atkbd = serio_get_drvdata(serio);
 867
 868         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 869
 870         atkbd_disable(atkbd);
 871
 872         input_unregister_device(atkbd->dev);
 873
 874         /*
 875          * Make sure we don't have a command in flight.
 876          * Note that since atkbd->enabled is false event work will keep
 877          * rescheduling itself until it gets canceled and will not try
 878          * accessing freed input device or serio port.
 879          */
 880         cancel_delayed_work_sync(&atkbd->event_work);
 881
 882         serio_close(serio);
 883         serio_set_drvdata(serio, NULL);
 884         kfree(atkbd);
 885 }
 886
 887 /*
 888  * generate release events for the keycodes given in data
 889  */
 890 static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
 891                                                 const void *data)
 892 {
 893         const unsigned int *keys = data;
 894         unsigned int i;
 895
 896         if (atkbd->set == 2)
 897                 for (i = 0; keys[i] != -1U; i++)
 898                         __set_bit(keys[i], atkbd->force_release_mask);
 899 }
 900
 901 /*
 902  * Most special keys (Fn+F?) on Dell laptops do not generate release
 903  * events so we have to do it ourselves.
 904  */
 905 static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
 906         0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
 907 };
 908
 909 /*
 910  * Perform fixup for HP system that doesn't generate release
 911  * for its video switch
 912  */
 913 static unsigned int atkbd_hp_forced_release_keys[] = {
 914         0x94, -1U
 915 };
 916
 917 /*
 918  * Samsung NC10,NC20 with Fn+F? key release not working
 919  */
 920 static unsigned int atkbd_samsung_forced_release_keys[] = {
 921         0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
 922 };
 923
 924 /*
 925  * Amilo Pi 3525 key release for Fn+Volume keys not working
 926  */
 927 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
 928         0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
 929 };
 930
 931 /*
 932  * Amilo Xi 3650 key release for light touch bar not working
 933  */
 934 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
 935         0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
 936 };
 937
 938 /*
 939  * Soltech TA12 system with broken key release on volume keys and mute key
 940  */
 941 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
 942         0xa0, 0xae, 0xb0, -1U
 943 };
 944
 945 /*
 946  * Many notebooks don't send key release event for volume up/down
 947  * keys, with key list below common among them
 948  */
 949 static unsigned int atkbd_volume_forced_release_keys[] = {
 950         0xae, 0xb0, -1U
 951 };
 952
 953 /*
 954  * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
 955  * they should be generating e4-e6 (0x80 | code).
 956  */
 957 static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
 958                                                     unsigned int code)
 959 {
 960         if (atkbd->translated && atkbd->emul == 1 &&
 961             (code == 0x64 || code == 0x65 || code == 0x66)) {
 962                 atkbd->emul = 0;
 963                 code |= 0x80;
 964         }
 965
 966         return code;
 967 }
 968
 969 /*
 970  * atkbd_set_keycode_table() initializes keyboard's keycode table
 971  * according to the selected scancode set
 972  */
 973
 974 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 975 {
 976         unsigned int scancode;
 977         int i, j;
 978
 979         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 980         bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
 981
 982         if (atkbd->translated) {
 983                 for (i = 0; i < 128; i++) {
 984                         scancode = atkbd_unxlate_table[i];
 985                         atkbd->keycode[i] = atkbd_set2_keycode[scancode];
 986                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
 987                         if (atkbd->scroll)
 988                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 989                                         if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
 990                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 991                 }
 992         } else if (atkbd->set == 3) {
 993                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 994         } else {
 995                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 996
 997                 if (atkbd->scroll)
 998                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
 999                                 scancode = atkbd_scroll_keys[i].set2;
1000                                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1001                 }
1002         }
1003
1004 /*
1005  * HANGEUL and HANJA keys do not send release events so we need to
1006  * generate such events ourselves
1007  */
1008         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1009         atkbd->keycode[scancode] = KEY_HANGEUL;
1010         __set_bit(scancode, atkbd->force_release_mask);
1011
1012         scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1013         atkbd->keycode[scancode] = KEY_HANJA;
1014         __set_bit(scancode, atkbd->force_release_mask);
1015
1016 /*
1017  * Perform additional fixups
1018  */
1019         if (atkbd_platform_fixup)
1020                 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1021 }
1022
1023 /*
1024  * atkbd_set_device_attrs() sets up keyboard's input device structure
1025  */
1026
1027 static void atkbd_set_device_attrs(struct atkbd *atkbd)
1028 {
1029         struct input_dev *input_dev = atkbd->dev;
1030         int i;
1031
1032         if (atkbd->extra)
1033                 snprintf(atkbd->name, sizeof(atkbd->name),
1034                          "AT Set 2 Extra keyboard");
1035         else
1036                 snprintf(atkbd->name, sizeof(atkbd->name),
1037                          "AT %s Set %d keyboard",
1038                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
1039
1040         snprintf(atkbd->phys, sizeof(atkbd->phys),
1041                  "%s/input0", atkbd->ps2dev.serio->phys);
1042
1043         input_dev->name = atkbd->name;
1044         input_dev->phys = atkbd->phys;
1045         input_dev->id.bustype = BUS_I8042;
1046         input_dev->id.vendor = 0x0001;
1047         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1048         input_dev->id.version = atkbd->id;
1049         input_dev->event = atkbd_event;
1050         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1051
1052         input_set_drvdata(input_dev, atkbd);
1053
1054         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1055                 BIT_MASK(EV_MSC);
1056
1057         if (atkbd->write) {
1058                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1059                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1060                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1061         }
1062
1063         if (atkbd->extra)
1064                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1065                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1066                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1067
1068         if (!atkbd->softrepeat) {
1069                 input_dev->rep[REP_DELAY] = 250;
1070                 input_dev->rep[REP_PERIOD] = 33;
1071         }
1072
1073         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1074                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1075
1076         if (atkbd->scroll) {
1077                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1078                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1079                         BIT_MASK(REL_HWHEEL);
1080                 __set_bit(BTN_MIDDLE, input_dev->keybit);
1081         }
1082
1083         input_dev->keycode = atkbd->keycode;
1084         input_dev->keycodesize = sizeof(unsigned short);
1085         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1086
1087         for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1088                 if (atkbd->keycode[i] != KEY_RESERVED &&
1089                     atkbd->keycode[i] != ATKBD_KEY_NULL &&
1090                     atkbd->keycode[i] < ATKBD_SPECIAL) {
1091                         __set_bit(atkbd->keycode[i], input_dev->keybit);
1092                 }
1093         }
1094 }
1095
1096 /*
1097  * atkbd_connect() is called when the serio module finds an interface
1098  * that isn't handled yet by an appropriate device driver. We check if
1099  * there is an AT keyboard out there and if yes, we register ourselves
1100  * to the input module.
1101  */
1102
1103 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1104 {
1105         struct atkbd *atkbd;
1106         struct input_dev *dev;
1107         int err = -ENOMEM;
1108
1109         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1110         dev = input_allocate_device();
1111         if (!atkbd || !dev)
1112                 goto fail1;
1113
1114         atkbd->dev = dev;
1115         ps2_init(&atkbd->ps2dev, serio);
1116         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1117         mutex_init(&atkbd->mutex);
1118
1119         switch (serio->id.type) {
1120
1121         case SERIO_8042_XL:
1122                 atkbd->translated = true;
1123                 /* Fall through */
1124
1125         case SERIO_8042:
1126                 if (serio->write)
1127                         atkbd->write = true;
1128                 break;
1129         }
1130
1131         atkbd->softraw = atkbd_softraw;
1132         atkbd->softrepeat = atkbd_softrepeat;
1133         atkbd->scroll = atkbd_scroll;
1134
1135         if (atkbd->softrepeat)
1136                 atkbd->softraw = true;
1137
1138         serio_set_drvdata(serio, atkbd);
1139
1140         err = serio_open(serio, drv);
1141         if (err)
1142                 goto fail2;
1143
1144         if (atkbd->write) {
1145
1146                 if (atkbd_probe(atkbd)) {
1147                         err = -ENODEV;
1148                         goto fail3;
1149                 }
1150
1151                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1152                 atkbd_reset_state(atkbd);
1153                 atkbd_activate(atkbd);
1154
1155         } else {
1156                 atkbd->set = 2;
1157                 atkbd->id = 0xab00;
1158         }
1159
1160         atkbd_set_keycode_table(atkbd);
1161         atkbd_set_device_attrs(atkbd);
1162
1163         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1164         if (err)
1165                 goto fail3;
1166
1167         atkbd_enable(atkbd);
1168
1169         err = input_register_device(atkbd->dev);
1170         if (err)
1171                 goto fail4;
1172
1173         return 0;
1174
1175  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1176  fail3: serio_close(serio);
1177  fail2: serio_set_drvdata(serio, NULL);
1178  fail1: input_free_device(dev);
1179         kfree(atkbd);
1180         return err;
1181 }
1182
1183 /*
1184  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1185  * most likely called on resume.
1186  */
1187
1188 static int atkbd_reconnect(struct serio *serio)
1189 {
1190         struct atkbd *atkbd = serio_get_drvdata(serio);
1191         struct serio_driver *drv = serio->drv;
1192         int retval = -1;
1193
1194         if (!atkbd || !drv) {
1195                 dev_dbg(&serio->dev,
1196                         "reconnect request, but serio is disconnected, ignoring...\n");
1197                 return -1;
1198         }
1199
1200         mutex_lock(&atkbd->mutex);
1201
1202         atkbd_disable(atkbd);
1203
1204         if (atkbd->write) {
1205                 if (atkbd_probe(atkbd))
1206                         goto out;
1207
1208                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1209                         goto out;
1210
1211                 atkbd_activate(atkbd);
1212
1213                 /*
1214                  * Restore LED state and repeat rate. While input core
1215                  * will do this for us at resume time reconnect may happen
1216                  * because user requested it via sysfs or simply because
1217                  * keyboard was unplugged and plugged in again so we need
1218                  * to do it ourselves here.
1219                  */
1220                 atkbd_set_leds(atkbd);
1221                 if (!atkbd->softrepeat)
1222                         atkbd_set_repeat_rate(atkbd);
1223
1224         }
1225
1226         atkbd_enable(atkbd);
1227         retval = 0;
1228
1229  out:
1230         mutex_unlock(&atkbd->mutex);
1231         return retval;
1232 }
1233
1234 static struct serio_device_id atkbd_serio_ids[] = {
1235         {
1236                 .type   = SERIO_8042,
1237                 .proto  = SERIO_ANY,
1238                 .id     = SERIO_ANY,
1239                 .extra  = SERIO_ANY,
1240         },
1241         {
1242                 .type   = SERIO_8042_XL,
1243                 .proto  = SERIO_ANY,
1244                 .id     = SERIO_ANY,
1245                 .extra  = SERIO_ANY,
1246         },
1247         {
1248                 .type   = SERIO_RS232,
1249                 .proto  = SERIO_PS2SER,
1250                 .id     = SERIO_ANY,
1251                 .extra  = SERIO_ANY,
1252         },
1253         { 0 }
1254 };
1255
1256 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1257
1258 static struct serio_driver atkbd_drv = {
1259         .driver         = {
1260                 .name   = "atkbd",
1261         },
1262         .description    = DRIVER_DESC,
1263         .id_table       = atkbd_serio_ids,
1264         .interrupt      = atkbd_interrupt,
1265         .connect        = atkbd_connect,
1266         .reconnect      = atkbd_reconnect,
1267         .disconnect     = atkbd_disconnect,
1268         .cleanup        = atkbd_cleanup,
1269 };
1270
1271 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1272                                 ssize_t (*handler)(struct atkbd *, char *))
1273 {
1274         struct serio *serio = to_serio_port(dev);
1275         struct atkbd *atkbd = serio_get_drvdata(serio);
1276
1277         return handler(atkbd, buf);
1278 }
1279
1280 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1281                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1282 {
1283         struct serio *serio = to_serio_port(dev);
1284         struct atkbd *atkbd = serio_get_drvdata(serio);
1285         int retval;
1286
1287         retval = mutex_lock_interruptible(&atkbd->mutex);
1288         if (retval)
1289                 return retval;
1290
1291         atkbd_disable(atkbd);
1292         retval = handler(atkbd, buf, count);
1293         atkbd_enable(atkbd);
1294
1295         mutex_unlock(&atkbd->mutex);
1296
1297         return retval;
1298 }
1299
1300 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1301 {
1302         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1303 }
1304
1305 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1306 {
1307         struct input_dev *old_dev, *new_dev;
1308         unsigned long value;
1309         int err;
1310         bool old_extra;
1311         unsigned char old_set;
1312
1313         if (!atkbd->write)
1314                 return -EIO;
1315
1316         if (strict_strtoul(buf, 10, &value) || value > 1)
1317                 return -EINVAL;
1318
1319         if (atkbd->extra != value) {
1320                 /*
1321                  * Since device's properties will change we need to
1322                  * unregister old device. But allocate and register
1323                  * new one first to make sure we have it.
1324                  */
1325                 old_dev = atkbd->dev;
1326                 old_extra = atkbd->extra;
1327                 old_set = atkbd->set;
1328
1329                 new_dev = input_allocate_device();
1330                 if (!new_dev)
1331                         return -ENOMEM;
1332
1333                 atkbd->dev = new_dev;
1334                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1335                 atkbd_reset_state(atkbd);
1336                 atkbd_activate(atkbd);
1337                 atkbd_set_keycode_table(atkbd);
1338                 atkbd_set_device_attrs(atkbd);
1339
1340                 err = input_register_device(atkbd->dev);
1341                 if (err) {
1342                         input_free_device(new_dev);
1343
1344                         atkbd->dev = old_dev;
1345                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1346                         atkbd_set_keycode_table(atkbd);
1347                         atkbd_set_device_attrs(atkbd);
1348
1349                         return err;
1350                 }
1351                 input_unregister_device(old_dev);
1352
1353         }
1354         return count;
1355 }
1356
1357 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1358 {
1359         size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1360                         atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1361
1362         buf[len++] = '\n';
1363         buf[len] = '\0';
1364
1365         return len;
1366 }
1367
1368 static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1369                                         const char *buf, size_t count)
1370 {
1371         /* 64 bytes on stack should be acceptable */
1372         DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1373         int err;
1374
1375         err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1376         if (err)
1377                 return err;
1378
1379         memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1380         return count;
1381 }
1382
1383
1384 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1385 {
1386         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1387 }
1388
1389 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1390 {
1391         struct input_dev *old_dev, *new_dev;
1392         unsigned long value;
1393         int err;
1394         bool old_scroll;
1395
1396         if (strict_strtoul(buf, 10, &value) || value > 1)
1397                 return -EINVAL;
1398
1399         if (atkbd->scroll != value) {
1400                 old_dev = atkbd->dev;
1401                 old_scroll = atkbd->scroll;
1402
1403                 new_dev = input_allocate_device();
1404                 if (!new_dev)
1405                         return -ENOMEM;
1406
1407                 atkbd->dev = new_dev;
1408                 atkbd->scroll = value;
1409                 atkbd_set_keycode_table(atkbd);
1410                 atkbd_set_device_attrs(atkbd);
1411
1412                 err = input_register_device(atkbd->dev);
1413                 if (err) {
1414                         input_free_device(new_dev);
1415
1416                         atkbd->scroll = old_scroll;
1417                         atkbd->dev = old_dev;
1418                         atkbd_set_keycode_table(atkbd);
1419                         atkbd_set_device_attrs(atkbd);
1420
1421                         return err;
1422                 }
1423                 input_unregister_device(old_dev);
1424         }
1425         return count;
1426 }
1427
1428 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1429 {
1430         return sprintf(buf, "%d\n", atkbd->set);
1431 }
1432
1433 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1434 {
1435         struct input_dev *old_dev, *new_dev;
1436         unsigned long value;
1437         int err;
1438         unsigned char old_set;
1439         bool old_extra;
1440
1441         if (!atkbd->write)
1442                 return -EIO;
1443
1444         if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1445                 return -EINVAL;
1446
1447         if (atkbd->set != value) {
1448                 old_dev = atkbd->dev;
1449                 old_extra = atkbd->extra;
1450                 old_set = atkbd->set;
1451
1452                 new_dev = input_allocate_device();
1453                 if (!new_dev)
1454                         return -ENOMEM;
1455
1456                 atkbd->dev = new_dev;
1457                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1458                 atkbd_reset_state(atkbd);
1459                 atkbd_activate(atkbd);
1460                 atkbd_set_keycode_table(atkbd);
1461                 atkbd_set_device_attrs(atkbd);
1462
1463                 err = input_register_device(atkbd->dev);
1464                 if (err) {
1465                         input_free_device(new_dev);
1466
1467                         atkbd->dev = old_dev;
1468                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1469                         atkbd_set_keycode_table(atkbd);
1470                         atkbd_set_device_attrs(atkbd);
1471
1472                         return err;
1473                 }
1474                 input_unregister_device(old_dev);
1475         }
1476         return count;
1477 }
1478
1479 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1480 {
1481         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1482 }
1483
1484 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1485 {
1486         struct input_dev *old_dev, *new_dev;
1487         unsigned long value;
1488         int err;
1489         bool old_softrepeat, old_softraw;
1490
1491         if (!atkbd->write)
1492                 return -EIO;
1493
1494         if (strict_strtoul(buf, 10, &value) || value > 1)
1495                 return -EINVAL;
1496
1497         if (atkbd->softrepeat != value) {
1498                 old_dev = atkbd->dev;
1499                 old_softrepeat = atkbd->softrepeat;
1500                 old_softraw = atkbd->softraw;
1501
1502                 new_dev = input_allocate_device();
1503                 if (!new_dev)
1504                         return -ENOMEM;
1505
1506                 atkbd->dev = new_dev;
1507                 atkbd->softrepeat = value;
1508                 if (atkbd->softrepeat)
1509                         atkbd->softraw = true;
1510                 atkbd_set_device_attrs(atkbd);
1511
1512                 err = input_register_device(atkbd->dev);
1513                 if (err) {
1514                         input_free_device(new_dev);
1515
1516                         atkbd->dev = old_dev;
1517                         atkbd->softrepeat = old_softrepeat;
1518                         atkbd->softraw = old_softraw;
1519                         atkbd_set_device_attrs(atkbd);
1520
1521                         return err;
1522                 }
1523                 input_unregister_device(old_dev);
1524         }
1525         return count;
1526 }
1527
1528
1529 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1530 {
1531         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1532 }
1533
1534 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1535 {
1536         struct input_dev *old_dev, *new_dev;
1537         unsigned long value;
1538         int err;
1539         bool old_softraw;
1540
1541         if (strict_strtoul(buf, 10, &value) || value > 1)
1542                 return -EINVAL;
1543
1544         if (atkbd->softraw != value) {
1545                 old_dev = atkbd->dev;
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->softraw = value;
1554                 atkbd_set_device_attrs(atkbd);
1555
1556                 err = input_register_device(atkbd->dev);
1557                 if (err) {
1558                         input_free_device(new_dev);
1559
1560                         atkbd->dev = old_dev;
1561                         atkbd->softraw = old_softraw;
1562                         atkbd_set_device_attrs(atkbd);
1563
1564                         return err;
1565                 }
1566                 input_unregister_device(old_dev);
1567         }
1568         return count;
1569 }
1570
1571 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1572 {
1573         return sprintf(buf, "%lu\n", atkbd->err_count);
1574 }
1575
1576 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1577 {
1578         atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1579         atkbd_platform_fixup_data = id->driver_data;
1580
1581         return 1;
1582 }
1583
1584 static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1585 {
1586         atkbd_platform_scancode_fixup = id->driver_data;
1587
1588         return 1;
1589 }
1590
1591 static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1592         {
1593                 .matches = {
1594                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1595                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1596                 },
1597                 .callback = atkbd_setup_forced_release,
1598                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1599         },
1600         {
1601                 .matches = {
1602                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1603                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1604                 },
1605                 .callback = atkbd_setup_forced_release,
1606                 .driver_data = atkbd_dell_laptop_forced_release_keys,
1607         },
1608         {
1609                 .matches = {
1610                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1611                         DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1612                 },
1613                 .callback = atkbd_setup_forced_release,
1614                 .driver_data = atkbd_hp_forced_release_keys,
1615         },
1616         {
1617                 .matches = {
1618                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1619                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1620                 },
1621                 .callback = atkbd_setup_forced_release,
1622                 .driver_data = atkbd_volume_forced_release_keys,
1623         },
1624         {
1625                 .matches = {
1626                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1627                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1628                 },
1629                 .callback = atkbd_setup_forced_release,
1630                 .driver_data = atkbd_volume_forced_release_keys,
1631         },
1632         {
1633                 .matches = {
1634                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1635                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1636                 },
1637                 .callback = atkbd_setup_forced_release,
1638                 .driver_data = atkbd_volume_forced_release_keys,
1639         },
1640         {
1641                 .matches = {
1642                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1643                         DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1644                 },
1645                 .callback = atkbd_setup_forced_release,
1646                 .driver_data = atkbd_volume_forced_release_keys,
1647         },
1648         {
1649                 /* Inventec Symphony */
1650                 .matches = {
1651                         DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1652                         DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1653                 },
1654                 .callback = atkbd_setup_forced_release,
1655                 .driver_data = atkbd_volume_forced_release_keys,
1656         },
1657         {
1658                 /* Samsung NC10 */
1659                 .matches = {
1660                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1661                         DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1662                 },
1663                 .callback = atkbd_setup_forced_release,
1664                 .driver_data = atkbd_samsung_forced_release_keys,
1665         },
1666         {
1667                 /* Samsung NC20 */
1668                 .matches = {
1669                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1670                         DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1671                 },
1672                 .callback = atkbd_setup_forced_release,
1673                 .driver_data = atkbd_samsung_forced_release_keys,
1674         },
1675         {
1676                 /* Samsung SQ45S70S */
1677                 .matches = {
1678                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1679                         DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1680                 },
1681                 .callback = atkbd_setup_forced_release,
1682                 .driver_data = atkbd_samsung_forced_release_keys,
1683         },
1684         {
1685                 /* Fujitsu Amilo PA 1510 */
1686                 .matches = {
1687                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1688                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1689                 },
1690                 .callback = atkbd_setup_forced_release,
1691                 .driver_data = atkbd_volume_forced_release_keys,
1692         },
1693         {
1694                 /* Fujitsu Amilo Pi 3525 */
1695                 .matches = {
1696                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1697                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1698                 },
1699                 .callback = atkbd_setup_forced_release,
1700                 .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1701         },
1702         {
1703                 /* Fujitsu Amilo Xi 3650 */
1704                 .matches = {
1705                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1706                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1707                 },
1708                 .callback = atkbd_setup_forced_release,
1709                 .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1710         },
1711         {
1712                 .matches = {
1713                         DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1714                         DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1715                 },
1716                 .callback = atkbd_setup_forced_release,
1717                 .driver_data = atkdb_soltech_ta12_forced_release_keys,
1718         },
1719         {
1720                 /* OQO Model 01+ */
1721                 .matches = {
1722                         DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1723                         DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1724                 },
1725                 .callback = atkbd_setup_scancode_fixup,
1726                 .driver_data = atkbd_oqo_01plus_scancode_fixup,
1727         },
1728         { }
1729 };
1730
1731 static int __init atkbd_init(void)
1732 {
1733         dmi_check_system(atkbd_dmi_quirk_table);
1734
1735         return serio_register_driver(&atkbd_drv);
1736 }
1737
1738 static void __exit atkbd_exit(void)
1739 {
1740         serio_unregister_driver(&atkbd_drv);
1741 }
1742
1743 module_init(atkbd_init);
1744 module_exit(atkbd_exit);