err.no Git - linux-2.6/blob - 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 /*
  67  * Scancode to keycode tables. These are just the default setting, and
  68  * are loadable via an userland utility.
  69  */
  70
  71 static unsigned char 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,150,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 unsigned char 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,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
 115         148,149,147,140
 116 };
 117
 118 static unsigned char 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           248
 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 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 char keycode[512];
 204         unsigned char set;
 205         unsigned char translated;
 206         unsigned char extra;
 207         unsigned char write;
 208         unsigned char softrepeat;
 209         unsigned char softraw;
 210         unsigned char scroll;
 211         unsigned char enabled;
 212
 213         /* Accessed only from interrupt */
 214         unsigned char emul;
 215         unsigned char resend;
 216         unsigned char release;
 217         unsigned long xl_bit;
 218         unsigned int last;
 219         unsigned long time;
 220         unsigned long err_count;
 221
 222         struct delayed_work event_work;
 223         unsigned long event_jiffies;
 224         struct mutex event_mutex;
 225         unsigned long event_mask;
 226 };
 227
 228 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
 229                                 ssize_t (*handler)(struct atkbd *, char *));
 230 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
 231                                 ssize_t (*handler)(struct atkbd *, const char *, size_t));
 232 #define ATKBD_DEFINE_ATTR(_name)                                                \
 233 static ssize_t atkbd_show_##_name(struct atkbd *, char *);                      \
 234 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);         \
 235 static ssize_t atkbd_do_show_##_name(struct device *d,                          \
 236                                 struct device_attribute *attr, char *b)         \
 237 {                                                                               \
 238         return atkbd_attr_show_helper(d, b, atkbd_show_##_name);                \
 239 }                                                                               \
 240 static ssize_t atkbd_do_set_##_name(struct device *d,                           \
 241                         struct device_attribute *attr, const char *b, size_t s) \
 242 {                                                                               \
 243         return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);               \
 244 }                                                                               \
 245 static struct device_attribute atkbd_attr_##_name =                             \
 246         __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
 247
 248 ATKBD_DEFINE_ATTR(extra);
 249 ATKBD_DEFINE_ATTR(scroll);
 250 ATKBD_DEFINE_ATTR(set);
 251 ATKBD_DEFINE_ATTR(softrepeat);
 252 ATKBD_DEFINE_ATTR(softraw);
 253
 254 #define ATKBD_DEFINE_RO_ATTR(_name)                                             \
 255 static ssize_t atkbd_show_##_name(struct atkbd *, char *);                      \
 256 static ssize_t atkbd_do_show_##_name(struct device *d,                          \
 257                                 struct device_attribute *attr, char *b)         \
 258 {                                                                               \
 259         return atkbd_attr_show_helper(d, b, atkbd_show_##_name);                \
 260 }                                                                               \
 261 static struct device_attribute atkbd_attr_##_name =                             \
 262         __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
 263
 264 ATKBD_DEFINE_RO_ATTR(err_count);
 265
 266 static struct attribute *atkbd_attributes[] = {
 267         &atkbd_attr_extra.attr,
 268         &atkbd_attr_scroll.attr,
 269         &atkbd_attr_set.attr,
 270         &atkbd_attr_softrepeat.attr,
 271         &atkbd_attr_softraw.attr,
 272         &atkbd_attr_err_count.attr,
 273         NULL
 274 };
 275
 276 static struct attribute_group atkbd_attribute_group = {
 277         .attrs  = atkbd_attributes,
 278 };
 279
 280 static const unsigned int xl_table[] = {
 281         ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
 282         ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
 283 };
 284
 285 /*
 286  * Checks if we should mangle the scancode to extract 'release' bit
 287  * in translated mode.
 288  */
 289 static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
 290 {
 291         int i;
 292
 293         if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
 294                 return 0;
 295
 296         for (i = 0; i < ARRAY_SIZE(xl_table); i++)
 297                 if (code == xl_table[i])
 298                         return test_bit(i, &xl_bit);
 299
 300         return 1;
 301 }
 302
 303 /*
 304  * Calculates new value of xl_bit so the driver can distinguish
 305  * between make/break pair of scancodes for select keys and PS/2
 306  * protocol responses.
 307  */
 308 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
 309 {
 310         int i;
 311
 312         for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
 313                 if (!((code ^ xl_table[i]) & 0x7f)) {
 314                         if (code & 0x80)
 315                                 __clear_bit(i, &atkbd->xl_bit);
 316                         else
 317                                 __set_bit(i, &atkbd->xl_bit);
 318                         break;
 319                 }
 320         }
 321 }
 322
 323 /*
 324  * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
 325  * keeping kernel 2.4 compatibility for set 2
 326  */
 327 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
 328 {
 329         if (atkbd->set == 3) {
 330                 if (atkbd->emul == 1)
 331                         code |= 0x100;
 332         } else {
 333                 code = (code & 0x7f) | ((code & 0x80) << 1);
 334                 if (atkbd->emul == 1)
 335                         code |= 0x80;
 336         }
 337
 338         return code;
 339 }
 340
 341 /*
 342  * atkbd_interrupt(). Here takes place processing of data received from
 343  * the keyboard into events.
 344  */
 345
 346 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
 347                         unsigned int flags)
 348 {
 349         struct atkbd *atkbd = serio_get_drvdata(serio);
 350         struct input_dev *dev = atkbd->dev;
 351         unsigned int code = data;
 352         int scroll = 0, hscroll = 0, click = -1, add_release_event = 0;
 353         int value;
 354         unsigned char keycode;
 355
 356 #ifdef ATKBD_DEBUG
 357         printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
 358 #endif
 359
 360 #if !defined(__i386__) && !defined (__x86_64__)
 361         if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
 362                 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
 363                 serio_write(serio, ATKBD_CMD_RESEND);
 364                 atkbd->resend = 1;
 365                 goto out;
 366         }
 367
 368         if (!flags && data == ATKBD_RET_ACK)
 369                 atkbd->resend = 0;
 370 #endif
 371
 372         if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
 373                 if  (ps2_handle_ack(&atkbd->ps2dev, data))
 374                         goto out;
 375
 376         if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
 377                 if  (ps2_handle_response(&atkbd->ps2dev, data))
 378                         goto out;
 379
 380         if (!atkbd->enabled)
 381                 goto out;
 382
 383         input_event(dev, EV_MSC, MSC_RAW, code);
 384
 385         if (atkbd->translated) {
 386
 387                 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
 388                         atkbd->release = code >> 7;
 389                         code &= 0x7f;
 390                 }
 391
 392                 if (!atkbd->emul)
 393                         atkbd_calculate_xl_bit(atkbd, data);
 394         }
 395
 396         switch (code) {
 397                 case ATKBD_RET_BAT:
 398                         atkbd->enabled = 0;
 399                         serio_reconnect(atkbd->ps2dev.serio);
 400                         goto out;
 401                 case ATKBD_RET_EMUL0:
 402                         atkbd->emul = 1;
 403                         goto out;
 404                 case ATKBD_RET_EMUL1:
 405                         atkbd->emul = 2;
 406                         goto out;
 407                 case ATKBD_RET_RELEASE:
 408                         atkbd->release = 1;
 409                         goto out;
 410                 case ATKBD_RET_ACK:
 411                 case ATKBD_RET_NAK:
 412                         printk(KERN_WARNING "atkbd.c: Spurious %s on %s. "
 413                                "Some program might be trying access hardware directly.\n",
 414                                data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
 415                         goto out;
 416                 case ATKBD_RET_HANGEUL:
 417                 case ATKBD_RET_HANJA:
 418                         /*
 419                          * These keys do not report release and thus need to be
 420                          * flagged properly
 421                          */
 422                         add_release_event = 1;
 423                         break;
 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 && add_release_event) {
 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         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
 812 }
 813
 814
 815 /*
 816  * atkbd_disconnect() closes and frees.
 817  */
 818
 819 static void atkbd_disconnect(struct serio *serio)
 820 {
 821         struct atkbd *atkbd = serio_get_drvdata(serio);
 822
 823         atkbd_disable(atkbd);
 824
 825         /* make sure we don't have a command in flight */
 826         synchronize_sched();  /* Allow atkbd_interrupt()s to complete. */
 827         flush_scheduled_work();
 828
 829         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 830         input_unregister_device(atkbd->dev);
 831         serio_close(serio);
 832         serio_set_drvdata(serio, NULL);
 833         kfree(atkbd);
 834 }
 835
 836
 837 /*
 838  * atkbd_set_keycode_table() initializes keyboard's keycode table
 839  * according to the selected scancode set
 840  */
 841
 842 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 843 {
 844         int i, j;
 845
 846         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 847
 848         if (atkbd->translated) {
 849                 for (i = 0; i < 128; i++) {
 850                         atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
 851                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
 852                         if (atkbd->scroll)
 853                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 854                                         if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
 855                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 856                 }
 857         } else if (atkbd->set == 3) {
 858                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 859         } else {
 860                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 861
 862                 if (atkbd->scroll)
 863                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
 864                                 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
 865         }
 866
 867         atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL)] = KEY_HANGUEL;
 868         atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA)] = KEY_HANJA;
 869 }
 870
 871 /*
 872  * atkbd_set_device_attrs() sets up keyboard's input device structure
 873  */
 874
 875 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 876 {
 877         struct input_dev *input_dev = atkbd->dev;
 878         int i;
 879
 880         if (atkbd->extra)
 881                 snprintf(atkbd->name, sizeof(atkbd->name),
 882                          "AT Set 2 Extra keyboard");
 883         else
 884                 snprintf(atkbd->name, sizeof(atkbd->name),
 885                          "AT %s Set %d keyboard",
 886                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
 887
 888         snprintf(atkbd->phys, sizeof(atkbd->phys),
 889                  "%s/input0", atkbd->ps2dev.serio->phys);
 890
 891         input_dev->name = atkbd->name;
 892         input_dev->phys = atkbd->phys;
 893         input_dev->id.bustype = BUS_I8042;
 894         input_dev->id.vendor = 0x0001;
 895         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
 896         input_dev->id.version = atkbd->id;
 897         input_dev->event = atkbd_event;
 898         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
 899
 900         input_set_drvdata(input_dev, atkbd);
 901
 902         input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
 903
 904         if (atkbd->write) {
 905                 input_dev->evbit[0] |= BIT(EV_LED);
 906                 input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
 907         }
 908
 909         if (atkbd->extra)
 910                 input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
 911                                         BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
 912
 913         if (!atkbd->softrepeat) {
 914                 input_dev->rep[REP_DELAY] = 250;
 915                 input_dev->rep[REP_PERIOD] = 33;
 916         }
 917
 918         input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
 919
 920         if (atkbd->scroll) {
 921                 input_dev->evbit[0] |= BIT(EV_REL);
 922                 input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);
 923                 set_bit(BTN_MIDDLE, input_dev->keybit);
 924         }
 925
 926         input_dev->keycode = atkbd->keycode;
 927         input_dev->keycodesize = sizeof(unsigned char);
 928         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 929
 930         for (i = 0; i < 512; i++)
 931                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
 932                         set_bit(atkbd->keycode[i], input_dev->keybit);
 933 }
 934
 935 /*
 936  * atkbd_connect() is called when the serio module finds an interface
 937  * that isn't handled yet by an appropriate device driver. We check if
 938  * there is an AT keyboard out there and if yes, we register ourselves
 939  * to the input module.
 940  */
 941
 942 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
 943 {
 944         struct atkbd *atkbd;
 945         struct input_dev *dev;
 946         int err = -ENOMEM;
 947
 948         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
 949         dev = input_allocate_device();
 950         if (!atkbd || !dev)
 951                 goto fail1;
 952
 953         atkbd->dev = dev;
 954         ps2_init(&atkbd->ps2dev, serio);
 955         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
 956         mutex_init(&atkbd->event_mutex);
 957
 958         switch (serio->id.type) {
 959
 960                 case SERIO_8042_XL:
 961                         atkbd->translated = 1;
 962                 case SERIO_8042:
 963                         if (serio->write)
 964                                 atkbd->write = 1;
 965                         break;
 966         }
 967
 968         atkbd->softraw = atkbd_softraw;
 969         atkbd->softrepeat = atkbd_softrepeat;
 970         atkbd->scroll = atkbd_scroll;
 971
 972         if (atkbd->softrepeat)
 973                 atkbd->softraw = 1;
 974
 975         serio_set_drvdata(serio, atkbd);
 976
 977         err = serio_open(serio, drv);
 978         if (err)
 979                 goto fail2;
 980
 981         if (atkbd->write) {
 982
 983                 if (atkbd_probe(atkbd)) {
 984                         err = -ENODEV;
 985                         goto fail3;
 986                 }
 987
 988                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
 989                 atkbd_activate(atkbd);
 990
 991         } else {
 992                 atkbd->set = 2;
 993                 atkbd->id = 0xab00;
 994         }
 995
 996         atkbd_set_keycode_table(atkbd);
 997         atkbd_set_device_attrs(atkbd);
 998
 999         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1000         if (err)
1001                 goto fail3;
1002
1003         atkbd_enable(atkbd);
1004
1005         err = input_register_device(atkbd->dev);
1006         if (err)
1007                 goto fail4;
1008
1009         return 0;
1010
1011  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1012  fail3: serio_close(serio);
1013  fail2: serio_set_drvdata(serio, NULL);
1014  fail1: input_free_device(dev);
1015         kfree(atkbd);
1016         return err;
1017 }
1018
1019 /*
1020  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1021  * most likely called on resume.
1022  */
1023
1024 static int atkbd_reconnect(struct serio *serio)
1025 {
1026         struct atkbd *atkbd = serio_get_drvdata(serio);
1027         struct serio_driver *drv = serio->drv;
1028
1029         if (!atkbd || !drv) {
1030                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1031                 return -1;
1032         }
1033
1034         atkbd_disable(atkbd);
1035
1036         if (atkbd->write) {
1037                 if (atkbd_probe(atkbd))
1038                         return -1;
1039                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1040                         return -1;
1041
1042                 atkbd_activate(atkbd);
1043
1044 /*
1045  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1046  * to pre-resume state
1047  */
1048                 if (!atkbd->softrepeat)
1049                         atkbd_set_repeat_rate(atkbd);
1050                 atkbd_set_leds(atkbd);
1051         }
1052
1053         atkbd_enable(atkbd);
1054
1055         return 0;
1056 }
1057
1058 static struct serio_device_id atkbd_serio_ids[] = {
1059         {
1060                 .type   = SERIO_8042,
1061                 .proto  = SERIO_ANY,
1062                 .id     = SERIO_ANY,
1063                 .extra  = SERIO_ANY,
1064         },
1065         {
1066                 .type   = SERIO_8042_XL,
1067                 .proto  = SERIO_ANY,
1068                 .id     = SERIO_ANY,
1069                 .extra  = SERIO_ANY,
1070         },
1071         {
1072                 .type   = SERIO_RS232,
1073                 .proto  = SERIO_PS2SER,
1074                 .id     = SERIO_ANY,
1075                 .extra  = SERIO_ANY,
1076         },
1077         { 0 }
1078 };
1079
1080 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1081
1082 static struct serio_driver atkbd_drv = {
1083         .driver         = {
1084                 .name   = "atkbd",
1085         },
1086         .description    = DRIVER_DESC,
1087         .id_table       = atkbd_serio_ids,
1088         .interrupt      = atkbd_interrupt,
1089         .connect        = atkbd_connect,
1090         .reconnect      = atkbd_reconnect,
1091         .disconnect     = atkbd_disconnect,
1092         .cleanup        = atkbd_cleanup,
1093 };
1094
1095 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1096                                 ssize_t (*handler)(struct atkbd *, char *))
1097 {
1098         struct serio *serio = to_serio_port(dev);
1099         int retval;
1100
1101         retval = serio_pin_driver(serio);
1102         if (retval)
1103                 return retval;
1104
1105         if (serio->drv != &atkbd_drv) {
1106                 retval = -ENODEV;
1107                 goto out;
1108         }
1109
1110         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1111
1112 out:
1113         serio_unpin_driver(serio);
1114         return retval;
1115 }
1116
1117 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1118                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1119 {
1120         struct serio *serio = to_serio_port(dev);
1121         struct atkbd *atkbd;
1122         int retval;
1123
1124         retval = serio_pin_driver(serio);
1125         if (retval)
1126                 return retval;
1127
1128         if (serio->drv != &atkbd_drv) {
1129                 retval = -ENODEV;
1130                 goto out;
1131         }
1132
1133         atkbd = serio_get_drvdata(serio);
1134         atkbd_disable(atkbd);
1135         retval = handler(atkbd, buf, count);
1136         atkbd_enable(atkbd);
1137
1138 out:
1139         serio_unpin_driver(serio);
1140         return retval;
1141 }
1142
1143 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1144 {
1145         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1146 }
1147
1148 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1149 {
1150         struct input_dev *old_dev, *new_dev;
1151         unsigned long value;
1152         char *rest;
1153         int err;
1154         unsigned char old_extra, old_set;
1155
1156         if (!atkbd->write)
1157                 return -EIO;
1158
1159         value = simple_strtoul(buf, &rest, 10);
1160         if (*rest || value > 1)
1161                 return -EINVAL;
1162
1163         if (atkbd->extra != value) {
1164                 /*
1165                  * Since device's properties will change we need to
1166                  * unregister old device. But allocate and register
1167                  * new one first to make sure we have it.
1168                  */
1169                 old_dev = atkbd->dev;
1170                 old_extra = atkbd->extra;
1171                 old_set = atkbd->set;
1172
1173                 new_dev = input_allocate_device();
1174                 if (!new_dev)
1175                         return -ENOMEM;
1176
1177                 atkbd->dev = new_dev;
1178                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1179                 atkbd_activate(atkbd);
1180                 atkbd_set_keycode_table(atkbd);
1181                 atkbd_set_device_attrs(atkbd);
1182
1183                 err = input_register_device(atkbd->dev);
1184                 if (err) {
1185                         input_free_device(new_dev);
1186
1187                         atkbd->dev = old_dev;
1188                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1189                         atkbd_set_keycode_table(atkbd);
1190                         atkbd_set_device_attrs(atkbd);
1191
1192                         return err;
1193                 }
1194                 input_unregister_device(old_dev);
1195
1196         }
1197         return count;
1198 }
1199
1200 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1201 {
1202         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1203 }
1204
1205 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1206 {
1207         struct input_dev *old_dev, *new_dev;
1208         unsigned long value;
1209         char *rest;
1210         int err;
1211         unsigned char old_scroll;
1212
1213         value = simple_strtoul(buf, &rest, 10);
1214         if (*rest || value > 1)
1215                 return -EINVAL;
1216
1217         if (atkbd->scroll != value) {
1218                 old_dev = atkbd->dev;
1219                 old_scroll = atkbd->scroll;
1220
1221                 new_dev = input_allocate_device();
1222                 if (!new_dev)
1223                         return -ENOMEM;
1224
1225                 atkbd->dev = new_dev;
1226                 atkbd->scroll = value;
1227                 atkbd_set_keycode_table(atkbd);
1228                 atkbd_set_device_attrs(atkbd);
1229
1230                 err = input_register_device(atkbd->dev);
1231                 if (err) {
1232                         input_free_device(new_dev);
1233
1234                         atkbd->scroll = old_scroll;
1235                         atkbd->dev = old_dev;
1236                         atkbd_set_keycode_table(atkbd);
1237                         atkbd_set_device_attrs(atkbd);
1238
1239                         return err;
1240                 }
1241                 input_unregister_device(old_dev);
1242         }
1243         return count;
1244 }
1245
1246 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1247 {
1248         return sprintf(buf, "%d\n", atkbd->set);
1249 }
1250
1251 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1252 {
1253         struct input_dev *old_dev, *new_dev;
1254         unsigned long value;
1255         char *rest;
1256         int err;
1257         unsigned char old_set, old_extra;
1258
1259         if (!atkbd->write)
1260                 return -EIO;
1261
1262         value = simple_strtoul(buf, &rest, 10);
1263         if (*rest || (value != 2 && value != 3))
1264                 return -EINVAL;
1265
1266         if (atkbd->set != value) {
1267                 old_dev = atkbd->dev;
1268                 old_extra = atkbd->extra;
1269                 old_set = atkbd->set;
1270
1271                 new_dev = input_allocate_device();
1272                 if (!new_dev)
1273                         return -ENOMEM;
1274
1275                 atkbd->dev = new_dev;
1276                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1277                 atkbd_activate(atkbd);
1278                 atkbd_set_keycode_table(atkbd);
1279                 atkbd_set_device_attrs(atkbd);
1280
1281                 err = input_register_device(atkbd->dev);
1282                 if (err) {
1283                         input_free_device(new_dev);
1284
1285                         atkbd->dev = old_dev;
1286                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1287                         atkbd_set_keycode_table(atkbd);
1288                         atkbd_set_device_attrs(atkbd);
1289
1290                         return err;
1291                 }
1292                 input_unregister_device(old_dev);
1293         }
1294         return count;
1295 }
1296
1297 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1298 {
1299         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1300 }
1301
1302 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1303 {
1304         struct input_dev *old_dev, *new_dev;
1305         unsigned long value;
1306         char *rest;
1307         int err;
1308         unsigned char old_softrepeat, old_softraw;
1309
1310         if (!atkbd->write)
1311                 return -EIO;
1312
1313         value = simple_strtoul(buf, &rest, 10);
1314         if (*rest || value > 1)
1315                 return -EINVAL;
1316
1317         if (atkbd->softrepeat != value) {
1318                 old_dev = atkbd->dev;
1319                 old_softrepeat = atkbd->softrepeat;
1320                 old_softraw = atkbd->softraw;
1321
1322                 new_dev = input_allocate_device();
1323                 if (!new_dev)
1324                         return -ENOMEM;
1325
1326                 atkbd->dev = new_dev;
1327                 atkbd->softrepeat = value;
1328                 if (atkbd->softrepeat)
1329                         atkbd->softraw = 1;
1330                 atkbd_set_device_attrs(atkbd);
1331
1332                 err = input_register_device(atkbd->dev);
1333                 if (err) {
1334                         input_free_device(new_dev);
1335
1336                         atkbd->dev = old_dev;
1337                         atkbd->softrepeat = old_softrepeat;
1338                         atkbd->softraw = old_softraw;
1339                         atkbd_set_device_attrs(atkbd);
1340
1341                         return err;
1342                 }
1343                 input_unregister_device(old_dev);
1344         }
1345         return count;
1346 }
1347
1348
1349 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1350 {
1351         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1352 }
1353
1354 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1355 {
1356         struct input_dev *old_dev, *new_dev;
1357         unsigned long value;
1358         char *rest;
1359         int err;
1360         unsigned char old_softraw;
1361
1362         value = simple_strtoul(buf, &rest, 10);
1363         if (*rest || value > 1)
1364                 return -EINVAL;
1365
1366         if (atkbd->softraw != value) {
1367                 old_dev = atkbd->dev;
1368                 old_softraw = atkbd->softraw;
1369
1370                 new_dev = input_allocate_device();
1371                 if (!new_dev)
1372                         return -ENOMEM;
1373
1374                 atkbd->dev = new_dev;
1375                 atkbd->softraw = value;
1376                 atkbd_set_device_attrs(atkbd);
1377
1378                 err = input_register_device(atkbd->dev);
1379                 if (err) {
1380                         input_free_device(new_dev);
1381
1382                         atkbd->dev = old_dev;
1383                         atkbd->softraw = old_softraw;
1384                         atkbd_set_device_attrs(atkbd);
1385
1386                         return err;
1387                 }
1388                 input_unregister_device(old_dev);
1389         }
1390         return count;
1391 }
1392
1393 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1394 {
1395         return sprintf(buf, "%lu\n", atkbd->err_count);
1396 }
1397
1398
1399 static int __init atkbd_init(void)
1400 {
1401         return serio_register_driver(&atkbd_drv);
1402 }
1403
1404 static void __exit atkbd_exit(void)
1405 {
1406         serio_unregister_driver(&atkbd_drv);
1407 }
1408
1409 module_init(atkbd_init);
1410 module_exit(atkbd_exit);