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
  30 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  31 MODULE_DESCRIPTION("AT and PS/2 keyboard driver");
  32 MODULE_LICENSE("GPL");
  33
  34 static int atkbd_set = 2;
  35 module_param_named(set, atkbd_set, int, 0);
  36 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
  37
  38 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
  39 static int atkbd_reset;
  40 #else
  41 static int atkbd_reset = 1;
  42 #endif
  43 module_param_named(reset, atkbd_reset, bool, 0);
  44 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
  45
  46 static int atkbd_softrepeat;
  47 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
  48 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
  49
  50 static int atkbd_scroll;
  51 module_param_named(scroll, atkbd_scroll, bool, 0);
  52 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
  53
  54 static int atkbd_extra;
  55 module_param_named(extra, atkbd_extra, bool, 0);
  56 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
  57
  58 __obsolete_setup("atkbd_set=");
  59 __obsolete_setup("atkbd_reset");
  60 __obsolete_setup("atkbd_softrepeat=");
  61
  62 /*
  63  * Scancode to keycode tables. These are just the default setting, and
  64  * are loadable via an userland utility.
  65  */
  66
  67 #if defined(__hppa__)
  68 #include "hpps2atkbd.h"
  69 #else
  70
  71 static unsigned char atkbd_set2_keycode[512] = {
  72
  73           0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
  74           0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
  75           0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
  76           0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
  77           0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
  78           0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
  79           0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
  80          82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
  81
  82           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  83         217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
  84         173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
  85         159,  0,115,  0,164,  0,  0,116,158,  0,150,166,  0,  0,  0,142,
  86         157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
  87         226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
  88           0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
  89         110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
  90
  91           0,  0,  0, 65, 99,
  92 };
  93
  94 #endif
  95
  96 static unsigned char atkbd_set3_keycode[512] = {
  97
  98           0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
  99         131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
 100         134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
 101         136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
 102         125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
 103         113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
 104         108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
 105          82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,
 106
 107         184,185,186,187, 74, 94, 92, 93,  0,  0,  0,125,126,127,112,  0,
 108           0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
 109         148,149,147,140
 110 };
 111
 112 static unsigned char atkbd_unxlate_table[128] = {
 113           0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
 114          21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
 115          35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
 116          50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
 117          11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
 118         114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
 119          71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
 120          19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
 121 };
 122
 123 #define ATKBD_CMD_SETLEDS       0x10ed
 124 #define ATKBD_CMD_GSCANSET      0x11f0
 125 #define ATKBD_CMD_SSCANSET      0x10f0
 126 #define ATKBD_CMD_GETID         0x02f2
 127 #define ATKBD_CMD_SETREP        0x10f3
 128 #define ATKBD_CMD_ENABLE        0x00f4
 129 #define ATKBD_CMD_RESET_DIS     0x00f5
 130 #define ATKBD_CMD_SETALL_MBR    0x00fa
 131 #define ATKBD_CMD_RESET_BAT     0x02ff
 132 #define ATKBD_CMD_RESEND        0x00fe
 133 #define ATKBD_CMD_EX_ENABLE     0x10ea
 134 #define ATKBD_CMD_EX_SETLEDS    0x20eb
 135 #define ATKBD_CMD_OK_GETID      0x02e8
 136
 137
 138 #define ATKBD_RET_ACK           0xfa
 139 #define ATKBD_RET_NAK           0xfe
 140 #define ATKBD_RET_BAT           0xaa
 141 #define ATKBD_RET_EMUL0         0xe0
 142 #define ATKBD_RET_EMUL1         0xe1
 143 #define ATKBD_RET_RELEASE       0xf0
 144 #define ATKBD_RET_HANGUEL       0xf1
 145 #define ATKBD_RET_HANJA         0xf2
 146 #define ATKBD_RET_ERR           0xff
 147
 148 #define ATKBD_KEY_UNKNOWN         0
 149 #define ATKBD_KEY_NULL          255
 150
 151 #define ATKBD_SCR_1             254
 152 #define ATKBD_SCR_2             253
 153 #define ATKBD_SCR_4             252
 154 #define ATKBD_SCR_8             251
 155 #define ATKBD_SCR_CLICK         250
 156
 157 #define ATKBD_SPECIAL           250
 158
 159 static unsigned char atkbd_scroll_keys[5][2] = {
 160         { ATKBD_SCR_1,     0x45 },
 161         { ATKBD_SCR_2,     0x29 },
 162         { ATKBD_SCR_4,     0x36 },
 163         { ATKBD_SCR_8,     0x27 },
 164         { ATKBD_SCR_CLICK, 0x60 },
 165 };
 166
 167 /*
 168  * The atkbd control structure
 169  */
 170
 171 struct atkbd {
 172         unsigned char keycode[512];
 173         struct input_dev dev;
 174         struct serio *serio;
 175
 176         char name[64];
 177         char phys[32];
 178         unsigned short id;
 179         unsigned char set;
 180         unsigned int translated:1;
 181         unsigned int extra:1;
 182         unsigned int write:1;
 183
 184         unsigned char cmdbuf[4];
 185         unsigned char cmdcnt;
 186         volatile signed char ack;
 187         unsigned char emul;
 188         unsigned int resend:1;
 189         unsigned int release:1;
 190         unsigned int bat_xl:1;
 191         unsigned int enabled:1;
 192
 193         unsigned int last;
 194         unsigned long time;
 195 };
 196
 197 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
 198 {
 199         input_regs(dev, regs);
 200         if (value == 3) {
 201                 input_report_key(dev, code, 1);
 202                 input_report_key(dev, code, 0);
 203         } else
 204                 input_event(dev, EV_KEY, code, value);
 205         input_sync(dev);
 206 }
 207
 208 /*
 209  * atkbd_interrupt(). Here takes place processing of data received from
 210  * the keyboard into events.
 211  */
 212
 213 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
 214                         unsigned int flags, struct pt_regs *regs)
 215 {
 216         struct atkbd *atkbd = serio->private;
 217         unsigned int code = data;
 218         int scroll = 0, click = -1;
 219         int value;
 220
 221 #ifdef ATKBD_DEBUG
 222         printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
 223 #endif
 224
 225 #if !defined(__i386__) && !defined (__x86_64__)
 226         if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
 227                 printk("atkbd.c: frame/parity error: %02x\n", flags);
 228                 serio_write(serio, ATKBD_CMD_RESEND);
 229                 atkbd->resend = 1;
 230                 goto out;
 231         }
 232
 233         if (!flags && data == ATKBD_RET_ACK)
 234                 atkbd->resend = 0;
 235 #endif
 236
 237         if (!atkbd->ack)
 238                 switch (code) {
 239                         case ATKBD_RET_ACK:
 240                                 atkbd->ack = 1;
 241                                 goto out;
 242                         case ATKBD_RET_NAK:
 243                                 atkbd->ack = -1;
 244                                 goto out;
 245                 }
 246
 247         if (atkbd->cmdcnt) {
 248                 atkbd->cmdbuf[--atkbd->cmdcnt] = code;
 249                 goto out;
 250         }
 251
 252         if (!atkbd->enabled)
 253                 goto out;
 254
 255         if (atkbd->translated) {
 256
 257                 if (atkbd->emul ||
 258                     !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
 259                       code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
 260                       code == ATKBD_RET_ERR ||
 261                      (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
 262                         atkbd->release = code >> 7;
 263                         code &= 0x7f;
 264                 }
 265
 266                 if (!atkbd->emul &&
 267                      (code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
 268                         atkbd->bat_xl = !atkbd->release;
 269         }
 270
 271         switch (code) {
 272                 case ATKBD_RET_BAT:
 273                         serio_rescan(atkbd->serio);
 274                         goto out;
 275                 case ATKBD_RET_EMUL0:
 276                         atkbd->emul = 1;
 277                         goto out;
 278                 case ATKBD_RET_EMUL1:
 279                         atkbd->emul = 2;
 280                         goto out;
 281                 case ATKBD_RET_RELEASE:
 282                         atkbd->release = 1;
 283                         goto out;
 284                 case ATKBD_RET_HANGUEL:
 285                         atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);
 286                         goto out;
 287                 case ATKBD_RET_HANJA:
 288                         atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);
 289                         goto out;
 290                 case ATKBD_RET_ERR:
 291                         printk(KERN_WARNING "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
 292                         goto out;
 293         }
 294
 295         if (atkbd->set != 3)
 296                 code = (code & 0x7f) | ((code & 0x80) << 1);
 297         if (atkbd->emul) {
 298                 if (--atkbd->emul)
 299                         goto out;
 300                 code |= (atkbd->set != 3) ? 0x80 : 0x100;
 301         }
 302
 303         switch (atkbd->keycode[code]) {
 304                 case ATKBD_KEY_NULL:
 305                         break;
 306                 case ATKBD_KEY_UNKNOWN:
 307                         if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
 308                                 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
 309                                        "like XFree86, might be trying access hardware directly.\n",
 310                                        data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
 311                         } else {
 312                                 printk(KERN_WARNING "atkbd.c: Unknown key %s "
 313                                        "(%s set %d, code %#x on %s).\n",
 314                                        atkbd->release ? "released" : "pressed",
 315                                        atkbd->translated ? "translated" : "raw",
 316                                        atkbd->set, code, serio->phys);
 317                                 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
 318                                        "to make it known.\n",
 319                                        code & 0x80 ? "e0" : "", code & 0x7f);
 320                         }
 321                         break;
 322                 case ATKBD_SCR_1:
 323                         scroll = 1 - atkbd->release * 2;
 324                         break;
 325                 case ATKBD_SCR_2:
 326                         scroll = 2 - atkbd->release * 4;
 327                         break;
 328                 case ATKBD_SCR_4:
 329                         scroll = 4 - atkbd->release * 8;
 330                         break;
 331                 case ATKBD_SCR_8:
 332                         scroll = 8 - atkbd->release * 16;
 333                         break;
 334                 case ATKBD_SCR_CLICK:
 335                         click = !atkbd->release;
 336                         break;
 337                 default:
 338                         value = atkbd->release ? 0 :
 339                                 (1 + (!atkbd_softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));
 340
 341                         switch (value) {        /* Workaround Toshiba laptop multiple keypress */
 342                                 case 0:
 343                                         atkbd->last = 0;
 344                                         break;
 345                                 case 1:
 346                                         atkbd->last = code;
 347                                         atkbd->time = jiffies + (atkbd->dev.rep[REP_DELAY] * HZ + 500) / 1000 / 2;
 348                                         break;
 349                                 case 2:
 350                                         if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
 351                                                 value = 1;
 352                                         break;
 353                         }
 354
 355                         atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);
 356         }
 357
 358         if (scroll || click != -1) {
 359                 input_regs(&atkbd->dev, regs);
 360                 input_report_key(&atkbd->dev, BTN_MIDDLE, click);
 361                 input_report_rel(&atkbd->dev, REL_WHEEL, scroll);
 362                 input_sync(&atkbd->dev);
 363         }
 364
 365         atkbd->release = 0;
 366 out:
 367         return IRQ_HANDLED;
 368 }
 369
 370 /*
 371  * atkbd_sendbyte() sends a byte to the keyboard, and waits for
 372  * acknowledge. It doesn't handle resends according to the keyboard
 373  * protocol specs, because if these are needed, the keyboard needs
 374  * replacement anyway, and they only make a mess in the protocol.
 375  */
 376
 377 static int atkbd_sendbyte(struct atkbd *atkbd, unsigned char byte)
 378 {
 379         int timeout = 20000; /* 200 msec */
 380         atkbd->ack = 0;
 381
 382 #ifdef ATKBD_DEBUG
 383         printk(KERN_DEBUG "atkbd.c: Sent: %02x\n", byte);
 384 #endif
 385         if (serio_write(atkbd->serio, byte))
 386                 return -1;
 387
 388         while (!atkbd->ack && timeout--) udelay(10);
 389
 390         return -(atkbd->ack <= 0);
 391 }
 392
 393 /*
 394  * atkbd_command() sends a command, and its parameters to the keyboard,
 395  * then waits for the response and puts it in the param array.
 396  */
 397
 398 static int atkbd_command(struct atkbd *atkbd, unsigned char *param, int command)
 399 {
 400         int timeout = 500000; /* 500 msec */
 401         int send = (command >> 12) & 0xf;
 402         int receive = (command >> 8) & 0xf;
 403         int i;
 404
 405         atkbd->cmdcnt = receive;
 406
 407         if (command == ATKBD_CMD_RESET_BAT)
 408                 timeout = 2000000; /* 2 sec */
 409
 410         if (receive && param)
 411                 for (i = 0; i < receive; i++)
 412                         atkbd->cmdbuf[(receive - 1) - i] = param[i];
 413
 414         if (command & 0xff)
 415                 if (atkbd_sendbyte(atkbd, command & 0xff))
 416                         return (atkbd->cmdcnt = 0) - 1;
 417
 418         for (i = 0; i < send; i++)
 419                 if (atkbd_sendbyte(atkbd, param[i]))
 420                         return (atkbd->cmdcnt = 0) - 1;
 421
 422         while (atkbd->cmdcnt && timeout--) {
 423
 424                 if (atkbd->cmdcnt == 1 &&
 425                     command == ATKBD_CMD_RESET_BAT && timeout > 100000)
 426                         timeout = 100000;
 427
 428                 if (atkbd->cmdcnt == 1 && command == ATKBD_CMD_GETID &&
 429                     atkbd->cmdbuf[1] != 0xab && atkbd->cmdbuf[1] != 0xac) {
 430                         atkbd->cmdcnt = 0;
 431                         break;
 432                 }
 433
 434                 udelay(1);
 435         }
 436
 437         if (param)
 438                 for (i = 0; i < receive; i++)
 439                         param[i] = atkbd->cmdbuf[(receive - 1) - i];
 440
 441         if (command == ATKBD_CMD_RESET_BAT && atkbd->cmdcnt == 1)
 442                 atkbd->cmdcnt = 0;
 443
 444         if (atkbd->cmdcnt) {
 445                 atkbd->cmdcnt = 0;
 446                 return -1;
 447         }
 448
 449         return 0;
 450 }
 451
 452 /*
 453  * Event callback from the input module. Events that change the state of
 454  * the hardware are processed here.
 455  */
 456
 457 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 458 {
 459         struct atkbd *atkbd = dev->private;
 460         const short period[32] =
 461                 { 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
 462                  133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
 463         const short delay[4] =
 464                 { 250, 500, 750, 1000 };
 465         unsigned char param[2];
 466         int i, j;
 467
 468         if (!atkbd->write)
 469                 return -1;
 470
 471         switch (type) {
 472
 473                 case EV_LED:
 474
 475                         param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
 476                                  | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
 477                                  | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
 478                         atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS);
 479
 480                         if (atkbd->extra) {
 481                                 param[0] = 0;
 482                                 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
 483                                          | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
 484                                          | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
 485                                          | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
 486                                          | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
 487                                 atkbd_command(atkbd, param, ATKBD_CMD_EX_SETLEDS);
 488                         }
 489
 490                         return 0;
 491
 492
 493                 case EV_REP:
 494
 495                         if (atkbd_softrepeat) return 0;
 496
 497                         i = j = 0;
 498                         while (i < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
 499                         while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
 500                         dev->rep[REP_PERIOD] = period[i];
 501                         dev->rep[REP_DELAY] = delay[j];
 502                         param[0] = i | (j << 5);
 503                         atkbd_command(atkbd, param, ATKBD_CMD_SETREP);
 504
 505                         return 0;
 506         }
 507
 508         return -1;
 509 }
 510
 511 /*
 512  * atkbd_probe() probes for an AT keyboard on a serio port.
 513  */
 514
 515 static int atkbd_probe(struct atkbd *atkbd)
 516 {
 517         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 (atkbd_command(atkbd, NULL, ATKBD_CMD_RESET_BAT))
 527                         printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", atkbd->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 (atkbd_command(atkbd, 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 (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
 546                         return -1;
 547                 atkbd->id = 0xabba;
 548                 return 0;
 549         }
 550
 551         if (param[0] != 0xab && param[0] != 0xac)
 552                 return -1;
 553         atkbd->id = (param[0] << 8) | param[1];
 554
 555         if (atkbd->id == 0xaca1 && atkbd->translated) {
 556                 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
 557                 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
 558                 return -1;
 559         }
 560
 561         return 0;
 562 }
 563
 564 /*
 565  * atkbd_set_3 checks if a keyboard has a working Set 3 support, and
 566  * sets it into that. Unfortunately there are keyboards that can be switched
 567  * to Set 3, but don't work well in that (BTC Multimedia ...)
 568  */
 569
 570 static int atkbd_set_3(struct atkbd *atkbd)
 571 {
 572         unsigned char param[2];
 573
 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                 atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET);
 586                 return 3;
 587         }
 588
 589         if (atkbd_extra) {
 590                 param[0] = 0x71;
 591                 if (!atkbd_command(atkbd, param, ATKBD_CMD_EX_ENABLE)) {
 592                         atkbd->extra = 1;
 593                         return 2;
 594                 }
 595         }
 596
 597         if (atkbd_set != 3)
 598                 return 2;
 599
 600         if (!atkbd_command(atkbd, param, ATKBD_CMD_OK_GETID)) {
 601                 atkbd->id = param[0] << 8 | param[1];
 602                 return 2;
 603         }
 604
 605         param[0] = 3;
 606         if (atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET))
 607                 return 2;
 608
 609         param[0] = 0;
 610         if (atkbd_command(atkbd, param, ATKBD_CMD_GSCANSET))
 611                 return 2;
 612
 613         if (param[0] != 3) {
 614                 param[0] = 2;
 615                 if (atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET))
 616                 return 2;
 617         }
 618
 619         atkbd_command(atkbd, param, ATKBD_CMD_SETALL_MBR);
 620
 621         return 3;
 622 }
 623
 624 static int atkbd_enable(struct atkbd *atkbd)
 625 {
 626         unsigned char param[1];
 627
 628 /*
 629  * Set the LEDs to a defined state.
 630  */
 631
 632         param[0] = 0;
 633         if (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
 634                 return -1;
 635
 636 /*
 637  * Set autorepeat to fastest possible.
 638  */
 639
 640         param[0] = 0;
 641         if (atkbd_command(atkbd, param, ATKBD_CMD_SETREP))
 642                 return -1;
 643
 644 /*
 645  * Enable the keyboard to receive keystrokes.
 646  */
 647
 648         if (atkbd_command(atkbd, NULL, ATKBD_CMD_ENABLE)) {
 649                 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
 650                         atkbd->serio->phys);
 651                 return -1;
 652         }
 653
 654         return 0;
 655 }
 656
 657 /*
 658  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 659  * reboot.
 660  */
 661
 662 static void atkbd_cleanup(struct serio *serio)
 663 {
 664         struct atkbd *atkbd = serio->private;
 665         atkbd_command(atkbd, NULL, ATKBD_CMD_RESET_BAT);
 666 }
 667
 668 /*
 669  * atkbd_disconnect() closes and frees.
 670  */
 671
 672 static void atkbd_disconnect(struct serio *serio)
 673 {
 674         struct atkbd *atkbd = serio->private;
 675         input_unregister_device(&atkbd->dev);
 676         serio_close(serio);
 677         kfree(atkbd);
 678 }
 679
 680 /*
 681  * atkbd_connect() is called when the serio module finds and interface
 682  * that isn't handled yet by an appropriate device driver. We check if
 683  * there is an AT keyboard out there and if yes, we register ourselves
 684  * to the input module.
 685  */
 686
 687 static void atkbd_connect(struct serio *serio, struct serio_dev *dev)
 688 {
 689         struct atkbd *atkbd;
 690         int i;
 691
 692         if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
 693                 return;
 694         memset(atkbd, 0, sizeof(struct atkbd));
 695
 696         switch (serio->type & SERIO_TYPE) {
 697
 698                 case SERIO_8042_XL:
 699                         atkbd->translated = 1;
 700                 case SERIO_8042:
 701                         if (serio->write)
 702                                 atkbd->write = 1;
 703                         break;
 704                 case SERIO_RS232:
 705                         if ((serio->type & SERIO_PROTO) == SERIO_PS2SER)
 706                                 break;
 707                 default:
 708                         kfree(atkbd);
 709                         return;
 710         }
 711
 712         if (atkbd->write) {
 713                 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
 714                 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
 715         } else  atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
 716
 717         if (!atkbd_softrepeat) {
 718                 atkbd->dev.rep[REP_DELAY] = 250;
 719                 atkbd->dev.rep[REP_PERIOD] = 33;
 720         }
 721
 722         atkbd->ack = 1;
 723         atkbd->serio = serio;
 724
 725         init_input_dev(&atkbd->dev);
 726
 727         atkbd->dev.keycode = atkbd->keycode;
 728         atkbd->dev.keycodesize = sizeof(unsigned char);
 729         atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 730         atkbd->dev.event = atkbd_event;
 731         atkbd->dev.private = atkbd;
 732
 733         serio->private = atkbd;
 734
 735         if (serio_open(serio, dev)) {
 736                 kfree(atkbd);
 737                 return;
 738         }
 739
 740         if (atkbd->write) {
 741
 742                 if (atkbd_probe(atkbd)) {
 743                         serio_close(serio);
 744                         serio->private = NULL;
 745                         kfree(atkbd);
 746                         return;
 747                 }
 748
 749                 atkbd->set = atkbd_set_3(atkbd);
 750                 atkbd_enable(atkbd);
 751
 752         } else {
 753                 atkbd->set = 2;
 754                 atkbd->id = 0xab00;
 755         }
 756
 757         atkbd->enabled = 1;
 758
 759         if (atkbd->extra) {
 760                 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) | BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
 761                 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
 762         } else
 763                 sprintf(atkbd->name, "AT %s Set %d keyboard",
 764                         atkbd->translated ? "Translated" : "Raw", atkbd->set);
 765
 766         sprintf(atkbd->phys, "%s/input0", serio->phys);
 767
 768         if (atkbd_scroll) {
 769                 for (i = 0; i < 5; i++)
 770                         atkbd_set2_keycode[atkbd_scroll_keys[i][1]] = atkbd_scroll_keys[i][0];
 771                 atkbd->dev.evbit[0] |= BIT(EV_REL);
 772                 atkbd->dev.relbit[0] = BIT(REL_WHEEL);
 773                 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
 774         }
 775
 776         if (atkbd->translated) {
 777                 for (i = 0; i < 128; i++) {
 778                         atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
 779                         atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
 780                 }
 781         } else if (atkbd->set == 3) {
 782                 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 783         } else {
 784                 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 785         }
 786
 787         atkbd->dev.name = atkbd->name;
 788         atkbd->dev.phys = atkbd->phys;
 789         atkbd->dev.id.bustype = BUS_I8042;
 790         atkbd->dev.id.vendor = 0x0001;
 791         atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
 792         atkbd->dev.id.version = atkbd->id;
 793
 794         for (i = 0; i < 512; i++)
 795                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
 796                         set_bit(atkbd->keycode[i], atkbd->dev.keybit);
 797
 798         input_register_device(&atkbd->dev);
 799
 800         printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
 801 }
 802
 803 /*
 804  * atkbd_reconnect() tries to restore keyboard into a sane state and is
 805  * most likely called on resume.
 806  */
 807
 808 static int atkbd_reconnect(struct serio *serio)
 809 {
 810         struct atkbd *atkbd = serio->private;
 811         struct serio_dev *dev = serio->dev;
 812         unsigned char param[1];
 813
 814         if (!dev) {
 815                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
 816                 return -1;
 817         }
 818
 819         if (atkbd->write) {
 820                 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
 821                          | (test_bit(LED_NUML,    atkbd->dev.led) ? 2 : 0)
 822                          | (test_bit(LED_CAPSL,   atkbd->dev.led) ? 4 : 0);
 823
 824                 if (atkbd_probe(atkbd))
 825                         return -1;
 826                 if (atkbd->set != atkbd_set_3(atkbd))
 827                         return -1;
 828
 829                 atkbd_enable(atkbd);
 830
 831                 if (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
 832                         return -1;
 833         }
 834
 835         return 0;
 836 }
 837
 838 static struct serio_dev atkbd_dev = {
 839         .interrupt =    atkbd_interrupt,
 840         .connect =      atkbd_connect,
 841         .reconnect =    atkbd_reconnect,
 842         .disconnect =   atkbd_disconnect,
 843         .cleanup =      atkbd_cleanup,
 844 };
 845
 846 int __init atkbd_init(void)
 847 {
 848         serio_register_device(&atkbd_dev);
 849         return 0;
 850 }
 851
 852 void __exit atkbd_exit(void)
 853 {
 854         serio_unregister_device(&atkbd_dev);
 855 }
 856
 857 module_init(atkbd_init);
 858 module_exit(atkbd_exit);