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/slab.h>
  23#include <linux/interrupt.h>
  24#include <linux/init.h>
  25#include <linux/input.h>
  26#include <linux/serio.h>
  27#include <linux/workqueue.h>
  28#include <linux/libps2.h>
  29#include <linux/mutex.h>
  30#include <linux/dmi.h>
  31
  32#define DRIVER_DESC	"AT and PS/2 keyboard driver"
  33
  34MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  35MODULE_DESCRIPTION(DRIVER_DESC);
  36MODULE_LICENSE("GPL");
  37
  38static int atkbd_set = 2;
  39module_param_named(set, atkbd_set, int, 0);
  40MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
  41
  42#if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
  43static bool atkbd_reset;
  44#else
  45static bool atkbd_reset = true;
  46#endif
  47module_param_named(reset, atkbd_reset, bool, 0);
  48MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
  49
  50static bool atkbd_softrepeat;
  51module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
  52MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
  53
  54static bool atkbd_softraw = true;
  55module_param_named(softraw, atkbd_softraw, bool, 0);
  56MODULE_PARM_DESC(softraw, "Use software generated rawmode");
  57
  58static bool atkbd_scroll;
  59module_param_named(scroll, atkbd_scroll, bool, 0);
  60MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
  61
  62static bool atkbd_extra;
  63module_param_named(extra, atkbd_extra, bool, 0);
  64MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
  65
  66static bool atkbd_terminal;
  67module_param_named(terminal, atkbd_terminal, bool, 0);
  68MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
  69
  70/*
  71 * Scancode to keycode tables. These are just the default setting, and
  72 * are loadable via a userland utility.
  73 */
  74
  75#define ATKBD_KEYMAP_SIZE	512
  76
  77static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
  78
  79#ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
  80
  81/* XXX: need a more general approach */
  82
  83#include "hpps2atkbd.h"	/* include the keyboard scancodes */
  84
  85#else
  86	  0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
  87	  0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
  88	  0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
  89	  0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
  90	  0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
  91	  0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
  92	  0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
  93	 82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
  94
  95	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  96	217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
  97	173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
  98	159,  0,115,  0,164,  0,  0,116,158,  0,172,166,  0,  0,  0,142,
  99	157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
 100	226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
 101	  0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
 102	110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
 103
 104	  0,  0,  0, 65, 99,
 105#endif
 106};
 107
 108static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
 109
 110	  0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
 111	131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
 112	134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
 113	136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
 114	125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
 115	113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
 116	108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
 117	 82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,
 118
 119	184,185,186,187, 74, 94, 92, 93,  0,  0,  0,125,126,127,112,  0,
 120	  0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
 121	148,149,147,140
 122};
 123
 124static const unsigned short atkbd_unxlate_table[128] = {
 125          0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
 126         21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
 127         35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
 128         50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
 129         11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
 130        114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
 131         71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
 132         19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
 133};
 134
 135#define ATKBD_CMD_SETLEDS	0x10ed
 136#define ATKBD_CMD_GSCANSET	0x11f0
 137#define ATKBD_CMD_SSCANSET	0x10f0
 138#define ATKBD_CMD_GETID		0x02f2
 139#define ATKBD_CMD_SETREP	0x10f3
 140#define ATKBD_CMD_ENABLE	0x00f4
 141#define ATKBD_CMD_RESET_DIS	0x00f5	/* Reset to defaults and disable */
 142#define ATKBD_CMD_RESET_DEF	0x00f6	/* Reset to defaults */
 143#define ATKBD_CMD_SETALL_MB	0x00f8	/* Set all keys to give break codes */
 144#define ATKBD_CMD_SETALL_MBR	0x00fa  /* ... and repeat */
 145#define ATKBD_CMD_RESET_BAT	0x02ff
 146#define ATKBD_CMD_RESEND	0x00fe
 147#define ATKBD_CMD_EX_ENABLE	0x10ea
 148#define ATKBD_CMD_EX_SETLEDS	0x20eb
 149#define ATKBD_CMD_OK_GETID	0x02e8
 150
 151#define ATKBD_RET_ACK		0xfa
 152#define ATKBD_RET_NAK		0xfe
 153#define ATKBD_RET_BAT		0xaa
 154#define ATKBD_RET_EMUL0		0xe0
 155#define ATKBD_RET_EMUL1		0xe1
 156#define ATKBD_RET_RELEASE	0xf0
 157#define ATKBD_RET_HANJA		0xf1
 158#define ATKBD_RET_HANGEUL	0xf2
 159#define ATKBD_RET_ERR		0xff
 160
 161#define ATKBD_KEY_UNKNOWN	0
 162#define ATKBD_KEY_NULL		255
 163
 164#define ATKBD_SCR_1		0xfffe
 165#define ATKBD_SCR_2		0xfffd
 166#define ATKBD_SCR_4		0xfffc
 167#define ATKBD_SCR_8		0xfffb
 168#define ATKBD_SCR_CLICK		0xfffa
 169#define ATKBD_SCR_LEFT		0xfff9
 170#define ATKBD_SCR_RIGHT		0xfff8
 171
 172#define ATKBD_SPECIAL		ATKBD_SCR_RIGHT
 173
 174#define ATKBD_LED_EVENT_BIT	0
 175#define ATKBD_REP_EVENT_BIT	1
 176
 177#define ATKBD_XL_ERR		0x01
 178#define ATKBD_XL_BAT		0x02
 179#define ATKBD_XL_ACK		0x04
 180#define ATKBD_XL_NAK		0x08
 181#define ATKBD_XL_HANGEUL	0x10
 182#define ATKBD_XL_HANJA		0x20
 183
 184static const struct {
 185	unsigned short keycode;
 186	unsigned char set2;
 187} atkbd_scroll_keys[] = {
 188	{ ATKBD_SCR_1,     0xc5 },
 189	{ ATKBD_SCR_2,     0x9d },
 190	{ ATKBD_SCR_4,     0xa4 },
 191	{ ATKBD_SCR_8,     0x9b },
 192	{ ATKBD_SCR_CLICK, 0xe0 },
 193	{ ATKBD_SCR_LEFT,  0xcb },
 194	{ ATKBD_SCR_RIGHT, 0xd2 },
 195};
 196
 197/*
 198 * The atkbd control structure
 199 */
 200
 201struct atkbd {
 202
 203	struct ps2dev ps2dev;
 204	struct input_dev *dev;
 205
 206	/* Written only during init */
 207	char name[64];
 208	char phys[32];
 209
 210	unsigned short id;
 211	unsigned short keycode[ATKBD_KEYMAP_SIZE];
 212	DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
 213	unsigned char set;
 214	bool translated;
 215	bool extra;
 216	bool write;
 217	bool softrepeat;
 218	bool softraw;
 219	bool scroll;
 220	bool enabled;
 221
 222	/* Accessed only from interrupt */
 223	unsigned char emul;
 224	bool resend;
 225	bool release;
 226	unsigned long xl_bit;
 227	unsigned int last;
 228	unsigned long time;
 229	unsigned long err_count;
 230
 231	struct delayed_work event_work;
 232	unsigned long event_jiffies;
 233	unsigned long event_mask;
 234
 235	/* Serializes reconnect(), attr->set() and event work */
 236	struct mutex mutex;
 237};
 238
 239/*
 240 * System-specific keymap fixup routine
 241 */
 242static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
 243static void *atkbd_platform_fixup_data;
 244static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
 245
 246/*
 247 * Certain keyboards to not like ATKBD_CMD_RESET_DIS and stop responding
 248 * to many commands until full reset (ATKBD_CMD_RESET_BAT) is performed.
 249 */
 250static bool atkbd_skip_deactivate;
 251
 252static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
 253				ssize_t (*handler)(struct atkbd *, char *));
 254static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
 255				ssize_t (*handler)(struct atkbd *, const char *, size_t));
 256#define ATKBD_DEFINE_ATTR(_name)						\
 257static ssize_t atkbd_show_##_name(struct atkbd *, char *);			\
 258static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);		\
 259static ssize_t atkbd_do_show_##_name(struct device *d,				\
 260				struct device_attribute *attr, char *b)		\
 261{										\
 262	return atkbd_attr_show_helper(d, b, atkbd_show_##_name);		\
 263}										\
 264static ssize_t atkbd_do_set_##_name(struct device *d,				\
 265			struct device_attribute *attr, const char *b, size_t s)	\
 266{										\
 267	return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);		\
 268}										\
 269static struct device_attribute atkbd_attr_##_name =				\
 270	__ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
 271
 272ATKBD_DEFINE_ATTR(extra);
 273ATKBD_DEFINE_ATTR(force_release);
 274ATKBD_DEFINE_ATTR(scroll);
 275ATKBD_DEFINE_ATTR(set);
 276ATKBD_DEFINE_ATTR(softrepeat);
 277ATKBD_DEFINE_ATTR(softraw);
 278
 279#define ATKBD_DEFINE_RO_ATTR(_name)						\
 280static ssize_t atkbd_show_##_name(struct atkbd *, char *);			\
 281static ssize_t atkbd_do_show_##_name(struct device *d,				\
 282				struct device_attribute *attr, char *b)		\
 283{										\
 284	return atkbd_attr_show_helper(d, b, atkbd_show_##_name);		\
 285}										\
 286static struct device_attribute atkbd_attr_##_name =				\
 287	__ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
 288
 289ATKBD_DEFINE_RO_ATTR(err_count);
 290
 291static struct attribute *atkbd_attributes[] = {
 292	&atkbd_attr_extra.attr,
 293	&atkbd_attr_force_release.attr,
 294	&atkbd_attr_scroll.attr,
 295	&atkbd_attr_set.attr,
 296	&atkbd_attr_softrepeat.attr,
 297	&atkbd_attr_softraw.attr,
 298	&atkbd_attr_err_count.attr,
 299	NULL
 300};
 301
 302static struct attribute_group atkbd_attribute_group = {
 303	.attrs	= atkbd_attributes,
 304};
 305
 306static const unsigned int xl_table[] = {
 307	ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
 308	ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
 309};
 310
 311/*
 312 * Checks if we should mangle the scancode to extract 'release' bit
 313 * in translated mode.
 314 */
 315static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
 316{
 317	int i;
 318
 319	if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
 320		return false;
 321
 322	for (i = 0; i < ARRAY_SIZE(xl_table); i++)
 323		if (code == xl_table[i])
 324			return test_bit(i, &xl_bit);
 325
 326	return true;
 327}
 328
 329/*
 330 * Calculates new value of xl_bit so the driver can distinguish
 331 * between make/break pair of scancodes for select keys and PS/2
 332 * protocol responses.
 333 */
 334static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
 335{
 336	int i;
 337
 338	for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
 339		if (!((code ^ xl_table[i]) & 0x7f)) {
 340			if (code & 0x80)
 341				__clear_bit(i, &atkbd->xl_bit);
 342			else
 343				__set_bit(i, &atkbd->xl_bit);
 344			break;
 345		}
 346	}
 347}
 348
 349/*
 350 * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
 351 * keeping kernel 2.4 compatibility for set 2
 352 */
 353static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
 354{
 355	if (atkbd->set == 3) {
 356		if (atkbd->emul == 1)
 357			code |= 0x100;
 358        } else {
 359		code = (code & 0x7f) | ((code & 0x80) << 1);
 360		if (atkbd->emul == 1)
 361			code |= 0x80;
 362	}
 363
 364	return code;
 365}
 366
 367/*
 368 * atkbd_interrupt(). Here takes place processing of data received from
 369 * the keyboard into events.
 370 */
 371
 372static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
 373				   unsigned int flags)
 374{
 375	struct atkbd *atkbd = serio_get_drvdata(serio);
 376	struct input_dev *dev = atkbd->dev;
 377	unsigned int code = data;
 378	int scroll = 0, hscroll = 0, click = -1;
 379	int value;
 380	unsigned short keycode;
 381
 382	dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
 383
 384#if !defined(__i386__) && !defined (__x86_64__)
 385	if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
 386		dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
 387		serio_write(serio, ATKBD_CMD_RESEND);
 388		atkbd->resend = true;
 389		goto out;
 390	}
 391
 392	if (!flags && data == ATKBD_RET_ACK)
 393		atkbd->resend = false;
 394#endif
 395
 396	if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
 397		if  (ps2_handle_ack(&atkbd->ps2dev, data))
 398			goto out;
 399
 400	if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
 401		if  (ps2_handle_response(&atkbd->ps2dev, data))
 402			goto out;
 403
 404	if (!atkbd->enabled)
 405		goto out;
 406
 407	input_event(dev, EV_MSC, MSC_RAW, code);
 408
 409	if (atkbd_platform_scancode_fixup)
 410		code = atkbd_platform_scancode_fixup(atkbd, code);
 411
 412	if (atkbd->translated) {
 413
 414		if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
 415			atkbd->release = code >> 7;
 416			code &= 0x7f;
 417		}
 418
 419		if (!atkbd->emul)
 420			atkbd_calculate_xl_bit(atkbd, data);
 421	}
 422
 423	switch (code) {
 424	case ATKBD_RET_BAT:
 425		atkbd->enabled = false;
 426		serio_reconnect(atkbd->ps2dev.serio);
 427		goto out;
 428	case ATKBD_RET_EMUL0:
 429		atkbd->emul = 1;
 430		goto out;
 431	case ATKBD_RET_EMUL1:
 432		atkbd->emul = 2;
 433		goto out;
 434	case ATKBD_RET_RELEASE:
 435		atkbd->release = true;
 436		goto out;
 437	case ATKBD_RET_ACK:
 438	case ATKBD_RET_NAK:
 439		if (printk_ratelimit())
 440			dev_warn(&serio->dev,
 441				 "Spurious %s on %s. "
 442				 "Some program might be trying to access hardware directly.\n",
 443				 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
 444		goto out;
 445	case ATKBD_RET_ERR:
 446		atkbd->err_count++;
 447		dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
 448			serio->phys);
 449		goto out;
 450	}
 451
 452	code = atkbd_compat_scancode(atkbd, code);
 453
 454	if (atkbd->emul && --atkbd->emul)
 455		goto out;
 456
 457	keycode = atkbd->keycode[code];
 458
 459	if (!(atkbd->release && test_bit(code, atkbd->force_release_mask)))
 460		if (keycode != ATKBD_KEY_NULL)
 461			input_event(dev, EV_MSC, MSC_SCAN, code);
 462
 463	switch (keycode) {
 464	case ATKBD_KEY_NULL:
 465		break;
 466	case ATKBD_KEY_UNKNOWN:
 467		dev_warn(&serio->dev,
 468			 "Unknown key %s (%s set %d, code %#x on %s).\n",
 469			 atkbd->release ? "released" : "pressed",
 470			 atkbd->translated ? "translated" : "raw",
 471			 atkbd->set, code, serio->phys);
 472		dev_warn(&serio->dev,
 473			 "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
 474			 code & 0x80 ? "e0" : "", code & 0x7f);
 475		input_sync(dev);
 476		break;
 477	case ATKBD_SCR_1:
 478		scroll = 1;
 479		break;
 480	case ATKBD_SCR_2:
 481		scroll = 2;
 482		break;
 483	case ATKBD_SCR_4:
 484		scroll = 4;
 485		break;
 486	case ATKBD_SCR_8:
 487		scroll = 8;
 488		break;
 489	case ATKBD_SCR_CLICK:
 490		click = !atkbd->release;
 491		break;
 492	case ATKBD_SCR_LEFT:
 493		hscroll = -1;
 494		break;
 495	case ATKBD_SCR_RIGHT:
 496		hscroll = 1;
 497		break;
 498	default:
 499		if (atkbd->release) {
 500			value = 0;
 501			atkbd->last = 0;
 502		} else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
 503			/* Workaround Toshiba laptop multiple keypress */
 504			value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
 505		} else {
 506			value = 1;
 507			atkbd->last = code;
 508			atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
 509		}
 510
 511		input_event(dev, EV_KEY, keycode, value);
 512		input_sync(dev);
 513
 514		if (value && test_bit(code, atkbd->force_release_mask)) {
 515			input_event(dev, EV_MSC, MSC_SCAN, code);
 516			input_report_key(dev, keycode, 0);
 517			input_sync(dev);
 518		}
 519	}
 520
 521	if (atkbd->scroll) {
 522		if (click != -1)
 523			input_report_key(dev, BTN_MIDDLE, click);
 524		input_report_rel(dev, REL_WHEEL,
 525				 atkbd->release ? -scroll : scroll);
 526		input_report_rel(dev, REL_HWHEEL, hscroll);
 527		input_sync(dev);
 528	}
 529
 530	atkbd->release = false;
 531out:
 532	return IRQ_HANDLED;
 533}
 534
 535static int atkbd_set_repeat_rate(struct atkbd *atkbd)
 536{
 537	const short period[32] =
 538		{ 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
 539		 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
 540	const short delay[4] =
 541		{ 250, 500, 750, 1000 };
 542
 543	struct input_dev *dev = atkbd->dev;
 544	unsigned char param;
 545	int i = 0, j = 0;
 546
 547	while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
 548		i++;
 549	dev->rep[REP_PERIOD] = period[i];
 550
 551	while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
 552		j++;
 553	dev->rep[REP_DELAY] = delay[j];
 554
 555	param = i | (j << 5);
 556	return ps2_command(&atkbd->ps2dev, &param, ATKBD_CMD_SETREP);
 557}
 558
 559static int atkbd_set_leds(struct atkbd *atkbd)
 560{
 561	struct input_dev *dev = atkbd->dev;
 562	unsigned char param[2];
 563
 564	param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
 565		 | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
 566		 | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
 567	if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
 568		return -1;
 569
 570	if (atkbd->extra) {
 571		param[0] = 0;
 572		param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
 573			 | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
 574			 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
 575			 | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
 576			 | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
 577		if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
 578			return -1;
 579	}
 580
 581	return 0;
 582}
 583
 584/*
 585 * atkbd_event_work() is used to complete processing of events that
 586 * can not be processed by input_event() which is often called from
 587 * interrupt context.
 588 */
 589
 590static void atkbd_event_work(struct work_struct *work)
 591{
 592	struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
 593
 594	mutex_lock(&atkbd->mutex);
 595
 596	if (!atkbd->enabled) {
 597		/*
 598		 * Serio ports are resumed asynchronously so while driver core
 599		 * thinks that device is already fully operational in reality
 600		 * it may not be ready yet. In this case we need to keep
 601		 * rescheduling till reconnect completes.
 602		 */
 603		schedule_delayed_work(&atkbd->event_work,
 604					msecs_to_jiffies(100));
 605	} else {
 606		if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
 607			atkbd_set_leds(atkbd);
 608
 609		if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
 610			atkbd_set_repeat_rate(atkbd);
 611	}
 612
 613	mutex_unlock(&atkbd->mutex);
 614}
 615
 616/*
 617 * Schedule switch for execution. We need to throttle requests,
 618 * otherwise keyboard may become unresponsive.
 619 */
 620static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
 621{
 622	unsigned long delay = msecs_to_jiffies(50);
 623
 624	if (time_after(jiffies, atkbd->event_jiffies + delay))
 625		delay = 0;
 626
 627	atkbd->event_jiffies = jiffies;
 628	set_bit(event_bit, &atkbd->event_mask);
 629	mb();
 630	schedule_delayed_work(&atkbd->event_work, delay);
 631}
 632
 633/*
 634 * Event callback from the input module. Events that change the state of
 635 * the hardware are processed here. If action can not be performed in
 636 * interrupt context it is offloaded to atkbd_event_work.
 637 */
 638
 639static int atkbd_event(struct input_dev *dev,
 640			unsigned int type, unsigned int code, int value)
 641{
 642	struct atkbd *atkbd = input_get_drvdata(dev);
 643
 644	if (!atkbd->write)
 645		return -1;
 646
 647	switch (type) {
 648
 649	case EV_LED:
 650		atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
 651		return 0;
 652
 653	case EV_REP:
 654		if (!atkbd->softrepeat)
 655			atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
 656		return 0;
 657
 658	default:
 659		return -1;
 660	}
 661}
 662
 663/*
 664 * atkbd_enable() signals that interrupt handler is allowed to
 665 * generate input events.
 666 */
 667
 668static inline void atkbd_enable(struct atkbd *atkbd)
 669{
 670	serio_pause_rx(atkbd->ps2dev.serio);
 671	atkbd->enabled = true;
 672	serio_continue_rx(atkbd->ps2dev.serio);
 673}
 674
 675/*
 676 * atkbd_disable() tells input handler that all incoming data except
 677 * for ACKs and command response should be dropped.
 678 */
 679
 680static inline void atkbd_disable(struct atkbd *atkbd)
 681{
 682	serio_pause_rx(atkbd->ps2dev.serio);
 683	atkbd->enabled = false;
 684	serio_continue_rx(atkbd->ps2dev.serio);
 685}
 686
 687static int atkbd_activate(struct atkbd *atkbd)
 688{
 689	struct ps2dev *ps2dev = &atkbd->ps2dev;
 690
 691/*
 692 * Enable the keyboard to receive keystrokes.
 693 */
 694
 695	if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
 696		dev_err(&ps2dev->serio->dev,
 697			"Failed to enable keyboard on %s\n",
 698			ps2dev->serio->phys);
 699		return -1;
 700	}
 701
 702	return 0;
 703}
 704
 705/*
 706 * atkbd_deactivate() resets and disables the keyboard from sending
 707 * keystrokes.
 708 */
 709
 710static void atkbd_deactivate(struct atkbd *atkbd)
 711{
 712	struct ps2dev *ps2dev = &atkbd->ps2dev;
 713
 714	if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
 715		dev_err(&ps2dev->serio->dev,
 716			"Failed to deactivate keyboard on %s\n",
 717			ps2dev->serio->phys);
 718}
 719
 720/*
 721 * atkbd_probe() probes for an AT keyboard on a serio port.
 722 */
 723
 724static int atkbd_probe(struct atkbd *atkbd)
 725{
 726	struct ps2dev *ps2dev = &atkbd->ps2dev;
 727	unsigned char param[2];
 728
 729/*
 730 * Some systems, where the bit-twiddling when testing the io-lines of the
 731 * controller may confuse the keyboard need a full reset of the keyboard. On
 732 * these systems the BIOS also usually doesn't do it for us.
 733 */
 734
 735	if (atkbd_reset)
 736		if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
 737			dev_warn(&ps2dev->serio->dev,
 738				 "keyboard reset failed on %s\n",
 739				 ps2dev->serio->phys);
 740
 741/*
 742 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
 743 * Some keyboards report different values, but the first byte is always 0xab or
 744 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
 745 * should make sure we don't try to set the LEDs on it.
 746 */
 747
 748	param[0] = param[1] = 0xa5;	/* initialize with invalid values */
 749	if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
 750
 751/*
 752 * If the get ID command failed, we check if we can at least set the LEDs on
 753 * the keyboard. This should work on every keyboard out there. It also turns
 754 * the LEDs off, which we want anyway.
 755 */
 756		param[0] = 0;
 757		if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 758			return -1;
 759		atkbd->id = 0xabba;
 760		return 0;
 761	}
 762
 763	if (!ps2_is_keyboard_id(param[0]))
 764		return -1;
 765
 766	atkbd->id = (param[0] << 8) | param[1];
 767
 768	if (atkbd->id == 0xaca1 && atkbd->translated) {
 769		dev_err(&ps2dev->serio->dev,
 770			"NCD terminal keyboards are only supported on non-translating controllers. "
 771			"Use i8042.direct=1 to disable translation.\n");
 772		return -1;
 773	}
 774
 775/*
 776 * Make sure nothing is coming from the keyboard and disturbs our
 777 * internal state.
 778 */
 779	if (!atkbd_skip_deactivate)
 780		atkbd_deactivate(atkbd);
 781
 782	return 0;
 783}
 784
 785/*
 786 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
 787 * sets it into that. Unfortunately there are keyboards that can be switched
 788 * to Set 3, but don't work well in that (BTC Multimedia ...)
 789 */
 790
 791static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
 792{
 793	struct ps2dev *ps2dev = &atkbd->ps2dev;
 794	unsigned char param[2];
 795
 796	atkbd->extra = false;
 797/*
 798 * For known special keyboards we can go ahead and set the correct set.
 799 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
 800 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
 801 */
 802
 803	if (atkbd->translated)
 804		return 2;
 805
 806	if (atkbd->id == 0xaca1) {
 807		param[0] = 3;
 808		ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
 809		return 3;
 810	}
 811
 812	if (allow_extra) {
 813		param[0] = 0x71;
 814		if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
 815			atkbd->extra = true;
 816			return 2;
 817		}
 818	}
 819
 820	if (atkbd_terminal) {
 821		ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
 822		return 3;
 823	}
 824
 825	if (target_set != 3)
 826		return 2;
 827
 828	if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
 829		atkbd->id = param[0] << 8 | param[1];
 830		return 2;
 831	}
 832
 833	param[0] = 3;
 834	if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 835		return 2;
 836
 837	param[0] = 0;
 838	if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
 839		return 2;
 840
 841	if (param[0] != 3) {
 842		param[0] = 2;
 843		if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
 844		return 2;
 845	}
 846
 847	ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
 848
 849	return 3;
 850}
 851
 852static int atkbd_reset_state(struct atkbd *atkbd)
 853{
 854        struct ps2dev *ps2dev = &atkbd->ps2dev;
 855	unsigned char param[1];
 856
 857/*
 858 * Set the LEDs to a predefined state (all off).
 859 */
 860
 861	param[0] = 0;
 862	if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
 863		return -1;
 864
 865/*
 866 * Set autorepeat to fastest possible.
 867 */
 868
 869	param[0] = 0;
 870	if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
 871		return -1;
 872
 873	return 0;
 874}
 875
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 876/*
 877 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 878 * reboot.
 879 */
 880
 881static void atkbd_cleanup(struct serio *serio)
 882{
 883	struct atkbd *atkbd = serio_get_drvdata(serio);
 884
 885	atkbd_disable(atkbd);
 886	ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
 887}
 888
 889
 890/*
 891 * atkbd_disconnect() closes and frees.
 892 */
 893
 894static void atkbd_disconnect(struct serio *serio)
 895{
 896	struct atkbd *atkbd = serio_get_drvdata(serio);
 897
 898	sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 899
 900	atkbd_disable(atkbd);
 901
 902	input_unregister_device(atkbd->dev);
 903
 904	/*
 905	 * Make sure we don't have a command in flight.
 906	 * Note that since atkbd->enabled is false event work will keep
 907	 * rescheduling itself until it gets canceled and will not try
 908	 * accessing freed input device or serio port.
 909	 */
 910	cancel_delayed_work_sync(&atkbd->event_work);
 911
 912	serio_close(serio);
 913	serio_set_drvdata(serio, NULL);
 914	kfree(atkbd);
 915}
 916
 917/*
 918 * generate release events for the keycodes given in data
 919 */
 920static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
 921						const void *data)
 922{
 923	const unsigned int *keys = data;
 924	unsigned int i;
 925
 926	if (atkbd->set == 2)
 927		for (i = 0; keys[i] != -1U; i++)
 928			__set_bit(keys[i], atkbd->force_release_mask);
 929}
 930
 931/*
 932 * Most special keys (Fn+F?) on Dell laptops do not generate release
 933 * events so we have to do it ourselves.
 934 */
 935static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
 936	0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
 937};
 938
 939/*
 940 * Perform fixup for HP system that doesn't generate release
 941 * for its video switch
 942 */
 943static unsigned int atkbd_hp_forced_release_keys[] = {
 944	0x94, -1U
 945};
 946
 947/*
 948 * Samsung NC10,NC20 with Fn+F? key release not working
 949 */
 950static unsigned int atkbd_samsung_forced_release_keys[] = {
 951	0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
 952};
 953
 954/*
 955 * Amilo Pi 3525 key release for Fn+Volume keys not working
 956 */
 957static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
 958	0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
 959};
 960
 961/*
 962 * Amilo Xi 3650 key release for light touch bar not working
 963 */
 964static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
 965	0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
 966};
 967
 968/*
 969 * Soltech TA12 system with broken key release on volume keys and mute key
 970 */
 971static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
 972	0xa0, 0xae, 0xb0, -1U
 973};
 974
 975/*
 976 * Many notebooks don't send key release event for volume up/down
 977 * keys, with key list below common among them
 978 */
 979static unsigned int atkbd_volume_forced_release_keys[] = {
 980	0xae, 0xb0, -1U
 981};
 982
 983/*
 984 * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
 985 * they should be generating e4-e6 (0x80 | code).
 986 */
 987static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
 988						    unsigned int code)
 989{
 990	if (atkbd->translated && atkbd->emul == 1 &&
 991	    (code == 0x64 || code == 0x65 || code == 0x66)) {
 992		atkbd->emul = 0;
 993		code |= 0x80;
 994	}
 995
 996	return code;
 997}
 998
 999/*
1000 * atkbd_set_keycode_table() initializes keyboard's keycode table
1001 * according to the selected scancode set
1002 */
1003
1004static void atkbd_set_keycode_table(struct atkbd *atkbd)
1005{
1006	unsigned int scancode;
1007	int i, j;
1008
1009	memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1010	bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1011
1012	if (atkbd->translated) {
1013		for (i = 0; i < 128; i++) {
1014			scancode = atkbd_unxlate_table[i];
1015			atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1016			atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1017			if (atkbd->scroll)
1018				for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1019					if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
1020						atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1021		}
1022	} else if (atkbd->set == 3) {
1023		memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1024	} else {
1025		memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1026
1027		if (atkbd->scroll)
1028			for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
1029				scancode = atkbd_scroll_keys[i].set2;
1030				atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1031		}
1032	}
1033
1034/*
1035 * HANGEUL and HANJA keys do not send release events so we need to
1036 * generate such events ourselves
1037 */
1038	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1039	atkbd->keycode[scancode] = KEY_HANGEUL;
1040	__set_bit(scancode, atkbd->force_release_mask);
1041
1042	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1043	atkbd->keycode[scancode] = KEY_HANJA;
1044	__set_bit(scancode, atkbd->force_release_mask);
1045
1046/*
1047 * Perform additional fixups
1048 */
1049	if (atkbd_platform_fixup)
1050		atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1051}
1052
1053/*
1054 * atkbd_set_device_attrs() sets up keyboard's input device structure
1055 */
1056
1057static void atkbd_set_device_attrs(struct atkbd *atkbd)
1058{
1059	struct input_dev *input_dev = atkbd->dev;
1060	int i;
1061
1062	if (atkbd->extra)
1063		snprintf(atkbd->name, sizeof(atkbd->name),
1064			 "AT Set 2 Extra keyboard");
1065	else
1066		snprintf(atkbd->name, sizeof(atkbd->name),
1067			 "AT %s Set %d keyboard",
1068			 atkbd->translated ? "Translated" : "Raw", atkbd->set);
1069
1070	snprintf(atkbd->phys, sizeof(atkbd->phys),
1071		 "%s/input0", atkbd->ps2dev.serio->phys);
1072
1073	input_dev->name = atkbd->name;
1074	input_dev->phys = atkbd->phys;
1075	input_dev->id.bustype = BUS_I8042;
1076	input_dev->id.vendor = 0x0001;
1077	input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1078	input_dev->id.version = atkbd->id;
1079	input_dev->event = atkbd_event;
1080	input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1081
1082	input_set_drvdata(input_dev, atkbd);
1083
1084	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1085		BIT_MASK(EV_MSC);
1086
1087	if (atkbd->write) {
1088		input_dev->evbit[0] |= BIT_MASK(EV_LED);
1089		input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1090			BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1091	}
1092
1093	if (atkbd->extra)
1094		input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1095			BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1096			BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1097
1098	if (!atkbd->softrepeat) {
1099		input_dev->rep[REP_DELAY] = 250;
1100		input_dev->rep[REP_PERIOD] = 33;
1101	}
1102
1103	input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1104		BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1105
1106	if (atkbd->scroll) {
1107		input_dev->evbit[0] |= BIT_MASK(EV_REL);
1108		input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1109			BIT_MASK(REL_HWHEEL);
1110		__set_bit(BTN_MIDDLE, input_dev->keybit);
1111	}
1112
1113	input_dev->keycode = atkbd->keycode;
1114	input_dev->keycodesize = sizeof(unsigned short);
1115	input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1116
1117	for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1118		if (atkbd->keycode[i] != KEY_RESERVED &&
1119		    atkbd->keycode[i] != ATKBD_KEY_NULL &&
1120		    atkbd->keycode[i] < ATKBD_SPECIAL) {
1121			__set_bit(atkbd->keycode[i], input_dev->keybit);
1122		}
1123	}
1124}
1125
1126/*
1127 * atkbd_connect() is called when the serio module finds an interface
1128 * that isn't handled yet by an appropriate device driver. We check if
1129 * there is an AT keyboard out there and if yes, we register ourselves
1130 * to the input module.
1131 */
1132
1133static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1134{
1135	struct atkbd *atkbd;
1136	struct input_dev *dev;
1137	int err = -ENOMEM;
1138
1139	atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1140	dev = input_allocate_device();
1141	if (!atkbd || !dev)
1142		goto fail1;
1143
1144	atkbd->dev = dev;
1145	ps2_init(&atkbd->ps2dev, serio);
1146	INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1147	mutex_init(&atkbd->mutex);
1148
1149	switch (serio->id.type) {
1150
1151	case SERIO_8042_XL:
1152		atkbd->translated = true;
1153		/* Fall through */
1154
1155	case SERIO_8042:
1156		if (serio->write)
1157			atkbd->write = true;
1158		break;
1159	}
1160
1161	atkbd->softraw = atkbd_softraw;
1162	atkbd->softrepeat = atkbd_softrepeat;
1163	atkbd->scroll = atkbd_scroll;
1164
1165	if (atkbd->softrepeat)
1166		atkbd->softraw = true;
1167
1168	serio_set_drvdata(serio, atkbd);
1169
1170	err = serio_open(serio, drv);
1171	if (err)
1172		goto fail2;
1173
1174	if (atkbd->write) {
1175
1176		if (atkbd_probe(atkbd)) {
1177			err = -ENODEV;
1178			goto fail3;
1179		}
1180
1181		atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1182		atkbd_reset_state(atkbd);
 
1183
1184	} else {
1185		atkbd->set = 2;
1186		atkbd->id = 0xab00;
1187	}
1188
1189	atkbd_set_keycode_table(atkbd);
1190	atkbd_set_device_attrs(atkbd);
1191
1192	err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1193	if (err)
1194		goto fail3;
1195
1196	atkbd_enable(atkbd);
1197	if (serio->write)
1198		atkbd_activate(atkbd);
1199
1200	err = input_register_device(atkbd->dev);
1201	if (err)
1202		goto fail4;
1203
1204	return 0;
1205
1206 fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1207 fail3:	serio_close(serio);
1208 fail2:	serio_set_drvdata(serio, NULL);
1209 fail1:	input_free_device(dev);
1210	kfree(atkbd);
1211	return err;
1212}
1213
1214/*
1215 * atkbd_reconnect() tries to restore keyboard into a sane state and is
1216 * most likely called on resume.
1217 */
1218
1219static int atkbd_reconnect(struct serio *serio)
1220{
1221	struct atkbd *atkbd = serio_get_drvdata(serio);
1222	struct serio_driver *drv = serio->drv;
1223	int retval = -1;
1224
1225	if (!atkbd || !drv) {
1226		dev_dbg(&serio->dev,
1227			"reconnect request, but serio is disconnected, ignoring...\n");
1228		return -1;
1229	}
1230
1231	mutex_lock(&atkbd->mutex);
1232
1233	atkbd_disable(atkbd);
1234
1235	if (atkbd->write) {
1236		if (atkbd_probe(atkbd))
1237			goto out;
1238
1239		if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1240			goto out;
1241
 
 
1242		/*
1243		 * Restore LED state and repeat rate. While input core
1244		 * will do this for us at resume time reconnect may happen
1245		 * because user requested it via sysfs or simply because
1246		 * keyboard was unplugged and plugged in again so we need
1247		 * to do it ourselves here.
1248		 */
1249		atkbd_set_leds(atkbd);
1250		if (!atkbd->softrepeat)
1251			atkbd_set_repeat_rate(atkbd);
1252
1253	}
1254
1255	/*
1256	 * Reset our state machine in case reconnect happened in the middle
1257	 * of multi-byte scancode.
1258	 */
1259	atkbd->xl_bit = 0;
1260	atkbd->emul = 0;
1261
1262	atkbd_enable(atkbd);
1263	if (atkbd->write)
1264		atkbd_activate(atkbd);
1265
1266	retval = 0;
1267
1268 out:
1269	mutex_unlock(&atkbd->mutex);
1270	return retval;
1271}
1272
1273static struct serio_device_id atkbd_serio_ids[] = {
1274	{
1275		.type	= SERIO_8042,
1276		.proto	= SERIO_ANY,
1277		.id	= SERIO_ANY,
1278		.extra	= SERIO_ANY,
1279	},
1280	{
1281		.type	= SERIO_8042_XL,
1282		.proto	= SERIO_ANY,
1283		.id	= SERIO_ANY,
1284		.extra	= SERIO_ANY,
1285	},
1286	{
1287		.type	= SERIO_RS232,
1288		.proto	= SERIO_PS2SER,
1289		.id	= SERIO_ANY,
1290		.extra	= SERIO_ANY,
1291	},
1292	{ 0 }
1293};
1294
1295MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1296
1297static struct serio_driver atkbd_drv = {
1298	.driver		= {
1299		.name	= "atkbd",
1300	},
1301	.description	= DRIVER_DESC,
1302	.id_table	= atkbd_serio_ids,
1303	.interrupt	= atkbd_interrupt,
1304	.connect	= atkbd_connect,
1305	.reconnect	= atkbd_reconnect,
1306	.disconnect	= atkbd_disconnect,
1307	.cleanup	= atkbd_cleanup,
1308};
1309
1310static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1311				ssize_t (*handler)(struct atkbd *, char *))
1312{
1313	struct serio *serio = to_serio_port(dev);
1314	struct atkbd *atkbd = serio_get_drvdata(serio);
1315
1316	return handler(atkbd, buf);
1317}
1318
1319static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1320				ssize_t (*handler)(struct atkbd *, const char *, size_t))
1321{
1322	struct serio *serio = to_serio_port(dev);
1323	struct atkbd *atkbd = serio_get_drvdata(serio);
1324	int retval;
1325
1326	retval = mutex_lock_interruptible(&atkbd->mutex);
1327	if (retval)
1328		return retval;
1329
1330	atkbd_disable(atkbd);
1331	retval = handler(atkbd, buf, count);
1332	atkbd_enable(atkbd);
1333
1334	mutex_unlock(&atkbd->mutex);
1335
1336	return retval;
1337}
1338
1339static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1340{
1341	return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1342}
1343
1344static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1345{
1346	struct input_dev *old_dev, *new_dev;
1347	unsigned int value;
1348	int err;
1349	bool old_extra;
1350	unsigned char old_set;
1351
1352	if (!atkbd->write)
1353		return -EIO;
1354
1355	err = kstrtouint(buf, 10, &value);
1356	if (err)
1357		return err;
1358
1359	if (value > 1)
1360		return -EINVAL;
1361
1362	if (atkbd->extra != value) {
1363		/*
1364		 * Since device's properties will change we need to
1365		 * unregister old device. But allocate and register
1366		 * new one first to make sure we have it.
1367		 */
1368		old_dev = atkbd->dev;
1369		old_extra = atkbd->extra;
1370		old_set = atkbd->set;
1371
1372		new_dev = input_allocate_device();
1373		if (!new_dev)
1374			return -ENOMEM;
1375
1376		atkbd->dev = new_dev;
1377		atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1378		atkbd_reset_state(atkbd);
1379		atkbd_activate(atkbd);
1380		atkbd_set_keycode_table(atkbd);
1381		atkbd_set_device_attrs(atkbd);
1382
1383		err = input_register_device(atkbd->dev);
1384		if (err) {
1385			input_free_device(new_dev);
1386
1387			atkbd->dev = old_dev;
1388			atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1389			atkbd_set_keycode_table(atkbd);
1390			atkbd_set_device_attrs(atkbd);
1391
1392			return err;
1393		}
1394		input_unregister_device(old_dev);
1395
1396	}
1397	return count;
1398}
1399
1400static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1401{
1402	size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
1403			       ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1404
1405	buf[len++] = '\n';
1406	buf[len] = '\0';
1407
1408	return len;
1409}
1410
1411static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1412					const char *buf, size_t count)
1413{
1414	/* 64 bytes on stack should be acceptable */
1415	DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1416	int err;
1417
1418	err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1419	if (err)
1420		return err;
1421
1422	memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1423	return count;
1424}
1425
1426
1427static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1428{
1429	return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1430}
1431
1432static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1433{
1434	struct input_dev *old_dev, *new_dev;
1435	unsigned int value;
1436	int err;
1437	bool old_scroll;
1438
1439	err = kstrtouint(buf, 10, &value);
1440	if (err)
1441		return err;
1442
1443	if (value > 1)
1444		return -EINVAL;
1445
1446	if (atkbd->scroll != value) {
1447		old_dev = atkbd->dev;
1448		old_scroll = atkbd->scroll;
1449
1450		new_dev = input_allocate_device();
1451		if (!new_dev)
1452			return -ENOMEM;
1453
1454		atkbd->dev = new_dev;
1455		atkbd->scroll = value;
1456		atkbd_set_keycode_table(atkbd);
1457		atkbd_set_device_attrs(atkbd);
1458
1459		err = input_register_device(atkbd->dev);
1460		if (err) {
1461			input_free_device(new_dev);
1462
1463			atkbd->scroll = old_scroll;
1464			atkbd->dev = old_dev;
1465			atkbd_set_keycode_table(atkbd);
1466			atkbd_set_device_attrs(atkbd);
1467
1468			return err;
1469		}
1470		input_unregister_device(old_dev);
1471	}
1472	return count;
1473}
1474
1475static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1476{
1477	return sprintf(buf, "%d\n", atkbd->set);
1478}
1479
1480static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1481{
1482	struct input_dev *old_dev, *new_dev;
1483	unsigned int value;
1484	int err;
1485	unsigned char old_set;
1486	bool old_extra;
1487
1488	if (!atkbd->write)
1489		return -EIO;
1490
1491	err = kstrtouint(buf, 10, &value);
1492	if (err)
1493		return err;
1494
1495	if (value != 2 && value != 3)
1496		return -EINVAL;
1497
1498	if (atkbd->set != value) {
1499		old_dev = atkbd->dev;
1500		old_extra = atkbd->extra;
1501		old_set = atkbd->set;
1502
1503		new_dev = input_allocate_device();
1504		if (!new_dev)
1505			return -ENOMEM;
1506
1507		atkbd->dev = new_dev;
1508		atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1509		atkbd_reset_state(atkbd);
1510		atkbd_activate(atkbd);
1511		atkbd_set_keycode_table(atkbd);
1512		atkbd_set_device_attrs(atkbd);
1513
1514		err = input_register_device(atkbd->dev);
1515		if (err) {
1516			input_free_device(new_dev);
1517
1518			atkbd->dev = old_dev;
1519			atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1520			atkbd_set_keycode_table(atkbd);
1521			atkbd_set_device_attrs(atkbd);
1522
1523			return err;
1524		}
1525		input_unregister_device(old_dev);
1526	}
1527	return count;
1528}
1529
1530static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1531{
1532	return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1533}
1534
1535static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1536{
1537	struct input_dev *old_dev, *new_dev;
1538	unsigned int value;
1539	int err;
1540	bool old_softrepeat, old_softraw;
1541
1542	if (!atkbd->write)
1543		return -EIO;
1544
1545	err = kstrtouint(buf, 10, &value);
1546	if (err)
1547		return err;
1548
1549	if (value > 1)
1550		return -EINVAL;
1551
1552	if (atkbd->softrepeat != value) {
1553		old_dev = atkbd->dev;
1554		old_softrepeat = atkbd->softrepeat;
1555		old_softraw = atkbd->softraw;
1556
1557		new_dev = input_allocate_device();
1558		if (!new_dev)
1559			return -ENOMEM;
1560
1561		atkbd->dev = new_dev;
1562		atkbd->softrepeat = value;
1563		if (atkbd->softrepeat)
1564			atkbd->softraw = true;
1565		atkbd_set_device_attrs(atkbd);
1566
1567		err = input_register_device(atkbd->dev);
1568		if (err) {
1569			input_free_device(new_dev);
1570
1571			atkbd->dev = old_dev;
1572			atkbd->softrepeat = old_softrepeat;
1573			atkbd->softraw = old_softraw;
1574			atkbd_set_device_attrs(atkbd);
1575
1576			return err;
1577		}
1578		input_unregister_device(old_dev);
1579	}
1580	return count;
1581}
1582
1583
1584static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1585{
1586	return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1587}
1588
1589static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1590{
1591	struct input_dev *old_dev, *new_dev;
1592	unsigned int value;
1593	int err;
1594	bool old_softraw;
1595
1596	err = kstrtouint(buf, 10, &value);
1597	if (err)
1598		return err;
1599
1600	if (value > 1)
1601		return -EINVAL;
1602
1603	if (atkbd->softraw != value) {
1604		old_dev = atkbd->dev;
1605		old_softraw = atkbd->softraw;
1606
1607		new_dev = input_allocate_device();
1608		if (!new_dev)
1609			return -ENOMEM;
1610
1611		atkbd->dev = new_dev;
1612		atkbd->softraw = value;
1613		atkbd_set_device_attrs(atkbd);
1614
1615		err = input_register_device(atkbd->dev);
1616		if (err) {
1617			input_free_device(new_dev);
1618
1619			atkbd->dev = old_dev;
1620			atkbd->softraw = old_softraw;
1621			atkbd_set_device_attrs(atkbd);
1622
1623			return err;
1624		}
1625		input_unregister_device(old_dev);
1626	}
1627	return count;
1628}
1629
1630static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1631{
1632	return sprintf(buf, "%lu\n", atkbd->err_count);
1633}
1634
1635static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1636{
1637	atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1638	atkbd_platform_fixup_data = id->driver_data;
1639
1640	return 1;
1641}
1642
1643static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1644{
1645	atkbd_platform_scancode_fixup = id->driver_data;
1646
1647	return 1;
1648}
1649
1650static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
1651{
1652	atkbd_skip_deactivate = true;
1653	return 1;
1654}
1655
1656/*
1657 * NOTE: do not add any more "force release" quirks to this table.  The
1658 * task of adjusting list of keys that should be "released" automatically
1659 * by the driver is now delegated to userspace tools, such as udev, so
1660 * submit such quirks there.
1661 */
1662static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1663	{
1664		.matches = {
1665			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1666			DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1667		},
1668		.callback = atkbd_setup_forced_release,
1669		.driver_data = atkbd_dell_laptop_forced_release_keys,
1670	},
1671	{
1672		.matches = {
1673			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1674			DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1675		},
1676		.callback = atkbd_setup_forced_release,
1677		.driver_data = atkbd_dell_laptop_forced_release_keys,
1678	},
1679	{
1680		.matches = {
1681			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1682			DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1683		},
1684		.callback = atkbd_setup_forced_release,
1685		.driver_data = atkbd_hp_forced_release_keys,
1686	},
1687	{
1688		.matches = {
1689			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1690			DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1691		},
1692		.callback = atkbd_setup_forced_release,
1693		.driver_data = atkbd_volume_forced_release_keys,
1694	},
1695	{
1696		.matches = {
1697			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1698			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1699		},
1700		.callback = atkbd_setup_forced_release,
1701		.driver_data = atkbd_volume_forced_release_keys,
1702	},
1703	{
1704		.matches = {
1705			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1706			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1707		},
1708		.callback = atkbd_setup_forced_release,
1709		.driver_data = atkbd_volume_forced_release_keys,
1710	},
1711	{
1712		.matches = {
1713			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1714			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1715		},
1716		.callback = atkbd_setup_forced_release,
1717		.driver_data = atkbd_volume_forced_release_keys,
1718	},
1719	{
1720		/* Inventec Symphony */
1721		.matches = {
1722			DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1723			DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1724		},
1725		.callback = atkbd_setup_forced_release,
1726		.driver_data = atkbd_volume_forced_release_keys,
1727	},
1728	{
1729		/* Samsung NC10 */
1730		.matches = {
1731			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1732			DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1733		},
1734		.callback = atkbd_setup_forced_release,
1735		.driver_data = atkbd_samsung_forced_release_keys,
1736	},
1737	{
1738		/* Samsung NC20 */
1739		.matches = {
1740			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1741			DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1742		},
1743		.callback = atkbd_setup_forced_release,
1744		.driver_data = atkbd_samsung_forced_release_keys,
1745	},
1746	{
1747		/* Samsung SQ45S70S */
1748		.matches = {
1749			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1750			DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1751		},
1752		.callback = atkbd_setup_forced_release,
1753		.driver_data = atkbd_samsung_forced_release_keys,
1754	},
1755	{
1756		/* Fujitsu Amilo PA 1510 */
1757		.matches = {
1758			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1759			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1760		},
1761		.callback = atkbd_setup_forced_release,
1762		.driver_data = atkbd_volume_forced_release_keys,
1763	},
1764	{
1765		/* Fujitsu Amilo Pi 3525 */
1766		.matches = {
1767			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1768			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1769		},
1770		.callback = atkbd_setup_forced_release,
1771		.driver_data = atkbd_amilo_pi3525_forced_release_keys,
1772	},
1773	{
1774		/* Fujitsu Amilo Xi 3650 */
1775		.matches = {
1776			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1777			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1778		},
1779		.callback = atkbd_setup_forced_release,
1780		.driver_data = atkbd_amilo_xi3650_forced_release_keys,
1781	},
1782	{
1783		.matches = {
1784			DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1785			DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1786		},
1787		.callback = atkbd_setup_forced_release,
1788		.driver_data = atkdb_soltech_ta12_forced_release_keys,
1789	},
1790	{
1791		/* OQO Model 01+ */
1792		.matches = {
1793			DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1794			DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1795		},
1796		.callback = atkbd_setup_scancode_fixup,
1797		.driver_data = atkbd_oqo_01plus_scancode_fixup,
1798	},
1799	{
1800		.matches = {
1801			DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
1802		},
1803		.callback = atkbd_deactivate_fixup,
1804	},
1805	{ }
1806};
1807
1808static int __init atkbd_init(void)
1809{
1810	dmi_check_system(atkbd_dmi_quirk_table);
1811
1812	return serio_register_driver(&atkbd_drv);
1813}
1814
1815static void __exit atkbd_exit(void)
1816{
1817	serio_unregister_driver(&atkbd_drv);
1818}
1819
1820module_init(atkbd_init);
1821module_exit(atkbd_exit);