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