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