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