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