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