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