atkbd.c 44.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * AT and PS/2 keyboard driver
 *
 * Copyright (c) 1999-2002 Vojtech Pavlik
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

/*
 * This driver can handle standard AT keyboards and PS/2 keyboards in
 * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
 * input-only controllers and AT keyboards connected over a one way RS232
 * converter.
 */

#include <linux/delay.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <linux/workqueue.h>
#include <linux/libps2.h>
29
#include <linux/mutex.h>
30
#include <linux/dmi.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38 39 40 41 42

#define DRIVER_DESC	"AT and PS/2 keyboard driver"

MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

static int atkbd_set = 2;
module_param_named(set, atkbd_set, int, 0);
MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");

#if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
43
static bool atkbd_reset;
Linus Torvalds's avatar
Linus Torvalds committed
44
#else
45
static bool atkbd_reset = true;
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49
#endif
module_param_named(reset, atkbd_reset, bool, 0);
MODULE_PARM_DESC(reset, "Reset keyboard during initialization");

50
static bool atkbd_softrepeat;
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53
module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");

54
static bool atkbd_softraw = true;
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57
module_param_named(softraw, atkbd_softraw, bool, 0);
MODULE_PARM_DESC(softraw, "Use software generated rawmode");

58
static bool atkbd_scroll;
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61
module_param_named(scroll, atkbd_scroll, bool, 0);
MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");

62
static bool atkbd_extra;
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65
module_param_named(extra, atkbd_extra, bool, 0);
MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");

66 67 68 69
static bool atkbd_terminal;
module_param_named(terminal, atkbd_terminal, bool, 0);
MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");

Linus Torvalds's avatar
Linus Torvalds committed
70 71
/*
 * Scancode to keycode tables. These are just the default setting, and
72
 * are loadable via a userland utility.
Linus Torvalds's avatar
Linus Torvalds committed
73 74
 */

75 76 77
#define ATKBD_KEYMAP_SIZE	512

static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
Linus Torvalds's avatar
Linus Torvalds committed
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

#ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES

/* XXX: need a more general approach */

#include "hpps2atkbd.h"	/* include the keyboard scancodes */

#else
	  0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
	  0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
	  0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
	  0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
	  0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
	  0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
	  0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
	 82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,

	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
	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,
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105 106 107
	157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
	226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
	110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,

	  0,  0,  0, 65, 99,
#endif
};

108
static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113 114 115 116 117 118 119

	  0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
	131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
	134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
	136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
	125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
	113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
	108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
	 82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,

	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,
Linus Torvalds's avatar
Linus Torvalds committed
121 122 123
	148,149,147,140
};

124
static const unsigned short atkbd_unxlate_table[128] = {
Linus Torvalds's avatar
Linus Torvalds committed
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
          0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
         21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
         35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
         50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
         11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
        114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
         71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
         19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
};

#define ATKBD_CMD_SETLEDS	0x10ed
#define ATKBD_CMD_GSCANSET	0x11f0
#define ATKBD_CMD_SSCANSET	0x10f0
#define ATKBD_CMD_GETID		0x02f2
#define ATKBD_CMD_SETREP	0x10f3
#define ATKBD_CMD_ENABLE	0x00f4
141 142
#define ATKBD_CMD_RESET_DIS	0x00f5	/* Reset to defaults and disable */
#define ATKBD_CMD_RESET_DEF	0x00f6	/* Reset to defaults */
143 144
#define ATKBD_CMD_SETALL_MB	0x00f8	/* Set all keys to give break codes */
#define ATKBD_CMD_SETALL_MBR	0x00fa  /* ... and repeat */
Linus Torvalds's avatar
Linus Torvalds committed
145 146 147 148 149 150 151 152 153 154 155 156
#define ATKBD_CMD_RESET_BAT	0x02ff
#define ATKBD_CMD_RESEND	0x00fe
#define ATKBD_CMD_EX_ENABLE	0x10ea
#define ATKBD_CMD_EX_SETLEDS	0x20eb
#define ATKBD_CMD_OK_GETID	0x02e8

#define ATKBD_RET_ACK		0xfa
#define ATKBD_RET_NAK		0xfe
#define ATKBD_RET_BAT		0xaa
#define ATKBD_RET_EMUL0		0xe0
#define ATKBD_RET_EMUL1		0xe1
#define ATKBD_RET_RELEASE	0xf0
157 158
#define ATKBD_RET_HANJA		0xf1
#define ATKBD_RET_HANGEUL	0xf2
Linus Torvalds's avatar
Linus Torvalds committed
159 160
#define ATKBD_RET_ERR		0xff

161
#define ATKBD_KEY_UNKNOWN	0
Linus Torvalds's avatar
Linus Torvalds committed
162 163
#define ATKBD_KEY_NULL		255

164 165 166 167 168 169 170
#define ATKBD_SCR_1		0xfffe
#define ATKBD_SCR_2		0xfffd
#define ATKBD_SCR_4		0xfffc
#define ATKBD_SCR_8		0xfffb
#define ATKBD_SCR_CLICK		0xfffa
#define ATKBD_SCR_LEFT		0xfff9
#define ATKBD_SCR_RIGHT		0xfff8
Linus Torvalds's avatar
Linus Torvalds committed
171

172
#define ATKBD_SPECIAL		ATKBD_SCR_RIGHT
Linus Torvalds's avatar
Linus Torvalds committed
173

174 175 176
#define ATKBD_LED_EVENT_BIT	0
#define ATKBD_REP_EVENT_BIT	1

177 178 179 180 181 182 183
#define ATKBD_XL_ERR		0x01
#define ATKBD_XL_BAT		0x02
#define ATKBD_XL_ACK		0x04
#define ATKBD_XL_NAK		0x08
#define ATKBD_XL_HANGEUL	0x10
#define ATKBD_XL_HANJA		0x20

184
static const struct {
185
	unsigned short keycode;
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188
	unsigned char set2;
} atkbd_scroll_keys[] = {
	{ ATKBD_SCR_1,     0xc5 },
189 190 191
	{ ATKBD_SCR_2,     0x9d },
	{ ATKBD_SCR_4,     0xa4 },
	{ ATKBD_SCR_8,     0x9b },
Linus Torvalds's avatar
Linus Torvalds committed
192 193 194 195 196 197 198 199 200 201 202
	{ ATKBD_SCR_CLICK, 0xe0 },
	{ ATKBD_SCR_LEFT,  0xcb },
	{ ATKBD_SCR_RIGHT, 0xd2 },
};

/*
 * The atkbd control structure
 */

struct atkbd {

203 204
	struct ps2dev ps2dev;
	struct input_dev *dev;
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208 209 210

	/* Written only during init */
	char name[64];
	char phys[32];

	unsigned short id;
211 212
	unsigned short keycode[ATKBD_KEYMAP_SIZE];
	DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
213
	unsigned char set;
214 215 216 217 218 219 220
	bool translated;
	bool extra;
	bool write;
	bool softrepeat;
	bool softraw;
	bool scroll;
	bool enabled;
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223

	/* Accessed only from interrupt */
	unsigned char emul;
224 225
	bool resend;
	bool release;
226
	unsigned long xl_bit;
Linus Torvalds's avatar
Linus Torvalds committed
227 228
	unsigned int last;
	unsigned long time;
229
	unsigned long err_count;
230

231 232
	struct delayed_work event_work;
	unsigned long event_jiffies;
233
	unsigned long event_mask;
234 235 236

	/* Serializes reconnect(), attr->set() and event work */
	struct mutex mutex;
Linus Torvalds's avatar
Linus Torvalds committed
237 238
};

239
/*
240
 * System-specific keymap fixup routine
241
 */
242 243
static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
static void *atkbd_platform_fixup_data;
244
static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
245

246 247 248 249 250 251
/*
 * Certain keyboards to not like ATKBD_CMD_RESET_DIS and stop responding
 * to many commands until full reset (ATKBD_CMD_RESET_BAT) is performed.
 */
static bool atkbd_skip_deactivate;

Linus Torvalds's avatar
Linus Torvalds committed
252 253 254 255 256 257 258
static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
				ssize_t (*handler)(struct atkbd *, char *));
static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
				ssize_t (*handler)(struct atkbd *, const char *, size_t));
#define ATKBD_DEFINE_ATTR(_name)						\
static ssize_t atkbd_show_##_name(struct atkbd *, char *);			\
static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);		\
259 260
static ssize_t atkbd_do_show_##_name(struct device *d,				\
				struct device_attribute *attr, char *b)		\
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263
{										\
	return atkbd_attr_show_helper(d, b, atkbd_show_##_name);		\
}										\
264 265
static ssize_t atkbd_do_set_##_name(struct device *d,				\
			struct device_attribute *attr, const char *b, size_t s)	\
Linus Torvalds's avatar
Linus Torvalds committed
266 267 268
{										\
	return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);		\
}										\
269
static struct device_attribute atkbd_attr_##_name =				\
Linus Torvalds's avatar
Linus Torvalds committed
270 271 272
	__ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);

ATKBD_DEFINE_ATTR(extra);
273
ATKBD_DEFINE_ATTR(force_release);
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278
ATKBD_DEFINE_ATTR(scroll);
ATKBD_DEFINE_ATTR(set);
ATKBD_DEFINE_ATTR(softrepeat);
ATKBD_DEFINE_ATTR(softraw);

279 280 281 282 283 284 285 286 287 288 289 290 291 292
#define ATKBD_DEFINE_RO_ATTR(_name)						\
static ssize_t atkbd_show_##_name(struct atkbd *, char *);			\
static ssize_t atkbd_do_show_##_name(struct device *d,				\
				struct device_attribute *attr, char *b)		\
{										\
	return atkbd_attr_show_helper(d, b, atkbd_show_##_name);		\
}										\
static struct device_attribute atkbd_attr_##_name =				\
	__ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);

ATKBD_DEFINE_RO_ATTR(err_count);

static struct attribute *atkbd_attributes[] = {
	&atkbd_attr_extra.attr,
293
	&atkbd_attr_force_release.attr,
294 295 296 297 298 299 300 301 302 303 304 305
	&atkbd_attr_scroll.attr,
	&atkbd_attr_set.attr,
	&atkbd_attr_softrepeat.attr,
	&atkbd_attr_softraw.attr,
	&atkbd_attr_err_count.attr,
	NULL
};

static struct attribute_group atkbd_attribute_group = {
	.attrs	= atkbd_attributes,
};

306 307 308 309
static const unsigned int xl_table[] = {
	ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
	ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
};
Linus Torvalds's avatar
Linus Torvalds committed
310

311 312 313 314
/*
 * Checks if we should mangle the scancode to extract 'release' bit
 * in translated mode.
 */
315
static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
Linus Torvalds's avatar
Linus Torvalds committed
316
{
317 318 319
	int i;

	if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
320
		return false;
321 322 323 324 325

	for (i = 0; i < ARRAY_SIZE(xl_table); i++)
		if (code == xl_table[i])
			return test_bit(i, &xl_bit);

326
	return true;
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
}

/*
 * Calculates new value of xl_bit so the driver can distinguish
 * between make/break pair of scancodes for select keys and PS/2
 * protocol responses.
 */
static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
		if (!((code ^ xl_table[i]) & 0x7f)) {
			if (code & 0x80)
				__clear_bit(i, &atkbd->xl_bit);
			else
				__set_bit(i, &atkbd->xl_bit);
			break;
		}
	}
}

/*
 * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
 * keeping kernel 2.4 compatibility for set 2
 */
static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
{
	if (atkbd->set == 3) {
		if (atkbd->emul == 1)
			code |= 0x100;
        } else {
		code = (code & 0x7f) | ((code & 0x80) << 1);
		if (atkbd->emul == 1)
			code |= 0x80;
	}

	return code;
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368 369 370 371 372
}

/*
 * atkbd_interrupt(). Here takes place processing of data received from
 * the keyboard into events.
 */

static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
373
				   unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
374 375
{
	struct atkbd *atkbd = serio_get_drvdata(serio);
376
	struct input_dev *dev = atkbd->dev;
Linus Torvalds's avatar
Linus Torvalds committed
377
	unsigned int code = data;
378
	int scroll = 0, hscroll = 0, click = -1;
Linus Torvalds's avatar
Linus Torvalds committed
379
	int value;
380
	unsigned short keycode;
Linus Torvalds's avatar
Linus Torvalds committed
381

382
	dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
Linus Torvalds's avatar
Linus Torvalds committed
383 384 385

#if !defined(__i386__) && !defined (__x86_64__)
	if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
386
		dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
Linus Torvalds's avatar
Linus Torvalds committed
387
		serio_write(serio, ATKBD_CMD_RESEND);
388
		atkbd->resend = true;
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392
		goto out;
	}

	if (!flags && data == ATKBD_RET_ACK)
393
		atkbd->resend = false;
Linus Torvalds's avatar
Linus Torvalds committed
394 395 396 397 398 399 400 401 402 403 404 405 406
#endif

	if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
		if  (ps2_handle_ack(&atkbd->ps2dev, data))
			goto out;

	if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
		if  (ps2_handle_response(&atkbd->ps2dev, data))
			goto out;

	if (!atkbd->enabled)
		goto out;

407
	input_event(dev, EV_MSC, MSC_RAW, code);
Linus Torvalds's avatar
Linus Torvalds committed
408

409 410 411
	if (atkbd_platform_scancode_fixup)
		code = atkbd_platform_scancode_fixup(atkbd, code);

Linus Torvalds's avatar
Linus Torvalds committed
412 413
	if (atkbd->translated) {

414
		if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418
			atkbd->release = code >> 7;
			code &= 0x7f;
		}

419 420
		if (!atkbd->emul)
			atkbd_calculate_xl_bit(atkbd, data);
Linus Torvalds's avatar
Linus Torvalds committed
421 422 423
	}

	switch (code) {
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
	case ATKBD_RET_BAT:
		atkbd->enabled = false;
		serio_reconnect(atkbd->ps2dev.serio);
		goto out;
	case ATKBD_RET_EMUL0:
		atkbd->emul = 1;
		goto out;
	case ATKBD_RET_EMUL1:
		atkbd->emul = 2;
		goto out;
	case ATKBD_RET_RELEASE:
		atkbd->release = true;
		goto out;
	case ATKBD_RET_ACK:
	case ATKBD_RET_NAK:
		if (printk_ratelimit())
			dev_warn(&serio->dev,
				 "Spurious %s on %s. "
442
				 "Some program might be trying to access hardware directly.\n",
443 444 445 446 447 448 449
				 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
		goto out;
	case ATKBD_RET_ERR:
		atkbd->err_count++;
		dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
			serio->phys);
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
450 451
	}

452 453 454 455 456 457
	code = atkbd_compat_scancode(atkbd, code);

	if (atkbd->emul && --atkbd->emul)
		goto out;

	keycode = atkbd->keycode[code];
Linus Torvalds's avatar
Linus Torvalds committed
458

459 460
	if (keycode != ATKBD_KEY_NULL)
		input_event(dev, EV_MSC, MSC_SCAN, code);
Linus Torvalds's avatar
Linus Torvalds committed
461

462
	switch (keycode) {
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
	case ATKBD_KEY_NULL:
		break;
	case ATKBD_KEY_UNKNOWN:
		dev_warn(&serio->dev,
			 "Unknown key %s (%s set %d, code %#x on %s).\n",
			 atkbd->release ? "released" : "pressed",
			 atkbd->translated ? "translated" : "raw",
			 atkbd->set, code, serio->phys);
		dev_warn(&serio->dev,
			 "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
			 code & 0x80 ? "e0" : "", code & 0x7f);
		input_sync(dev);
		break;
	case ATKBD_SCR_1:
		scroll = 1;
		break;
	case ATKBD_SCR_2:
		scroll = 2;
		break;
	case ATKBD_SCR_4:
		scroll = 4;
		break;
	case ATKBD_SCR_8:
		scroll = 8;
		break;
	case ATKBD_SCR_CLICK:
		click = !atkbd->release;
		break;
	case ATKBD_SCR_LEFT:
		hscroll = -1;
		break;
	case ATKBD_SCR_RIGHT:
		hscroll = 1;
		break;
	default:
		if (atkbd->release) {
			value = 0;
			atkbd->last = 0;
		} else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
			/* Workaround Toshiba laptop multiple keypress */
			value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
		} else {
			value = 1;
			atkbd->last = code;
			atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
		}

		input_event(dev, EV_KEY, keycode, value);
		input_sync(dev);
512

513 514 515 516
		if (value && test_bit(code, atkbd->force_release_mask)) {
			input_report_key(dev, keycode, 0);
			input_sync(dev);
		}
Linus Torvalds's avatar
Linus Torvalds committed
517 518 519 520
	}

	if (atkbd->scroll) {
		if (click != -1)
521
			input_report_key(dev, BTN_MIDDLE, click);
522 523
		input_report_rel(dev, REL_WHEEL,
				 atkbd->release ? -scroll : scroll);
524 525
		input_report_rel(dev, REL_HWHEEL, hscroll);
		input_sync(dev);
Linus Torvalds's avatar
Linus Torvalds committed
526 527
	}

528
	atkbd->release = false;
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531 532
out:
	return IRQ_HANDLED;
}

533
static int atkbd_set_repeat_rate(struct atkbd *atkbd)
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537 538 539
{
	const short period[32] =
		{ 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
		 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
	const short delay[4] =
		{ 250, 500, 750, 1000 };
540

541 542 543 544 545 546 547 548
	struct input_dev *dev = atkbd->dev;
	unsigned char param;
	int i = 0, j = 0;

	while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
		i++;
	dev->rep[REP_PERIOD] = period[i];

549
	while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
550 551 552 553 554 555 556 557 558
		j++;
	dev->rep[REP_DELAY] = delay[j];

	param = i | (j << 5);
	return ps2_command(&atkbd->ps2dev, &param, ATKBD_CMD_SETREP);
}

static int atkbd_set_leds(struct atkbd *atkbd)
{
559
	struct input_dev *dev = atkbd->dev;
Linus Torvalds's avatar
Linus Torvalds committed
560 561
	unsigned char param[2];

562 563 564 565 566
	param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
		 | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
		 | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
	if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
		return -1;
567

568 569 570 571 572 573 574 575 576
	if (atkbd->extra) {
		param[0] = 0;
		param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
			 | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
			 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
			 | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
			 | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
		if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
			return -1;
577 578
	}

579 580 581 582 583 584 585 586 587
	return 0;
}

/*
 * atkbd_event_work() is used to complete processing of events that
 * can not be processed by input_event() which is often called from
 * interrupt context.
 */

588
static void atkbd_event_work(struct work_struct *work)
589
{
590
	struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
591

592
	mutex_lock(&atkbd->mutex);
593

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
	if (!atkbd->enabled) {
		/*
		 * Serio ports are resumed asynchronously so while driver core
		 * thinks that device is already fully operational in reality
		 * it may not be ready yet. In this case we need to keep
		 * rescheduling till reconnect completes.
		 */
		schedule_delayed_work(&atkbd->event_work,
					msecs_to_jiffies(100));
	} else {
		if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
			atkbd_set_leds(atkbd);

		if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
			atkbd_set_repeat_rate(atkbd);
	}
610

611
	mutex_unlock(&atkbd->mutex);
612 613
}

614 615 616 617 618 619 620 621 622 623 624 625 626
/*
 * Schedule switch for execution. We need to throttle requests,
 * otherwise keyboard may become unresponsive.
 */
static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
{
	unsigned long delay = msecs_to_jiffies(50);

	if (time_after(jiffies, atkbd->event_jiffies + delay))
		delay = 0;

	atkbd->event_jiffies = jiffies;
	set_bit(event_bit, &atkbd->event_mask);
627
	mb();
628 629 630
	schedule_delayed_work(&atkbd->event_work, delay);
}

631 632 633 634 635 636
/*
 * Event callback from the input module. Events that change the state of
 * the hardware are processed here. If action can not be performed in
 * interrupt context it is offloaded to atkbd_event_work.
 */

637 638
static int atkbd_event(struct input_dev *dev,
			unsigned int type, unsigned int code, int value)
639
{
640
	struct atkbd *atkbd = input_get_drvdata(dev);
641

Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646
	if (!atkbd->write)
		return -1;

	switch (type) {

647 648 649
	case EV_LED:
		atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
650

651 652 653 654
	case EV_REP:
		if (!atkbd->softrepeat)
			atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
655

656 657 658
	default:
		return -1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662 663 664 665 666 667 668
}

/*
 * atkbd_enable() signals that interrupt handler is allowed to
 * generate input events.
 */

static inline void atkbd_enable(struct atkbd *atkbd)
{
	serio_pause_rx(atkbd->ps2dev.serio);
669
	atkbd->enabled = true;
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674 675 676 677 678 679 680
	serio_continue_rx(atkbd->ps2dev.serio);
}

/*
 * atkbd_disable() tells input handler that all incoming data except
 * for ACKs and command response should be dropped.
 */

static inline void atkbd_disable(struct atkbd *atkbd)
{
	serio_pause_rx(atkbd->ps2dev.serio);
681
	atkbd->enabled = false;
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684
	serio_continue_rx(atkbd->ps2dev.serio);
}

685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
static int atkbd_activate(struct atkbd *atkbd)
{
	struct ps2dev *ps2dev = &atkbd->ps2dev;

/*
 * Enable the keyboard to receive keystrokes.
 */

	if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
		dev_err(&ps2dev->serio->dev,
			"Failed to enable keyboard on %s\n",
			ps2dev->serio->phys);
		return -1;
	}

	return 0;
}

/*
 * atkbd_deactivate() resets and disables the keyboard from sending
 * keystrokes.
 */

static void atkbd_deactivate(struct atkbd *atkbd)
{
	struct ps2dev *ps2dev = &atkbd->ps2dev;

	if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
		dev_err(&ps2dev->serio->dev,
			"Failed to deactivate keyboard on %s\n",
			ps2dev->serio->phys);
}

Linus Torvalds's avatar
Linus Torvalds committed
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
/*
 * atkbd_probe() probes for an AT keyboard on a serio port.
 */

static int atkbd_probe(struct atkbd *atkbd)
{
	struct ps2dev *ps2dev = &atkbd->ps2dev;
	unsigned char param[2];

/*
 * Some systems, where the bit-twiddling when testing the io-lines of the
 * controller may confuse the keyboard need a full reset of the keyboard. On
 * these systems the BIOS also usually doesn't do it for us.
 */

	if (atkbd_reset)
		if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
735 736 737
			dev_warn(&ps2dev->serio->dev,
				 "keyboard reset failed on %s\n",
				 ps2dev->serio->phys);
Linus Torvalds's avatar
Linus Torvalds committed
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760

/*
 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
 * Some keyboards report different values, but the first byte is always 0xab or
 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
 * should make sure we don't try to set the LEDs on it.
 */

	param[0] = param[1] = 0xa5;	/* initialize with invalid values */
	if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {

/*
 * If the get ID command failed, we check if we can at least set the LEDs on
 * the keyboard. This should work on every keyboard out there. It also turns
 * the LEDs off, which we want anyway.
 */
		param[0] = 0;
		if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
			return -1;
		atkbd->id = 0xabba;
		return 0;
	}

761
	if (!ps2_is_keyboard_id(param[0]))
Linus Torvalds's avatar
Linus Torvalds committed
762 763 764 765 766
		return -1;

	atkbd->id = (param[0] << 8) | param[1];

	if (atkbd->id == 0xaca1 && atkbd->translated) {
767
		dev_err(&ps2dev->serio->dev,
768
			"NCD terminal keyboards are only supported on non-translating controllers. "
769
			"Use i8042.direct=1 to disable translation.\n");
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772
		return -1;
	}

773 774 775 776
/*
 * Make sure nothing is coming from the keyboard and disturbs our
 * internal state.
 */
777 778
	if (!atkbd_skip_deactivate)
		atkbd_deactivate(atkbd);
779

Linus Torvalds's avatar
Linus Torvalds committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793
	return 0;
}

/*
 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
 * sets it into that. Unfortunately there are keyboards that can be switched
 * to Set 3, but don't work well in that (BTC Multimedia ...)
 */

static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
{
	struct ps2dev *ps2dev = &atkbd->ps2dev;
	unsigned char param[2];

794
	atkbd->extra = false;
Linus Torvalds's avatar
Linus Torvalds committed
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
/*
 * For known special keyboards we can go ahead and set the correct set.
 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
 */

	if (atkbd->translated)
		return 2;

	if (atkbd->id == 0xaca1) {
		param[0] = 3;
		ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
		return 3;
	}

	if (allow_extra) {
		param[0] = 0x71;
		if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
813
			atkbd->extra = true;
Linus Torvalds's avatar
Linus Torvalds committed
814 815 816 817
			return 2;
		}
	}

818 819 820 821 822
	if (atkbd_terminal) {
		ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
		return 3;
	}

Linus Torvalds's avatar
Linus Torvalds committed
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
	if (target_set != 3)
		return 2;

	if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
		atkbd->id = param[0] << 8 | param[1];
		return 2;
	}

	param[0] = 3;
	if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
		return 2;

	param[0] = 0;
	if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
		return 2;

	if (param[0] != 3) {
		param[0] = 2;
		if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
		return 2;
	}

	ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);

	return 3;
}

850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
static int atkbd_reset_state(struct atkbd *atkbd)
{
        struct ps2dev *ps2dev = &atkbd->ps2dev;
	unsigned char param[1];

/*
 * Set the LEDs to a predefined state (all off).
 */

	param[0] = 0;
	if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
		return -1;

/*
 * Set autorepeat to fastest possible.
 */

	param[0] = 0;
	if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
		return -1;

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
874 875 876 877 878 879 880 881
/*
 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
 * reboot.
 */

static void atkbd_cleanup(struct serio *serio)
{
	struct atkbd *atkbd = serio_get_drvdata(serio);
882 883

	atkbd_disable(atkbd);
884
	ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887 888 889 890 891 892 893 894 895
}


/*
 * atkbd_disconnect() closes and frees.
 */

static void atkbd_disconnect(struct serio *serio)
{
	struct atkbd *atkbd = serio_get_drvdata(serio);

896 897
	sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);

Linus Torvalds's avatar
Linus Torvalds committed
898 899
	atkbd_disable(atkbd);

900 901 902 903 904 905 906 907
	input_unregister_device(atkbd->dev);

	/*
	 * Make sure we don't have a command in flight.
	 * Note that since atkbd->enabled is false event work will keep
	 * rescheduling itself until it gets canceled and will not try
	 * accessing freed input device or serio port.
	 */
908
	cancel_delayed_work_sync(&atkbd->event_work);
Linus Torvalds's avatar
Linus Torvalds committed
909 910 911 912 913 914

	serio_close(serio);
	serio_set_drvdata(serio, NULL);
	kfree(atkbd);
}

915
/*
916
 * generate release events for the keycodes given in data
917
 */
918 919
static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
						const void *data)
920
{
921 922
	const unsigned int *keys = data;
	unsigned int i;
923 924

	if (atkbd->set == 2)
925 926
		for (i = 0; keys[i] != -1U; i++)
			__set_bit(keys[i], atkbd->force_release_mask);
927
}
Linus Torvalds's avatar
Linus Torvalds committed
928

929 930 931 932 933 934 935 936
/*
 * Most special keys (Fn+F?) on Dell laptops do not generate release
 * events so we have to do it ourselves.
 */
static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
	0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
};

937 938 939 940
/*
 * Perform fixup for HP system that doesn't generate release
 * for its video switch
 */
941 942 943
static unsigned int atkbd_hp_forced_release_keys[] = {
	0x94, -1U
};
944

945
/*
946
 * Samsung NC10,NC20 with Fn+F? key release not working
947
 */
948 949 950
static unsigned int atkbd_samsung_forced_release_keys[] = {
	0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
};
951

952 953 954 955 956 957 958
/*
 * Amilo Pi 3525 key release for Fn+Volume keys not working
 */
static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
	0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
};

959 960 961 962 963 964 965
/*
 * Amilo Xi 3650 key release for light touch bar not working
 */
static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
	0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
};

966 967 968 969 970 971 972
/*
 * Soltech TA12 system with broken key release on volume keys and mute key
 */
static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
	0xa0, 0xae, 0xb0, -1U
};

973 974 975 976 977 978 979 980
/*
 * Many notebooks don't send key release event for volume up/down
 * keys, with key list below common among them
 */
static unsigned int atkbd_volume_forced_release_keys[] = {
	0xae, 0xb0, -1U
};

981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
/*
 * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
 * they should be generating e4-e6 (0x80 | code).
 */
static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
						    unsigned int code)
{
	if (atkbd->translated && atkbd->emul == 1 &&
	    (code == 0x64 || code == 0x65 || code == 0x66)) {
		atkbd->emul = 0;
		code |= 0x80;
	}

	return code;
}

Linus Torvalds's avatar
Linus Torvalds committed
997
/*
998
 * atkbd_set_keycode_table() initializes keyboard's keycode table
Linus Torvalds's avatar
Linus Torvalds committed
999 1000 1001 1002 1003
 * according to the selected scancode set
 */

static void atkbd_set_keycode_table(struct atkbd *atkbd)
{
1004
	unsigned int scancode;
Linus Torvalds's avatar
Linus Torvalds committed
1005 1006 1007
	int i, j;

	memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1008
	bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010 1011

	if (atkbd->translated) {
		for (i = 0; i < 128; i++) {
1012 1013 1014
			scancode = atkbd_unxlate_table[i];
			atkbd->keycode[i] = atkbd_set2_keycode[scancode];
			atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016
			if (atkbd->scroll)
				for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1017
					if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
Linus Torvalds's avatar
Linus Torvalds committed
1018 1019 1020 1021 1022 1023 1024 1025
						atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
		}
	} else if (atkbd->set == 3) {
		memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
	} else {
		memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));

		if (atkbd->scroll)
1026 1027 1028 1029
			for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
				scancode = atkbd_scroll_keys[i].set2;
				atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1030
	}
1031

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
/*
 * HANGEUL and HANJA keys do not send release events so we need to
 * generate such events ourselves
 */
	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
	atkbd->keycode[scancode] = KEY_HANGEUL;
	__set_bit(scancode, atkbd->force_release_mask);

	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
	atkbd->keycode[scancode] = KEY_HANJA;
	__set_bit(scancode, atkbd->force_release_mask);

/*
 * Perform additional fixups
 */
	if (atkbd_platform_fixup)
1048
		atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
Linus Torvalds's avatar
Linus Torvalds committed
1049 1050 1051 1052 1053 1054 1055 1056
}

/*
 * atkbd_set_device_attrs() sets up keyboard's input device structure
 */

static void atkbd_set_device_attrs(struct atkbd *atkbd)
{
1057
	struct input_dev *input_dev = atkbd->dev;
Linus Torvalds's avatar
Linus Torvalds committed
1058 1059
	int i;

1060
	if (atkbd->extra)
1061 1062
		snprintf(atkbd->name, sizeof(atkbd->name),
			 "AT Set 2 Extra keyboard");
1063
	else
1064 1065 1066
		snprintf(atkbd->name, sizeof(atkbd->name),
			 "AT %s Set %d keyboard",
			 atkbd->translated ? "Translated" : "Raw", atkbd->set);
Linus Torvalds's avatar
Linus Torvalds committed
1067

1068 1069
	snprintf(atkbd->phys, sizeof(atkbd->phys),
		 "%s/input0", atkbd->ps2dev.serio->phys);
Linus Torvalds's avatar
Linus Torvalds committed
1070

1071 1072 1073 1074 1075 1076 1077
	input_dev->name = atkbd->name;
	input_dev->phys = atkbd->phys;
	input_dev->id.bustype = BUS_I8042;
	input_dev->id.vendor = 0x0001;
	input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
	input_dev->id.version = atkbd->id;
	input_dev->event = atkbd_event;
1078
	input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
Linus Torvalds's avatar
Linus Torvalds committed
1079

1080 1081
	input_set_drvdata(input_dev, atkbd);

1082 1083
	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
		BIT_MASK(EV_MSC);
Linus Torvalds's avatar
Linus Torvalds committed
1084 1085

	if (atkbd->write) {
1086 1087 1088
		input_dev->evbit[0] |= BIT_MASK(EV_LED);
		input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
			BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
Linus Torvalds's avatar
Linus Torvalds committed
1089 1090 1091
	}

	if (atkbd->extra)
1092 1093 1094
		input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
			BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
			BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
Linus Torvalds's avatar
Linus Torvalds committed
1095 1096

	if (!atkbd->softrepeat) {
1097 1098
		input_dev->rep[REP_DELAY] = 250;
		input_dev->rep[REP_PERIOD] = 33;
Linus Torvalds's avatar
Linus Torvalds committed
1099 1100
	}

1101 1102
	input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
		BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
Linus Torvalds's avatar
Linus Torvalds committed
1103 1104

	if (atkbd->scroll) {
1105 1106 1107
		input_dev->evbit[0] |= BIT_MASK(EV_REL);
		input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
			BIT_MASK(REL_HWHEEL);
1108
		__set_bit(BTN_MIDDLE, input_dev->keybit);
Linus Torvalds's avatar
Linus Torvalds committed
1109 1110
	}

1111
	input_dev->keycode = atkbd->keycode;
1112
	input_dev->keycodesize = sizeof(unsigned short);
1113
	input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
Linus Torvalds's avatar
Linus Torvalds committed
1114

1115 1116 1117 1118
	for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
		if (atkbd->keycode[i] != KEY_RESERVED &&
		    atkbd->keycode[i] != ATKBD_KEY_NULL &&
		    atkbd->keycode[i] < ATKBD_SPECIAL) {
1119
			__set_bit(atkbd->keycode[i], input_dev->keybit);
1120 1121
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
}

/*
 * atkbd_connect() is called when the serio module finds an interface
 * that isn't handled yet by an appropriate device driver. We check if
 * there is an AT keyboard out there and if yes, we register ourselves
 * to the input module.
 */

static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
{
	struct atkbd *atkbd;
1134 1135
	struct input_dev *dev;
	int err = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
1136

1137 1138 1139
	atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
	dev = input_allocate_device();
	if (!atkbd || !dev)
1140
		goto fail1;
Linus Torvalds's avatar
Linus Torvalds committed
1141

1142
	atkbd->dev = dev;
Linus Torvalds's avatar
Linus Torvalds committed
1143
	ps2_init(&atkbd->ps2dev, serio);
1144
	INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1145
	mutex_init(&atkbd->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1146 1147 1148

	switch (serio->id.type) {

1149 1150 1151 1152 1153 1154 1155 1156
	case SERIO_8042_XL:
		atkbd->translated = true;
		/* Fall through */

	case SERIO_8042:
		if (serio->write)
			atkbd->write = true;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159 1160 1161 1162 1163
	}

	atkbd->softraw = atkbd_softraw;
	atkbd->softrepeat = atkbd_softrepeat;
	atkbd->scroll = atkbd_scroll;

	if (atkbd->softrepeat)
1164
		atkbd->softraw = true;
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166 1167 1168

	serio_set_drvdata(serio, atkbd);

	err = serio_open(serio, drv);
1169
	if (err)
1170
		goto fail2;
Linus Torvalds's avatar
Linus Torvalds committed
1171 1172 1173 1174

	if (atkbd->write) {

		if (atkbd_probe(atkbd)) {
1175
			err = -ENODEV;
1176
			goto fail3;
Linus Torvalds's avatar
Linus Torvalds committed
1177 1178 1179
		}

		atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1180
		atkbd_reset_state(atkbd);
Linus Torvalds's avatar
Linus Torvalds committed
1181 1182 1183 1184 1185 1186 1187 1188 1189

	} else {
		atkbd->set = 2;
		atkbd->id = 0xab00;
	}

	atkbd_set_keycode_table(atkbd);
	atkbd_set_device_attrs(atkbd);

1190 1191 1192
	err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
	if (err)
		goto fail3;
Linus Torvalds's avatar
Linus Torvalds committed
1193 1194

	atkbd_enable(atkbd);
1195 1196
	if (serio->write)
		atkbd_activate(atkbd);
Linus Torvalds's avatar
Linus Torvalds committed
1197

1198 1199 1200
	err = input_register_device(atkbd->dev);
	if (err)
		goto fail4;
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202

	return 0;
1203

1204 1205 1206 1207
 fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
 fail3:	serio_close(serio);
 fail2:	serio_set_drvdata(serio, NULL);
 fail1:	input_free_device(dev);
1208 1209
	kfree(atkbd);
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
}

/*
 * atkbd_reconnect() tries to restore keyboard into a sane state and is
 * most likely called on resume.
 */

static int atkbd_reconnect(struct serio *serio)
{
	struct atkbd *atkbd = serio_get_drvdata(serio);
	struct serio_driver *drv = serio->drv;
1221
	int retval = -1;
Linus Torvalds's avatar
Linus Torvalds committed
1222 1223

	if (!atkbd || !drv) {
1224 1225
		dev_dbg(&serio->dev,
			"reconnect request, but serio is disconnected, ignoring...\n");
Linus Torvalds's avatar
Linus Torvalds committed
1226 1227 1228
		return -1;
	}

1229 1230
	mutex_lock(&atkbd->mutex);

Linus Torvalds's avatar
Linus Torvalds committed
1231 1232 1233 1234
	atkbd_disable(atkbd);

	if (atkbd->write) {
		if (atkbd_probe(atkbd))
1235 1236
			goto out;

Linus Torvalds's avatar
Linus Torvalds committed
1237
		if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1238
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1239

1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
		/*
		 * Restore LED state and repeat rate. While input core
		 * will do this for us at resume time reconnect may happen
		 * because user requested it via sysfs or simply because
		 * keyboard was unplugged and plugged in again so we need
		 * to do it ourselves here.
		 */
		atkbd_set_leds(atkbd);
		if (!atkbd->softrepeat)
			atkbd_set_repeat_rate(atkbd);

Linus Torvalds's avatar
Linus Torvalds committed
1251 1252
	}

1253 1254 1255 1256 1257 1258 1259
	/*
	 * Reset our state machine in case reconnect happened in the middle
	 * of multi-byte scancode.
	 */
	atkbd->xl_bit = 0;
	atkbd->emul = 0;

Linus Torvalds's avatar
Linus Torvalds committed
1260
	atkbd_enable(atkbd);
1261 1262 1263
	if (atkbd->write)
		atkbd_activate(atkbd);

1264
	retval = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1265

1266 1267 1268
 out:
	mutex_unlock(&atkbd->mutex);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
}

static struct serio_device_id atkbd_serio_ids[] = {
	{
		.type	= SERIO_8042,
		.proto	= SERIO_ANY,
		.id	= SERIO_ANY,
		.extra	= SERIO_ANY,
	},
	{
		.type	= SERIO_8042_XL,
		.proto	= SERIO_ANY,
		.id	= SERIO_ANY,
		.extra	= SERIO_ANY,
	},
	{
		.type	= SERIO_RS232,
		.proto	= SERIO_PS2SER,
		.id	= SERIO_ANY,
		.extra	= SERIO_ANY,
	},
	{ 0 }
};

MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);

static struct serio_driver atkbd_drv = {
	.driver		= {
		.name	= "atkbd",
	},
	.description	= DRIVER_DESC,
	.id_table	= atkbd_serio_ids,
	.interrupt	= atkbd_interrupt,
	.connect	= atkbd_connect,
	.reconnect	= atkbd_reconnect,
	.disconnect	= atkbd_disconnect,
	.cleanup	= atkbd_cleanup,
};

static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
				ssize_t (*handler)(struct atkbd *, char *))
{
	struct serio *serio = to_serio_port(dev);
1312
	struct atkbd *atkbd = serio_get_drvdata(serio);
Linus Torvalds's avatar
Linus Torvalds committed
1313

1314
	return handler(atkbd, buf);
Linus Torvalds's avatar
Linus Torvalds committed
1315 1316 1317 1318 1319 1320
}

static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
				ssize_t (*handler)(struct atkbd *, const char *, size_t))
{
	struct serio *serio = to_serio_port(dev);
1321
	struct atkbd *atkbd = serio_get_drvdata(serio);
Linus Torvalds's avatar
Linus Torvalds committed
1322 1323
	int retval;

1324
	retval = mutex_lock_interruptible(&atkbd->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1325 1326 1327 1328 1329 1330 1331
	if (retval)
		return retval;

	atkbd_disable(atkbd);
	retval = handler(atkbd, buf, count);
	atkbd_enable(atkbd);

1332 1333
	mutex_unlock(&atkbd->mutex);

Linus Torvalds's avatar
Linus Torvalds committed
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
	return retval;
}

static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
}

static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
{
1344
	struct input_dev *old_dev, *new_dev;
1345
	unsigned int value;
1346
	int err;
1347 1348
	bool old_extra;
	unsigned char old_set;
Linus Torvalds's avatar
Linus Torvalds committed
1349 1350 1351 1352

	if (!atkbd->write)
		return -EIO;

1353 1354 1355 1356 1357
	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1358 1359 1360
		return -EINVAL;

	if (atkbd->extra != value) {
1361 1362
		/*
		 * Since device's properties will change we need to
1363 1364
		 * unregister old device. But allocate and register
		 * new one first to make sure we have it.
1365
		 */
1366 1367 1368 1369 1370 1371
		old_dev = atkbd->dev;
		old_extra = atkbd->extra;
		old_set = atkbd->set;

		new_dev = input_allocate_device();
		if (!new_dev)
1372
			return -ENOMEM;
1373

1374
		atkbd->dev = new_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1375
		atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1376
		atkbd_reset_state(atkbd);
Linus Torvalds's avatar
Linus Torvalds committed
1377
		atkbd_activate(atkbd);
1378
		atkbd_set_keycode_table(atkbd);
Linus Torvalds's avatar
Linus Torvalds committed
1379
		atkbd_set_device_attrs(atkbd);
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393

		err = input_register_device(atkbd->dev);
		if (err) {
			input_free_device(new_dev);

			atkbd->dev = old_dev;
			atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
			atkbd_set_keycode_table(atkbd);
			atkbd_set_device_attrs(atkbd);

			return err;
		}
		input_unregister_device(old_dev);

Linus Torvalds's avatar
Linus Torvalds committed
1394 1395 1396 1397
	}
	return count;
}

1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
{
	size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
			atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);

	buf[len++] = '\n';
	buf[len] = '\0';

	return len;
}

static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
					const char *buf, size_t count)
{
	/* 64 bytes on stack should be acceptable */
	DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
	int err;

	err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
	if (err)
		return err;

	memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
	return count;
}


Linus Torvalds's avatar
Linus Torvalds committed
1425 1426 1427 1428 1429 1430 1431
static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
}

static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
{
1432
	struct input_dev *old_dev, *new_dev;
1433
	unsigned int value;
1434
	int err;
1435
	bool old_scroll;
Linus Torvalds's avatar
Linus Torvalds committed
1436

1437 1438 1439 1440 1441
	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1442 1443 1444
		return -EINVAL;

	if (atkbd->scroll != value) {
1445 1446 1447 1448 1449
		old_dev = atkbd->dev;
		old_scroll = atkbd->scroll;

		new_dev = input_allocate_device();
		if (!new_dev)
1450
			return -ENOMEM;
1451

1452
		atkbd->dev = new_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1453 1454 1455
		atkbd->scroll = value;
		atkbd_set_keycode_table(atkbd);
		atkbd_set_device_attrs(atkbd);
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468

		err = input_register_device(atkbd->dev);
		if (err) {
			input_free_device(new_dev);

			atkbd->scroll = old_scroll;
			atkbd->dev = old_dev;
			atkbd_set_keycode_table(atkbd);
			atkbd_set_device_attrs(atkbd);

			return err;
		}
		input_unregister_device(old_dev);
Linus Torvalds's avatar
Linus Torvalds committed
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
	}
	return count;
}

static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%d\n", atkbd->set);
}

static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
{
1480
	struct input_dev *old_dev, *new_dev;
1481
	unsigned int value;
1482
	int err;
1483 1484
	unsigned char old_set;
	bool old_extra;
Linus Torvalds's avatar
Linus Torvalds committed
1485 1486 1487 1488

	if (!atkbd->write)
		return -EIO;

1489 1490 1491 1492 1493
	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value != 2 && value != 3)
Linus Torvalds's avatar
Linus Torvalds committed
1494 1495 1496
		return -EINVAL;

	if (atkbd->set != value) {
1497 1498 1499 1500 1501 1502
		old_dev = atkbd->dev;
		old_extra = atkbd->extra;
		old_set = atkbd->set;

		new_dev = input_allocate_device();
		if (!new_dev)
1503
			return -ENOMEM;
1504

1505
		atkbd->dev = new_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1506
		atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1507
		atkbd_reset_state(atkbd);
Linus Torvalds's avatar
Linus Torvalds committed
1508 1509 1510
		atkbd_activate(atkbd);
		atkbd_set_keycode_table(atkbd);
		atkbd_set_device_attrs(atkbd);
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523

		err = input_register_device(atkbd->dev);
		if (err) {
			input_free_device(new_dev);

			atkbd->dev = old_dev;
			atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
			atkbd_set_keycode_table(atkbd);
			atkbd_set_device_attrs(atkbd);

			return err;
		}
		input_unregister_device(old_dev);
Linus Torvalds's avatar
Linus Torvalds committed
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
	}
	return count;
}

static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
}

static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
{
1535
	struct input_dev *old_dev, *new_dev;
1536
	unsigned int value;
1537
	int err;
1538
	bool old_softrepeat, old_softraw;
Linus Torvalds's avatar
Linus Torvalds committed
1539 1540 1541 1542

	if (!atkbd->write)
		return -EIO;

1543 1544 1545 1546 1547
	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1548 1549 1550
		return -EINVAL;

	if (atkbd->softrepeat != value) {
1551 1552 1553 1554 1555 1556
		old_dev = atkbd->dev;
		old_softrepeat = atkbd->softrepeat;
		old_softraw = atkbd->softraw;

		new_dev = input_allocate_device();
		if (!new_dev)
1557
			return -ENOMEM;
1558

1559
		atkbd->dev = new_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1560 1561
		atkbd->softrepeat = value;
		if (atkbd->softrepeat)
1562
			atkbd->softraw = true;
Linus Torvalds's avatar
Linus Torvalds committed
1563
		atkbd_set_device_attrs(atkbd);
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

		err = input_register_device(atkbd->dev);
		if (err) {
			input_free_device(new_dev);

			atkbd->dev = old_dev;
			atkbd->softrepeat = old_softrepeat;
			atkbd->softraw = old_softraw;
			atkbd_set_device_attrs(atkbd);

			return err;
		}
		input_unregister_device(old_dev);
Linus Torvalds's avatar
Linus Torvalds committed
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
	}
	return count;
}


static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
}

static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
{
1589
	struct input_dev *old_dev, *new_dev;
1590
	unsigned int value;
1591
	int err;
1592
	bool old_softraw;
Linus Torvalds's avatar
Linus Torvalds committed
1593

1594 1595 1596 1597 1598
	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1599 1600 1601
		return -EINVAL;

	if (atkbd->softraw != value) {
1602 1603 1604 1605 1606
		old_dev = atkbd->dev;
		old_softraw = atkbd->softraw;

		new_dev = input_allocate_device();
		if (!new_dev)
1607
			return -ENOMEM;
1608

1609
		atkbd->dev = new_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1610 1611
		atkbd->softraw = value;
		atkbd_set_device_attrs(atkbd);
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623

		err = input_register_device(atkbd->dev);
		if (err) {
			input_free_device(new_dev);

			atkbd->dev = old_dev;
			atkbd->softraw = old_softraw;
			atkbd_set_device_attrs(atkbd);

			return err;
		}
		input_unregister_device(old_dev);
Linus Torvalds's avatar
Linus Torvalds committed
1624 1625 1626 1627
	}
	return count;
}

1628 1629 1630 1631 1632
static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
{
	return sprintf(buf, "%lu\n", atkbd->err_count);
}

1633
static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1634
{
1635 1636 1637
	atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
	atkbd_platform_fixup_data = id->driver_data;

1638
	return 1;
1639 1640
}

1641 1642 1643 1644
static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
{
	atkbd_platform_scancode_fixup = id->driver_data;

1645
	return 1;
1646 1647
}

1648 1649 1650 1651 1652 1653
static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
{
	atkbd_skip_deactivate = true;
	return 1;
}

1654
static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1655 1656 1657
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1658
			DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1659
		},
1660 1661
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_dell_laptop_forced_release_keys,
1662
	},
1663 1664 1665 1666 1667
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
			DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
		},
1668 1669
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_dell_laptop_forced_release_keys,
1670
	},
1671 1672 1673 1674 1675
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
		},
1676 1677
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_hp_forced_release_keys,
1678
	},
1679 1680 1681 1682 1683
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
		},
1684
		.callback = atkbd_setup_forced_release,
1685
		.driver_data = atkbd_volume_forced_release_keys,
1686
	},
1687 1688 1689 1690 1691 1692
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
		},
		.callback = atkbd_setup_forced_release,
1693
		.driver_data = atkbd_volume_forced_release_keys,
1694 1695 1696 1697 1698 1699 1700
	},
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
		},
		.callback = atkbd_setup_forced_release,
1701
		.driver_data = atkbd_volume_forced_release_keys,
1702 1703 1704 1705 1706 1707 1708
	},
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
		},
		.callback = atkbd_setup_forced_release,
1709
		.driver_data = atkbd_volume_forced_release_keys,
1710
	},
1711
	{
1712
		/* Inventec Symphony */
1713 1714 1715 1716
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
			DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
		},
1717
		.callback = atkbd_setup_forced_release,
1718
		.driver_data = atkbd_volume_forced_release_keys,
1719
	},
1720
	{
1721
		/* Samsung NC10 */
1722 1723 1724 1725
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
			DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
		},
1726 1727
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_samsung_forced_release_keys,
1728
	},
1729
	{
1730
		/* Samsung NC20 */
1731 1732 1733 1734 1735 1736 1737
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
			DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
		},
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_samsung_forced_release_keys,
	},
1738
	{
1739
		/* Samsung SQ45S70S */
1740 1741 1742 1743 1744 1745 1746
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
			DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
		},
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_samsung_forced_release_keys,
	},
1747
	{
1748
		/* Fujitsu Amilo PA 1510 */
1749 1750 1751 1752 1753
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
		},
		.callback = atkbd_setup_forced_release,
1754
		.driver_data = atkbd_volume_forced_release_keys,
1755
	},
1756
	{
1757
		/* Fujitsu Amilo Pi 3525 */
1758 1759 1760 1761 1762 1763 1764
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
		},
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_amilo_pi3525_forced_release_keys,
	},
1765
	{
1766
		/* Fujitsu Amilo Xi 3650 */
1767 1768 1769 1770 1771 1772 1773
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
		},
		.callback = atkbd_setup_forced_release,
		.driver_data = atkbd_amilo_xi3650_forced_release_keys,
	},
1774 1775 1776 1777 1778 1779 1780 1781
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
			DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
		},
		.callback = atkbd_setup_forced_release,
		.driver_data = atkdb_soltech_ta12_forced_release_keys,
	},
1782
	{
1783
		/* OQO Model 01+ */
1784 1785 1786 1787 1788 1789 1790
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
			DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
		},
		.callback = atkbd_setup_scancode_fixup,
		.driver_data = atkbd_oqo_01plus_scancode_fixup,
	},
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
			DMI_MATCH(DMI_PRODUCT_NAME, "LW25-B7HV"),
		},
		.callback = atkbd_deactivate_fixup,
	},
	{
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
			DMI_MATCH(DMI_PRODUCT_NAME, "P1-J273B"),
		},
		.callback = atkbd_deactivate_fixup,
	},
1805 1806
	{ }
};
Linus Torvalds's avatar
Linus Torvalds committed
1807 1808 1809

static int __init atkbd_init(void)
{
1810 1811
	dmi_check_system(atkbd_dmi_quirk_table);

1812
	return serio_register_driver(&atkbd_drv);
Linus Torvalds's avatar
Linus Torvalds committed
1813 1814 1815 1816 1817 1818 1819 1820 1821
}

static void __exit atkbd_exit(void)
{
	serio_unregister_driver(&atkbd_drv);
}

module_init(atkbd_init);
module_exit(atkbd_exit);