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