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 = 1;
  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,     0xa9 },
 175         { ATKBD_SCR_4,     0xb6 },
 176         { ATKBD_SCR_8,     0xa7 },
 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 < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
 469                         while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
 470                         dev->rep[REP_PERIOD] = period[i];
 471                         dev->rep[REP_DELAY] = delay[j];
 472                         param[0] = i | (j << 5);
 473                         ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
 474
 475                         return 0;
 476         }
 477
 478         return -1;
 479 }
 480
 481 /*
 482  * atkbd_enable() signals that interrupt handler is allowed to
 483  * generate input events.
 484  */
 485
 486 static inline void atkbd_enable(struct atkbd *atkbd)
 487 {
 488         serio_pause_rx(atkbd->ps2dev.serio);
 489         atkbd->enabled = 1;
 490         serio_continue_rx(atkbd->ps2dev.serio);
 491 }
 492
 493 /*
 494  * atkbd_disable() tells input handler that all incoming data except
 495  * for ACKs and command response should be dropped.
 496  */
 497
 498 static inline void atkbd_disable(struct atkbd *atkbd)
 499 {
 500         serio_pause_rx(atkbd->ps2dev.serio);
 501         atkbd->enabled = 0;
 502         serio_continue_rx(atkbd->ps2dev.serio);
 503 }
 504
 505 /*
 506  * atkbd_probe() probes for an AT keyboard on a serio port.
 507  */
 508
 509 static int atkbd_probe(struct atkbd *atkbd)
 510 {
 511         struct ps2dev *ps2dev = &atkbd->ps2dev;
 512         unsigned char param[2];
 513
 514 /*
 515  * Some systems, where the bit-twiddling when testing the io-lines of the
 516  * controller may confuse the keyboard need a full reset of the keyboard. On
 517  * these systems the BIOS also usually doesn't do it for us.
 518  */
 519
 520         if (atkbd_reset)
 521                 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
 522                         printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
 523
 524 /*
 525  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
 526  * Some keyboards report different values, but the first byte is always 0xab or
 527  * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
 528  * should make sure we don't try to set the LEDs on it.
 529  */
 530
 531         param[0] = param[1] = 0xa5;     /* initialize with invalid values */
 532         if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
 533
 534 /*
 535  * If the get ID command failed, we check if we can at least set the LEDs on
 536  * the keyboard. This should work on every keyboard out there. It also turns
 537  * the LEDs off, which we want anyway.
 538  */
 539                 param[0] = 0;
 540                 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 541                         return -1;
 542                 atkbd->id = 0xabba;
 543                 return 0;
 544         }
 545
 546         if (param[0] != 0xab && param[0] != 0xac &&     /* Regular and NCD Sun keyboards */
 547             param[0] != 0x2b && param[0] != 0x5d &&     /* Trust keyboard, raw and translated */
 548             param[0] != 0x60 && param[0] != 0x47)       /* NMB SGI keyboard, raw and translated */
 549                 return -1;
 550
 551         atkbd->id = (param[0] << 8) | param[1];
 552
 553         if (atkbd->id == 0xaca1 && atkbd->translated) {
 554                 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
 555                 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
 556                 return -1;
 557         }
 558
 559         return 0;
 560 }
 561
 562 /*
 563  * atkbd_select_set checks if a keyboard has a working Set 3 support, and
 564  * sets it into that. Unfortunately there are keyboards that can be switched
 565  * to Set 3, but don't work well in that (BTC Multimedia ...)
 566  */
 567
 568 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
 569 {
 570         struct ps2dev *ps2dev = &atkbd->ps2dev;
 571         unsigned char param[2];
 572
 573         atkbd->extra = 0;
 574 /*
 575  * For known special keyboards we can go ahead and set the correct set.
 576  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
 577  * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
 578  */
 579
 580         if (atkbd->translated)
 581                 return 2;
 582
 583         if (atkbd->id == 0xaca1) {
 584                 param[0] = 3;
 585                 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
 586                 return 3;
 587         }
 588
 589         if (allow_extra) {
 590                 param[0] = 0x71;
 591                 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
 592                         atkbd->extra = 1;
 593                         return 2;
 594                 }
 595         }
 596
 597         if (target_set != 3)
 598                 return 2;
 599
 600         if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
 601                 atkbd->id = param[0] << 8 | param[1];
 602                 return 2;
 603         }
 604
 605         param[0] = 3;
 606         if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 607                 return 2;
 608
 609         param[0] = 0;
 610         if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
 611                 return 2;
 612
 613         if (param[0] != 3) {
 614                 param[0] = 2;
 615                 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 616                 return 2;
 617         }
 618
 619         ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
 620
 621         return 3;
 622 }
 623
 624 static int atkbd_activate(struct atkbd *atkbd)
 625 {
 626         struct ps2dev *ps2dev = &atkbd->ps2dev;
 627         unsigned char param[1];
 628
 629 /*
 630  * Set the LEDs to a defined state.
 631  */
 632
 633         param[0] = 0;
 634         if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 635                 return -1;
 636
 637 /*
 638  * Set autorepeat to fastest possible.
 639  */
 640
 641         param[0] = 0;
 642         if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
 643                 return -1;
 644
 645 /*
 646  * Enable the keyboard to receive keystrokes.
 647  */
 648
 649         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 650                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
 651                         ps2dev->serio->phys);
 652                 return -1;
 653         }
 654
 655         return 0;
 656 }
 657
 658 /*
 659  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 660  * reboot.
 661  */
 662
 663 static void atkbd_cleanup(struct serio *serio)
 664 {
 665         struct atkbd *atkbd = serio_get_drvdata(serio);
 666         ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
 667 }
 668
 669
 670 /*
 671  * atkbd_disconnect() closes and frees.
 672  */
 673
 674 static void atkbd_disconnect(struct serio *serio)
 675 {
 676         struct atkbd *atkbd = serio_get_drvdata(serio);
 677
 678         atkbd_disable(atkbd);
 679
 680         /* make sure we don't have a command in flight */
 681         synchronize_kernel();
 682         flush_scheduled_work();
 683
 684         device_remove_file(&serio->dev, &atkbd_attr_extra);
 685         device_remove_file(&serio->dev, &atkbd_attr_scroll);
 686         device_remove_file(&serio->dev, &atkbd_attr_set);
 687         device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
 688         device_remove_file(&serio->dev, &atkbd_attr_softraw);
 689
 690         input_unregister_device(&atkbd->dev);
 691         serio_close(serio);
 692         serio_set_drvdata(serio, NULL);
 693         kfree(atkbd);
 694 }
 695
 696
 697 /*
 698  * atkbd_set_device_attrs() initializes keyboard's keycode table
 699  * according to the selected scancode set
 700  */
 701
 702 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 703 {
 704         int i, j;
 705
 706         memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
 707
 708         if (atkbd->translated) {
 709                 for (i = 0; i < 128; i++) {
 710                         atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
 711                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
 712                         if (atkbd->scroll)
 713                                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
 714                                         if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
 715                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 716                 }
 717         } else if (atkbd->set == 3) {
 718                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 719         } else {
 720                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 721
 722                 if (atkbd->scroll)
 723                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
 724                                 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
 725         }
 726 }
 727
 728 /*
 729  * atkbd_set_device_attrs() sets up keyboard's input device structure
 730  */
 731
 732 static void atkbd_set_device_attrs(struct atkbd *atkbd)
 733 {
 734         int i;
 735
 736         memset(&atkbd->dev, 0, sizeof(struct input_dev));
 737
 738         init_input_dev(&atkbd->dev);
 739
 740         atkbd->dev.name = atkbd->name;
 741         atkbd->dev.phys = atkbd->phys;
 742         atkbd->dev.id.bustype = BUS_I8042;
 743         atkbd->dev.id.vendor = 0x0001;
 744         atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
 745         atkbd->dev.id.version = atkbd->id;
 746         atkbd->dev.event = atkbd_event;
 747         atkbd->dev.private = atkbd;
 748         atkbd->dev.dev = &atkbd->ps2dev.serio->dev;
 749
 750         atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
 751
 752         if (atkbd->write) {
 753                 atkbd->dev.evbit[0] |= BIT(EV_LED);
 754                 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
 755         }
 756
 757         if (atkbd->extra)
 758                 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
 759                                         BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
 760
 761         if (!atkbd->softrepeat) {
 762                 atkbd->dev.rep[REP_DELAY] = 250;
 763                 atkbd->dev.rep[REP_PERIOD] = 33;
 764         }
 765
 766         atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
 767
 768         if (atkbd->scroll) {
 769                 atkbd->dev.evbit[0] |= BIT(EV_REL);
 770                 atkbd->dev.relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);
 771                 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
 772         }
 773
 774         atkbd->dev.keycode = atkbd->keycode;
 775         atkbd->dev.keycodesize = sizeof(unsigned char);
 776         atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 777
 778         for (i = 0; i < 512; i++)
 779                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
 780                         set_bit(atkbd->keycode[i], atkbd->dev.keybit);
 781 }
 782
 783 /*
 784  * atkbd_connect() is called when the serio module finds an interface
 785  * that isn't handled yet by an appropriate device driver. We check if
 786  * there is an AT keyboard out there and if yes, we register ourselves
 787  * to the input module.
 788  */
 789
 790 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
 791 {
 792         struct atkbd *atkbd;
 793         int err;
 794
 795         if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
 796                 return - ENOMEM;
 797
 798         memset(atkbd, 0, sizeof(struct atkbd));
 799
 800         ps2_init(&atkbd->ps2dev, serio);
 801
 802         switch (serio->id.type) {
 803
 804                 case SERIO_8042_XL:
 805                         atkbd->translated = 1;
 806                 case SERIO_8042:
 807                         if (serio->write)
 808                                 atkbd->write = 1;
 809                         break;
 810         }
 811
 812         atkbd->softraw = atkbd_softraw;
 813         atkbd->softrepeat = atkbd_softrepeat;
 814         atkbd->scroll = atkbd_scroll;
 815
 816         if (!atkbd->write)
 817                 atkbd->softrepeat = 1;
 818
 819         if (atkbd->softrepeat)
 820                 atkbd->softraw = 1;
 821
 822         serio_set_drvdata(serio, atkbd);
 823
 824         err = serio_open(serio, drv);
 825         if (err) {
 826                 serio_set_drvdata(serio, NULL);
 827                 kfree(atkbd);
 828                 return err;
 829         }
 830
 831         if (atkbd->write) {
 832
 833                 if (atkbd_probe(atkbd)) {
 834                         serio_close(serio);
 835                         serio_set_drvdata(serio, NULL);
 836                         kfree(atkbd);
 837                         return -ENODEV;
 838                 }
 839
 840                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
 841                 atkbd_activate(atkbd);
 842
 843         } else {
 844                 atkbd->set = 2;
 845                 atkbd->id = 0xab00;
 846         }
 847
 848         if (atkbd->extra)
 849                 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
 850         else
 851                 sprintf(atkbd->name, "AT %s Set %d keyboard",
 852                         atkbd->translated ? "Translated" : "Raw", atkbd->set);
 853
 854         sprintf(atkbd->phys, "%s/input0", serio->phys);
 855
 856         atkbd_set_keycode_table(atkbd);
 857         atkbd_set_device_attrs(atkbd);
 858
 859         input_register_device(&atkbd->dev);
 860
 861         device_create_file(&serio->dev, &atkbd_attr_extra);
 862         device_create_file(&serio->dev, &atkbd_attr_scroll);
 863         device_create_file(&serio->dev, &atkbd_attr_set);
 864         device_create_file(&serio->dev, &atkbd_attr_softrepeat);
 865         device_create_file(&serio->dev, &atkbd_attr_softraw);
 866
 867         atkbd_enable(atkbd);
 868
 869         printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
 870
 871         return 0;
 872 }
 873
 874 /*
 875  * atkbd_reconnect() tries to restore keyboard into a sane state and is
 876  * most likely called on resume.
 877  */
 878
 879 static int atkbd_reconnect(struct serio *serio)
 880 {
 881         struct atkbd *atkbd = serio_get_drvdata(serio);
 882         struct serio_driver *drv = serio->drv;
 883         unsigned char param[1];
 884
 885         if (!atkbd || !drv) {
 886                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
 887                 return -1;
 888         }
 889
 890         atkbd_disable(atkbd);
 891
 892         if (atkbd->write) {
 893                 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
 894                          | (test_bit(LED_NUML,    atkbd->dev.led) ? 2 : 0)
 895                          | (test_bit(LED_CAPSL,   atkbd->dev.led) ? 4 : 0);
 896
 897                 if (atkbd_probe(atkbd))
 898                         return -1;
 899                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
 900                         return -1;
 901
 902                 atkbd_activate(atkbd);
 903
 904                 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
 905                         return -1;
 906         }
 907
 908         atkbd_enable(atkbd);
 909
 910         return 0;
 911 }
 912
 913 static struct serio_device_id atkbd_serio_ids[] = {
 914         {
 915                 .type   = SERIO_8042,
 916                 .proto  = SERIO_ANY,
 917                 .id     = SERIO_ANY,
 918                 .extra  = SERIO_ANY,
 919         },
 920         {
 921                 .type   = SERIO_8042_XL,
 922                 .proto  = SERIO_ANY,
 923                 .id     = SERIO_ANY,
 924                 .extra  = SERIO_ANY,
 925         },
 926         {
 927                 .type   = SERIO_RS232,
 928                 .proto  = SERIO_PS2SER,
 929                 .id     = SERIO_ANY,
 930                 .extra  = SERIO_ANY,
 931         },
 932         { 0 }
 933 };
 934
 935 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
 936
 937 static struct serio_driver atkbd_drv = {
 938         .driver         = {
 939                 .name   = "atkbd",
 940         },
 941         .description    = DRIVER_DESC,
 942         .id_table       = atkbd_serio_ids,
 943         .interrupt      = atkbd_interrupt,
 944         .connect        = atkbd_connect,
 945         .reconnect      = atkbd_reconnect,
 946         .disconnect     = atkbd_disconnect,
 947         .cleanup        = atkbd_cleanup,
 948 };
 949
 950 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
 951                                 ssize_t (*handler)(struct atkbd *, char *))
 952 {
 953         struct serio *serio = to_serio_port(dev);
 954         int retval;
 955
 956         retval = serio_pin_driver(serio);
 957         if (retval)
 958                 return retval;
 959
 960         if (serio->drv != &atkbd_drv) {
 961                 retval = -ENODEV;
 962                 goto out;
 963         }
 964
 965         retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
 966
 967 out:
 968         serio_unpin_driver(serio);
 969         return retval;
 970 }
 971
 972 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
 973                                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
 974 {
 975         struct serio *serio = to_serio_port(dev);
 976         struct atkbd *atkbd;
 977         int retval;
 978
 979         retval = serio_pin_driver(serio);
 980         if (retval)
 981                 return retval;
 982
 983         if (serio->drv != &atkbd_drv) {
 984                 retval = -ENODEV;
 985                 goto out;
 986         }
 987
 988         atkbd = serio_get_drvdata(serio);
 989         atkbd_disable(atkbd);
 990         retval = handler(atkbd, buf, count);
 991         atkbd_enable(atkbd);
 992
 993 out:
 994         serio_unpin_driver(serio);
 995         return retval;
 996 }
 997
 998 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
 999 {
1000         return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1001 }
1002
1003 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1004 {
1005         unsigned long value;
1006         char *rest;
1007
1008         if (!atkbd->write)
1009                 return -EIO;
1010
1011         value = simple_strtoul(buf, &rest, 10);
1012         if (*rest || value > 1)
1013                 return -EINVAL;
1014
1015         if (atkbd->extra != value) {
1016                 /* unregister device as it's properties will change */
1017                 input_unregister_device(&atkbd->dev);
1018                 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1019                 atkbd_activate(atkbd);
1020                 atkbd_set_device_attrs(atkbd);
1021                 input_register_device(&atkbd->dev);
1022         }
1023         return count;
1024 }
1025
1026 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1027 {
1028         return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1029 }
1030
1031 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1032 {
1033         unsigned long value;
1034         char *rest;
1035
1036         value = simple_strtoul(buf, &rest, 10);
1037         if (*rest || value > 1)
1038                 return -EINVAL;
1039
1040         if (atkbd->scroll != value) {
1041                 /* unregister device as it's properties will change */
1042                 input_unregister_device(&atkbd->dev);
1043                 atkbd->scroll = value;
1044                 atkbd_set_keycode_table(atkbd);
1045                 atkbd_set_device_attrs(atkbd);
1046                 input_register_device(&atkbd->dev);
1047         }
1048         return count;
1049 }
1050
1051 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1052 {
1053         return sprintf(buf, "%d\n", atkbd->set);
1054 }
1055
1056 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1057 {
1058         unsigned long value;
1059         char *rest;
1060
1061         if (!atkbd->write)
1062                 return -EIO;
1063
1064         value = simple_strtoul(buf, &rest, 10);
1065         if (*rest || (value != 2 && value != 3))
1066                 return -EINVAL;
1067
1068         if (atkbd->set != value) {
1069                 /* unregister device as it's properties will change */
1070                 input_unregister_device(&atkbd->dev);
1071                 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1072                 atkbd_activate(atkbd);
1073                 atkbd_set_keycode_table(atkbd);
1074                 atkbd_set_device_attrs(atkbd);
1075                 input_register_device(&atkbd->dev);
1076         }
1077         return count;
1078 }
1079
1080 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1081 {
1082         return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1083 }
1084
1085 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1086 {
1087         unsigned long value;
1088         char *rest;
1089
1090         if (!atkbd->write)
1091                 return -EIO;
1092
1093         value = simple_strtoul(buf, &rest, 10);
1094         if (*rest || value > 1)
1095                 return -EINVAL;
1096
1097         if (atkbd->softrepeat != value) {
1098                 /* unregister device as it's properties will change */
1099                 input_unregister_device(&atkbd->dev);
1100                 atkbd->softrepeat = value;
1101                 if (atkbd->softrepeat)
1102                         atkbd->softraw = 1;
1103                 atkbd_set_device_attrs(atkbd);
1104                 input_register_device(&atkbd->dev);
1105         }
1106
1107         return count;
1108 }
1109
1110
1111 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1112 {
1113         return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1114 }
1115
1116 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1117 {
1118         unsigned long value;
1119         char *rest;
1120
1121         value = simple_strtoul(buf, &rest, 10);
1122         if (*rest || value > 1)
1123                 return -EINVAL;
1124
1125         if (atkbd->softraw != value) {
1126                 /* unregister device as it's properties will change */
1127                 input_unregister_device(&atkbd->dev);
1128                 atkbd->softraw = value;
1129                 atkbd_set_device_attrs(atkbd);
1130                 input_register_device(&atkbd->dev);
1131         }
1132         return count;
1133 }
1134
1135
1136 static int __init atkbd_init(void)
1137 {
1138         serio_register_driver(&atkbd_drv);
1139         return 0;
1140 }
1141
1142 static void __exit atkbd_exit(void)
1143 {
1144         serio_unregister_driver(&atkbd_drv);
1145 }
1146
1147 module_init(atkbd_init);
1148 module_exit(atkbd_exit);