PageRenderTime 69ms CodeModel.GetById 8ms app.highlight 53ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/input/keyboard/atkbd.c

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