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