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