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