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