drivers/input/keyboard/atkbd.c

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