drivers/input/keyboard/atkbd.c

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