git.oblomov.eu 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,172,166,  0,  0,  0,142,
  93         157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
  94         226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
  95           0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
  96         110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
  97
  98           0,  0,  0, 65, 99,
  99 #endif
 100 };
 101
 102 static 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,172,163,165,115,152,172,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                         if (printk_ratelimit())
 413                                 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. "
 414                                        "Some program might be trying access hardware directly.\n",
 415                                        data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
 416                         goto out;
 417                 case ATKBD_RET_HANGEUL:
 418                 case ATKBD_RET_HANJA:
 419                         /*
 420                          * These keys do not report release and thus need to be
 421                          * flagged properly
 422                          */
 423                         add_release_event = 1;
 424                         break;
 425                 case ATKBD_RET_ERR:
 426                         atkbd->err_count++;
 427 #ifdef ATKBD_DEBUG
 428                         printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
 429 #endif
 430                         goto out;
 431         }
 432
 433         code = atkbd_compat_scancode(atkbd, code);
 434
 435         if (atkbd->emul && --atkbd->emul)
 436                 goto out;
 437
 438         keycode = atkbd->keycode[code];
 439
 440         if (keycode != ATKBD_KEY_NULL)
 441                 input_event(dev, EV_MSC, MSC_SCAN, code);
 442
 443         switch (keycode) {
 444                 case ATKBD_KEY_NULL:
 445                         break;
 446                 case ATKBD_KEY_UNKNOWN:
 447                         printk(KERN_WARNING
 448                                "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n",
 449                                atkbd->release ? "released" : "pressed",
 450                                atkbd->translated ? "translated" : "raw",
 451                                atkbd->set, code, serio->phys);
 452                         printk(KERN_WARNING
 453                                "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
 454                                code & 0x80 ? "e0" : "", code & 0x7f);
 455                         input_sync(dev);
 456                         break;
 457                 case ATKBD_SCR_1:
 458                         scroll = 1 - atkbd->release * 2;
 459                         break;
 460                 case ATKBD_SCR_2:
 461                         scroll = 2 - atkbd->release * 4;
 462                         break;
 463                 case ATKBD_SCR_4:
 464                         scroll = 4 - atkbd->release * 8;
 465                         break;
 466                 case ATKBD_SCR_8:
 467                         scroll = 8 - atkbd->release * 16;
 468                         break;
 469                 case ATKBD_SCR_CLICK:
 470                         click = !atkbd->release;
 471                         break;
 472                 case ATKBD_SCR_LEFT:
 473                         hscroll = -1;
 474                         break;
 475                 case ATKBD_SCR_RIGHT:
 476                         hscroll = 1;
 477                         break;
 478                 default:
 479                         if (atkbd->release) {
 480                                 value = 0;
 481                                 atkbd->last = 0;
 482                         } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
 483                                 /* Workaround Toshiba laptop multiple keypress */
 484                                 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
 485                         } else {
 486                                 value = 1;
 487                                 atkbd->last = code;
 488                                 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
 489                         }
 490
 491                         input_event(dev, EV_KEY, keycode, value);
 492                         input_sync(dev);
 493
 494                         if (value && add_release_event) {
 495                                 input_report_key(dev, keycode, 0);
 496                                 input_sync(dev);
 497                         }
 498         }
 499
 500         if (atkbd->scroll) {
 501                 if (click != -1)
 502                         input_report_key(dev, BTN_MIDDLE, click);
 503                 input_report_rel(dev, REL_WHEEL, scroll);
 504                 input_report_rel(dev, REL_HWHEEL, hscroll);
 505                 input_sync(dev);
 506         }
 507
 508         atkbd->release = 0;
 509 out:
 510         return IRQ_HANDLED;
 511 }
 512
 513 static int atkbd_set_repeat_rate(struct atkbd *atkbd)
 514 {
 515         const short period[32] =
 516                 { 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
 517                  133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
 518         const short delay[4] =
 519                 { 250, 500, 750, 1000 };
 520
 521         struct input_dev *dev = atkbd->dev;
 522         unsigned char param;
 523         int i = 0, j = 0;
 524
 525         while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
 526                 i++;
 527         dev->rep[REP_PERIOD] = period[i];
 528
 529         while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
 530                 j++;
 531         dev->rep[REP_DELAY] = delay[j];
 532
 533         param = i | (j << 5);
 534         return ps2_command(&atkbd->ps2dev, &param, ATKBD_CMD_SETREP);
 535 }
 536
 537 static int atkbd_set_leds(struct atkbd *atkbd)
 538 {
 539         struct input_dev *dev = atkbd->dev;
 540         unsigned char param[2];
 541
 542         param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
 543                  | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
 544                  | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
 545         if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
 546                 return -1;
 547
 548         if (atkbd->extra) {
 549                 param[0] = 0;
 550                 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
 551                          | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
 552                          | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
 553                          | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
 554                          | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
 555                 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
 556                         return -1;
 557         }
 558
 559         return 0;
 560 }
 561
 562 /*
 563  * atkbd_event_work() is used to complete processing of events that
 564  * can not be processed by input_event() which is often called from
 565  * interrupt context.
 566  */
 567
 568 static void atkbd_event_work(struct work_struct *work)
 569 {
 570         struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
 571
 572         mutex_lock(&atkbd->event_mutex);
 573
 574         if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
 575                 atkbd_set_leds(atkbd);
 576
 577         if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
 578                 atkbd_set_repeat_rate(atkbd);
 579
 580         mutex_unlock(&atkbd->event_mutex);
 581 }
 582
 583 /*
 584  * Schedule switch for execution. We need to throttle requests,
 585  * otherwise keyboard may become unresponsive.
 586  */
 587 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
 588 {
 589         unsigned long delay = msecs_to_jiffies(50);
 590
 591         if (time_after(jiffies, atkbd->event_jiffies + delay))
 592                 delay = 0;
 593
 594         atkbd->event_jiffies = jiffies;
 595         set_bit(event_bit, &atkbd->event_mask);
 596         wmb();
 597         schedule_delayed_work(&atkbd->event_work, delay);
 598 }
 599
 600 /*
 601  * Event callback from the input module. Events that change the state of
 602  * the hardware are processed here. If action can not be performed in
 603  * interrupt context it is offloaded to atkbd_event_work.
 604  */
 605
 606 static int atkbd_event(struct input_dev *dev,
 607                         unsigned int type, unsigned int code, int value)
 608 {
 609         struct atkbd *atkbd = input_get_drvdata(dev);
 610
 611         if (!atkbd->write)
 612                 return -1;
 613
 614         switch (type) {
 615
 616                 case EV_LED:
 617                         atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
 618                         return 0;
 619
 620                 case EV_REP:
 621                         if (!atkbd->softrepeat)
 622                                 atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
 623                         return 0;
 624         }
 625
 626         return -1;
 627 }
 628
 629 /*
 630  * atkbd_enable() signals that interrupt handler is allowed to
 631  * generate input events.
 632  */
 633
 634 static inline void atkbd_enable(struct atkbd *atkbd)
 635 {
 636         serio_pause_rx(atkbd->ps2dev.serio);
 637         atkbd->enabled = 1;
 638         serio_continue_rx(atkbd->ps2dev.serio);
 639 }
 640
 641 /*
 642  * atkbd_disable() tells input handler that all incoming data except
 643  * for ACKs and command response should be dropped.
 644  */
 645
 646 static inline void atkbd_disable(struct atkbd *atkbd)
 647 {
 648         serio_pause_rx(atkbd->ps2dev.serio);
 649         atkbd->enabled = 0;
 650         serio_continue_rx(atkbd->ps2dev.serio);
 651 }
 652
 653 /*
 654  * atkbd_probe() probes for an AT keyboard on a serio port.
 655  */
 656
 657 static int atkbd_probe(struct atkbd *atkbd)
 658 {
 659         struct ps2dev *ps2dev = &atkbd->ps2dev;
 660         unsigned char param[2];
 661
 662 /*
 663  * Some systems, where the bit-twiddling when testing the io-lines of the
 664  * controller may confuse the keyboard need a full reset of the keyboard. On
 665  * these systems the BIOS also usually doesn't do it for us.
 666  */
 667
 668         if (atkbd_reset)
 669                 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
 670                         printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
 671
 672 /*
 673  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
 674  * Some keyboards report different values, but the first byte is always 0xab or
 675  * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
 676  * should make sure we don't try to set the LEDs on it.
 677  */
 678
 679         param[0] = param[1] = 0xa5;     /* initialize with invalid values */
 680         if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
 681
 682 /*
 683  * If the get ID command failed, we check if we can at least set the LEDs on
 684  * the keyboard. This should work on every keyboard out there. It also turns
 685  * the LEDs off, which we want anyway.
 686  */
 687                 param[0] = 0;
 688                 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 689                         return -1;
 690                 atkbd->id = 0xabba;
 691                 return 0;
 692         }
 693
 694         if (!ps2_is_keyboard_id(param[0]))
 695                 return -1;
 696
 697         atkbd->id = (param[0] << 8) | param[1];
 698
 699         if (atkbd->id == 0xaca1 && atkbd->translated) {
 700                 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
 701                 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
 702                 return -1;
 703         }
 704
 705         return 0;
 706 }
 707
 708 /*
 709  * atkbd_select_set checks if a keyboard has a working Set 3 support, and
 710  * sets it into that. Unfortunately there are keyboards that can be switched
 711  * to Set 3, but don't work well in that (BTC Multimedia ...)
 712  */
 713
 714 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
 715 {
 716         struct ps2dev *ps2dev = &atkbd->ps2dev;
 717         unsigned char param[2];
 718
 719         atkbd->extra = 0;
 720 /*
 721  * For known special keyboards we can go ahead and set the correct set.
 722  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
 723  * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
 724  */
 725
 726         if (atkbd->translated)
 727                 return 2;
 728
 729         if (atkbd->id == 0xaca1) {
 730                 param[0] = 3;
 731                 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
 732                 return 3;
 733         }
 734
 735         if (allow_extra) {
 736                 param[0] = 0x71;
 737                 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
 738                         atkbd->extra = 1;
 739                         return 2;
 740                 }
 741         }
 742
 743         if (target_set != 3)
 744                 return 2;
 745
 746         if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
 747                 atkbd->id = param[0] << 8 | param[1];
 748                 return 2;
 749         }
 750
 751         param[0] = 3;
 752         if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 753                 return 2;
 754
 755         param[0] = 0;
 756         if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
 757                 return 2;
 758
 759         if (param[0] != 3) {
 760                 param[0] = 2;
 761                 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 762                 return 2;
 763         }
 764
 765         ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
 766
 767         return 3;
 768 }
 769
 770 static int atkbd_activate(struct atkbd *atkbd)
 771 {
 772         struct ps2dev *ps2dev = &atkbd->ps2dev;
 773         unsigned char param[1];
 774
 775 /*
 776  * Set the LEDs to a defined state.
 777  */
 778
 779         param[0] = 0;
 780         if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 781                 return -1;
 782
 783 /*
 784  * Set autorepeat to fastest possible.
 785  */
 786
 787         param[0] = 0;
 788         if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
 789                 return -1;
 790
 791 /*
 792  * Enable the keyboard to receive keystrokes.
 793  */
 794
 795         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 796                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
 797                         ps2dev->serio->phys);
 798                 return -1;
 799         }
 800
 801         return 0;
 802 }
 803
 804 /*
 805  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 806  * reboot.
 807  */
 808
 809 static void atkbd_cleanup(struct serio *serio)
 810 {
 811         struct atkbd *atkbd = serio_get_drvdata(serio);
 812         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
 813 }
 814
 815
 816 /*
 817  * atkbd_disconnect() closes and frees.
 818  */
 819
 820 static void atkbd_disconnect(struct serio *serio)
 821 {
 822         struct atkbd *atkbd = serio_get_drvdata(serio);
 823
 824         atkbd_disable(atkbd);
 825
 826         /* make sure we don't have a command in flight */
 827         synchronize_sched();  /* Allow atkbd_interrupt()s to complete. */
 828         flush_scheduled_work();
 829
 830         sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 831         input_unregister_device(atkbd->dev);
 832         serio_close(serio);
 833         serio_set_drvdata(serio, NULL);
 834         kfree(atkbd);
 835 }
 836
 837
 838 /*
 839  * atkbd_set_keycode_table() initializes keyboard's keycode table
 840  * according to the selected scancode set
 841  */
 842
 843 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 844 {
 845         int i, j;
 846
 847         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 848
 849         if (atkbd->translated) {
 850                 for (i = 0; i < 128; i++) {
 851                         atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
 852                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
 853                         if (atkbd->scroll)
 854                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 855                                         if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
 856                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 857                 }
 858         } else if (atkbd->set == 3) {
 859                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 860         } else {
 861                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 862
 863                 if (atkbd->scroll)
 864                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
 865                                 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
 866         }
 867
 868         atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL)] = KEY_HANGUEL;
 869         atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA)] = KEY_HANJA;
 870 }
 871
 872 /*
 873  * atkbd_set_device_attrs() sets up keyboard's input device structure
 874  */
 875
 876 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 877 {
 878         struct input_dev *input_dev = atkbd->dev;
 879         int i;
 880
 881         if (atkbd->extra)
 882                 snprintf(atkbd->name, sizeof(atkbd->name),
 883                          "AT Set 2 Extra keyboard");
 884         else
 885                 snprintf(atkbd->name, sizeof(atkbd->name),
 886                          "AT %s Set %d keyboard",
 887                          atkbd->translated ? "Translated" : "Raw", atkbd->set);
 888
 889         snprintf(atkbd->phys, sizeof(atkbd->phys),
 890                  "%s/input0", atkbd->ps2dev.serio->phys);
 891
 892         input_dev->name = atkbd->name;
 893         input_dev->phys = atkbd->phys;
 894         input_dev->id.bustype = BUS_I8042;
 895         input_dev->id.vendor = 0x0001;
 896         input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
 897         input_dev->id.version = atkbd->id;
 898         input_dev->event = atkbd_event;
 899         input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
 900
 901         input_set_drvdata(input_dev, atkbd);
 902
 903         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
 904                 BIT_MASK(EV_MSC);
 905
 906         if (atkbd->write) {
 907                 input_dev->evbit[0] |= BIT_MASK(EV_LED);
 908                 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
 909                         BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
 910         }
 911
 912         if (atkbd->extra)
 913                 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
 914                         BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
 915                         BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
 916
 917         if (!atkbd->softrepeat) {
 918                 input_dev->rep[REP_DELAY] = 250;
 919                 input_dev->rep[REP_PERIOD] = 33;
 920         }
 921
 922         input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
 923                 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
 924
 925         if (atkbd->scroll) {
 926                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
 927                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
 928                         BIT_MASK(REL_HWHEEL);
 929                 set_bit(BTN_MIDDLE, input_dev->keybit);
 930         }
 931
 932         input_dev->keycode = atkbd->keycode;
 933         input_dev->keycodesize = sizeof(unsigned char);
 934         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 935
 936         for (i = 0; i < 512; i++)
 937                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
 938                         set_bit(atkbd->keycode[i], input_dev->keybit);
 939 }
 940
 941 /*
 942  * atkbd_connect() is called when the serio module finds an interface
 943  * that isn't handled yet by an appropriate device driver. We check if
 944  * there is an AT keyboard out there and if yes, we register ourselves
 945  * to the input module.
 946  */
 947
 948 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
 949 {
 950         struct atkbd *atkbd;
 951         struct input_dev *dev;
 952         int err = -ENOMEM;
 953
 954         atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
 955         dev = input_allocate_device();
 956         if (!atkbd || !dev)
 957                 goto fail1;
 958
 959         atkbd->dev = dev;
 960         ps2_init(&atkbd->ps2dev, serio);
 961         INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
 962         mutex_init(&atkbd->event_mutex);
 963
 964         switch (serio->id.type) {
 965
 966                 case SERIO_8042_XL:
 967                         atkbd->translated = 1;
 968                 case SERIO_8042:
 969                         if (serio->write)
 970                                 atkbd->write = 1;
 971                         break;
 972         }
 973
 974         atkbd->softraw = atkbd_softraw;
 975         atkbd->softrepeat = atkbd_softrepeat;
 976         atkbd->scroll = atkbd_scroll;
 977
 978         if (atkbd->softrepeat)
 979                 atkbd->softraw = 1;
 980
 981         serio_set_drvdata(serio, atkbd);
 982
 983         err = serio_open(serio, drv);
 984         if (err)
 985                 goto fail2;
 986
 987         if (atkbd->write) {
 988
 989                 if (atkbd_probe(atkbd)) {
 990                         err = -ENODEV;
 991                         goto fail3;
 992                 }
 993
 994                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
 995                 atkbd_activate(atkbd);
 996
 997         } else {
 998                 atkbd->set = 2;
 999                 atkbd->id = 0xab00;
1000         }
1001
1002         atkbd_set_keycode_table(atkbd);
1003         atkbd_set_device_attrs(atkbd);
1004
1005         err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1006         if (err)
1007                 goto fail3;
1008
1009         atkbd_enable(atkbd);
1010
1011         err = input_register_device(atkbd->dev);
1012         if (err)
1013                 goto fail4;
1014
1015         return 0;
1016
1017  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1018  fail3: serio_close(serio);
1019  fail2: serio_set_drvdata(serio, NULL);
1020  fail1: input_free_device(dev);
1021         kfree(atkbd);
1022         return err;
1023 }
1024
1025 /*
1026  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1027  * most likely called on resume.
1028  */
1029
1030 static int atkbd_reconnect(struct serio *serio)
1031 {
1032         struct atkbd *atkbd = serio_get_drvdata(serio);
1033         struct serio_driver *drv = serio->drv;
1034
1035         if (!atkbd || !drv) {
1036                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1037                 return -1;
1038         }
1039
1040         atkbd_disable(atkbd);
1041
1042         if (atkbd->write) {
1043                 if (atkbd_probe(atkbd))
1044                         return -1;
1045                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1046                         return -1;
1047
1048                 atkbd_activate(atkbd);
1049
1050 /*
1051  * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1052  * to pre-resume state
1053  */
1054                 if (!atkbd->softrepeat)
1055                         atkbd_set_repeat_rate(atkbd);
1056                 atkbd_set_leds(atkbd);
1057         }
1058
1059         atkbd_enable(atkbd);
1060
1061         return 0;
1062 }
1063
1064 static struct serio_device_id atkbd_serio_ids[] = {
1065         {
1066                 .type   = SERIO_8042,
1067                 .proto  = SERIO_ANY,
1068                 .id     = SERIO_ANY,
1069                 .extra  = SERIO_ANY,
1070         },
1071         {
1072                 .type   = SERIO_8042_XL,
1073                 .proto  = SERIO_ANY,
1074                 .id     = SERIO_ANY,
1075                 .extra  = SERIO_ANY,
1076         },
1077         {
1078                 .type   = SERIO_RS232,
1079                 .proto  = SERIO_PS2SER,
1080                 .id     = SERIO_ANY,
1081                 .extra  = SERIO_ANY,
1082         },
1083         { 0 }
1084 };
1085
1086 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1087
1088 static struct serio_driver atkbd_drv = {
1089         .driver         = {
1090                 .name   = "atkbd",
1091         },
1092         .description    = DRIVER_DESC,
1093         .id_table       = atkbd_serio_ids,
1094         .interrupt      = atkbd_interrupt,
1095         .connect        = atkbd_connect,
1096         .reconnect      = atkbd_reconnect,
1097         .disconnect     = atkbd_disconnect,
1098         .cleanup        = atkbd_cleanup,
1099 };
1100
1101 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1102                                 ssize_t (*handler)(struct atkbd *, char *))
1103 {
1104         struct serio *serio = to_serio_port(dev);
1105         int retval;
1106
1107         retval = serio_pin_driver(serio);
1108         if (retval)
1109                 return retval;
1110
1111         if (serio->drv != &atkbd_drv) {
1112                 retval = -ENODEV;
1113                 goto out;
1114         }
1115
1116         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1117
1118 out:
1119         serio_unpin_driver(serio);
1120         return retval;
1121 }
1122
1123 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1124                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1125 {
1126         struct serio *serio = to_serio_port(dev);
1127         struct atkbd *atkbd;
1128         int retval;
1129
1130         retval = serio_pin_driver(serio);
1131         if (retval)
1132                 return retval;
1133
1134         if (serio->drv != &atkbd_drv) {
1135                 retval = -ENODEV;
1136                 goto out;
1137         }
1138
1139         atkbd = serio_get_drvdata(serio);
1140         atkbd_disable(atkbd);
1141         retval = handler(atkbd, buf, count);
1142         atkbd_enable(atkbd);
1143
1144 out:
1145         serio_unpin_driver(serio);
1146         return retval;
1147 }
1148
1149 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1150 {
1151         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1152 }
1153
1154 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1155 {
1156         struct input_dev *old_dev, *new_dev;
1157         unsigned long value;
1158         char *rest;
1159         int err;
1160         unsigned char old_extra, old_set;
1161
1162         if (!atkbd->write)
1163                 return -EIO;
1164
1165         value = simple_strtoul(buf, &rest, 10);
1166         if (*rest || value > 1)
1167                 return -EINVAL;
1168
1169         if (atkbd->extra != value) {
1170                 /*
1171                  * Since device's properties will change we need to
1172                  * unregister old device. But allocate and register
1173                  * new one first to make sure we have it.
1174                  */
1175                 old_dev = atkbd->dev;
1176                 old_extra = atkbd->extra;
1177                 old_set = atkbd->set;
1178
1179                 new_dev = input_allocate_device();
1180                 if (!new_dev)
1181                         return -ENOMEM;
1182
1183                 atkbd->dev = new_dev;
1184                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1185                 atkbd_activate(atkbd);
1186                 atkbd_set_keycode_table(atkbd);
1187                 atkbd_set_device_attrs(atkbd);
1188
1189                 err = input_register_device(atkbd->dev);
1190                 if (err) {
1191                         input_free_device(new_dev);
1192
1193                         atkbd->dev = old_dev;
1194                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1195                         atkbd_set_keycode_table(atkbd);
1196                         atkbd_set_device_attrs(atkbd);
1197
1198                         return err;
1199                 }
1200                 input_unregister_device(old_dev);
1201
1202         }
1203         return count;
1204 }
1205
1206 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1207 {
1208         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1209 }
1210
1211 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1212 {
1213         struct input_dev *old_dev, *new_dev;
1214         unsigned long value;
1215         char *rest;
1216         int err;
1217         unsigned char old_scroll;
1218
1219         value = simple_strtoul(buf, &rest, 10);
1220         if (*rest || value > 1)
1221                 return -EINVAL;
1222
1223         if (atkbd->scroll != value) {
1224                 old_dev = atkbd->dev;
1225                 old_scroll = atkbd->scroll;
1226
1227                 new_dev = input_allocate_device();
1228                 if (!new_dev)
1229                         return -ENOMEM;
1230
1231                 atkbd->dev = new_dev;
1232                 atkbd->scroll = value;
1233                 atkbd_set_keycode_table(atkbd);
1234                 atkbd_set_device_attrs(atkbd);
1235
1236                 err = input_register_device(atkbd->dev);
1237                 if (err) {
1238                         input_free_device(new_dev);
1239
1240                         atkbd->scroll = old_scroll;
1241                         atkbd->dev = old_dev;
1242                         atkbd_set_keycode_table(atkbd);
1243                         atkbd_set_device_attrs(atkbd);
1244
1245                         return err;
1246                 }
1247                 input_unregister_device(old_dev);
1248         }
1249         return count;
1250 }
1251
1252 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1253 {
1254         return sprintf(buf, "%d\n", atkbd->set);
1255 }
1256
1257 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1258 {
1259         struct input_dev *old_dev, *new_dev;
1260         unsigned long value;
1261         char *rest;
1262         int err;
1263         unsigned char old_set, old_extra;
1264
1265         if (!atkbd->write)
1266                 return -EIO;
1267
1268         value = simple_strtoul(buf, &rest, 10);
1269         if (*rest || (value != 2 && value != 3))
1270                 return -EINVAL;
1271
1272         if (atkbd->set != value) {
1273                 old_dev = atkbd->dev;
1274                 old_extra = atkbd->extra;
1275                 old_set = atkbd->set;
1276
1277                 new_dev = input_allocate_device();
1278                 if (!new_dev)
1279                         return -ENOMEM;
1280
1281                 atkbd->dev = new_dev;
1282                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1283                 atkbd_activate(atkbd);
1284                 atkbd_set_keycode_table(atkbd);
1285                 atkbd_set_device_attrs(atkbd);
1286
1287                 err = input_register_device(atkbd->dev);
1288                 if (err) {
1289                         input_free_device(new_dev);
1290
1291                         atkbd->dev = old_dev;
1292                         atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1293                         atkbd_set_keycode_table(atkbd);
1294                         atkbd_set_device_attrs(atkbd);
1295
1296                         return err;
1297                 }
1298                 input_unregister_device(old_dev);
1299         }
1300         return count;
1301 }
1302
1303 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1304 {
1305         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1306 }
1307
1308 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1309 {
1310         struct input_dev *old_dev, *new_dev;
1311         unsigned long value;
1312         char *rest;
1313         int err;
1314         unsigned char old_softrepeat, old_softraw;
1315
1316         if (!atkbd->write)
1317                 return -EIO;
1318
1319         value = simple_strtoul(buf, &rest, 10);
1320         if (*rest || value > 1)
1321                 return -EINVAL;
1322
1323         if (atkbd->softrepeat != value) {
1324                 old_dev = atkbd->dev;
1325                 old_softrepeat = atkbd->softrepeat;
1326                 old_softraw = atkbd->softraw;
1327
1328                 new_dev = input_allocate_device();
1329                 if (!new_dev)
1330                         return -ENOMEM;
1331
1332                 atkbd->dev = new_dev;
1333                 atkbd->softrepeat = value;
1334                 if (atkbd->softrepeat)
1335                         atkbd->softraw = 1;
1336                 atkbd_set_device_attrs(atkbd);
1337
1338                 err = input_register_device(atkbd->dev);
1339                 if (err) {
1340                         input_free_device(new_dev);
1341
1342                         atkbd->dev = old_dev;
1343                         atkbd->softrepeat = old_softrepeat;
1344                         atkbd->softraw = old_softraw;
1345                         atkbd_set_device_attrs(atkbd);
1346
1347                         return err;
1348                 }
1349                 input_unregister_device(old_dev);
1350         }
1351         return count;
1352 }
1353
1354
1355 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1356 {
1357         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1358 }
1359
1360 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1361 {
1362         struct input_dev *old_dev, *new_dev;
1363         unsigned long value;
1364         char *rest;
1365         int err;
1366         unsigned char old_softraw;
1367
1368         value = simple_strtoul(buf, &rest, 10);
1369         if (*rest || value > 1)
1370                 return -EINVAL;
1371
1372         if (atkbd->softraw != value) {
1373                 old_dev = atkbd->dev;
1374                 old_softraw = atkbd->softraw;
1375
1376                 new_dev = input_allocate_device();
1377                 if (!new_dev)
1378                         return -ENOMEM;
1379
1380                 atkbd->dev = new_dev;
1381                 atkbd->softraw = value;
1382                 atkbd_set_device_attrs(atkbd);
1383
1384                 err = input_register_device(atkbd->dev);
1385                 if (err) {
1386                         input_free_device(new_dev);
1387
1388                         atkbd->dev = old_dev;
1389                         atkbd->softraw = old_softraw;
1390                         atkbd_set_device_attrs(atkbd);
1391
1392                         return err;
1393                 }
1394                 input_unregister_device(old_dev);
1395         }
1396         return count;
1397 }
1398
1399 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1400 {
1401         return sprintf(buf, "%lu\n", atkbd->err_count);
1402 }
1403
1404
1405 static int __init atkbd_init(void)
1406 {
1407         return serio_register_driver(&atkbd_drv);
1408 }
1409
1410 static void __exit atkbd_exit(void)
1411 {
1412         serio_unregister_driver(&atkbd_drv);
1413 }
1414
1415 module_init(atkbd_init);
1416 module_exit(atkbd_exit);