drivers/input/keyboard/atkbd.c

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