drivers/input/keyboard/atkbd.c

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