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