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