1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Copyright (c) 2000-2001 Vojtech Pavlik
   4 *  Copyright (c) 2006-2010 Jiri Kosina
   5 *
   6 *  HID to Linux Input mapping
   7 */
   8
   9/*
  10 *
  11 * Should you need to contact me, the author, you can do so either by
  12 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
  13 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/slab.h>
  18#include <linux/kernel.h>
  19
  20#include <linux/hid.h>
  21#include <linux/hid-debug.h>
  22
  23#include "hid-ids.h"
  24
  25#define unk	KEY_UNKNOWN
  26
  27static const unsigned char hid_keyboard[256] = {
  28	  0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
  29	 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
  30	  4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
  31	 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
  32	 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
  33	105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
  34	 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
  35	191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
  36	115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
  37	122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,
  38	unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
  39	unk,unk,unk,unk,unk,unk,179,180,unk,unk,unk,unk,unk,unk,unk,unk,
  40	unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
  41	unk,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,unk,unk,unk,unk,
  42	 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
  43	150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
  44};
  45
  46static const struct {
  47	__s32 x;
  48	__s32 y;
  49}  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
  50
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  51#define map_abs(c)	hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
  52#define map_rel(c)	hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
  53#define map_key(c)	hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
  54#define map_led(c)	hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
 
  55
  56#define map_abs_clear(c)	hid_map_usage_clear(hidinput, usage, &bit, \
  57		&max, EV_ABS, (c))
  58#define map_key_clear(c)	hid_map_usage_clear(hidinput, usage, &bit, \
  59		&max, EV_KEY, (c))
  60
  61static bool match_scancode(struct hid_usage *usage,
  62			   unsigned int cur_idx, unsigned int scancode)
  63{
  64	return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
  65}
  66
  67static bool match_keycode(struct hid_usage *usage,
  68			  unsigned int cur_idx, unsigned int keycode)
  69{
  70	/*
  71	 * We should exclude unmapped usages when doing lookup by keycode.
  72	 */
  73	return (usage->type == EV_KEY && usage->code == keycode);
  74}
  75
  76static bool match_index(struct hid_usage *usage,
  77			unsigned int cur_idx, unsigned int idx)
  78{
  79	return cur_idx == idx;
  80}
  81
  82typedef bool (*hid_usage_cmp_t)(struct hid_usage *usage,
  83				unsigned int cur_idx, unsigned int val);
  84
  85static struct hid_usage *hidinput_find_key(struct hid_device *hid,
  86					   hid_usage_cmp_t match,
  87					   unsigned int value,
  88					   unsigned int *usage_idx)
  89{
  90	unsigned int i, j, k, cur_idx = 0;
  91	struct hid_report *report;
  92	struct hid_usage *usage;
  93
  94	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
  95		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
  96			for (i = 0; i < report->maxfield; i++) {
  97				for (j = 0; j < report->field[i]->maxusage; j++) {
  98					usage = report->field[i]->usage + j;
  99					if (usage->type == EV_KEY || usage->type == 0) {
 100						if (match(usage, cur_idx, value)) {
 101							if (usage_idx)
 102								*usage_idx = cur_idx;
 103							return usage;
 104						}
 105						cur_idx++;
 106					}
 107				}
 108			}
 109		}
 110	}
 111	return NULL;
 112}
 113
 114static struct hid_usage *hidinput_locate_usage(struct hid_device *hid,
 115					const struct input_keymap_entry *ke,
 116					unsigned int *index)
 117{
 118	struct hid_usage *usage;
 119	unsigned int scancode;
 120
 121	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
 122		usage = hidinput_find_key(hid, match_index, ke->index, index);
 123	else if (input_scancode_to_scalar(ke, &scancode) == 0)
 124		usage = hidinput_find_key(hid, match_scancode, scancode, index);
 125	else
 126		usage = NULL;
 127
 128	return usage;
 129}
 130
 131static int hidinput_getkeycode(struct input_dev *dev,
 132			       struct input_keymap_entry *ke)
 133{
 134	struct hid_device *hid = input_get_drvdata(dev);
 135	struct hid_usage *usage;
 136	unsigned int scancode, index;
 137
 138	usage = hidinput_locate_usage(hid, ke, &index);
 139	if (usage) {
 140		ke->keycode = usage->type == EV_KEY ?
 141				usage->code : KEY_RESERVED;
 142		ke->index = index;
 143		scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE);
 144		ke->len = sizeof(scancode);
 145		memcpy(ke->scancode, &scancode, sizeof(scancode));
 146		return 0;
 147	}
 148
 149	return -EINVAL;
 150}
 151
 152static int hidinput_setkeycode(struct input_dev *dev,
 153			       const struct input_keymap_entry *ke,
 154			       unsigned int *old_keycode)
 155{
 156	struct hid_device *hid = input_get_drvdata(dev);
 157	struct hid_usage *usage;
 158
 159	usage = hidinput_locate_usage(hid, ke, NULL);
 160	if (usage) {
 161		*old_keycode = usage->type == EV_KEY ?
 162				usage->code : KEY_RESERVED;
 
 163		usage->code = ke->keycode;
 164
 165		clear_bit(*old_keycode, dev->keybit);
 166		set_bit(usage->code, dev->keybit);
 167		dbg_hid("Assigned keycode %d to HID usage code %x\n",
 168			usage->code, usage->hid);
 169
 170		/*
 171		 * Set the keybit for the old keycode if the old keycode is used
 172		 * by another key
 173		 */
 174		if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL))
 175			set_bit(*old_keycode, dev->keybit);
 176
 177		return 0;
 178	}
 179
 180	return -EINVAL;
 181}
 182
 183
 184/**
 185 * hidinput_calc_abs_res - calculate an absolute axis resolution
 186 * @field: the HID report field to calculate resolution for
 187 * @code: axis code
 188 *
 189 * The formula is:
 190 *                         (logical_maximum - logical_minimum)
 191 * resolution = ----------------------------------------------------------
 192 *              (physical_maximum - physical_minimum) * 10 ^ unit_exponent
 193 *
 194 * as seen in the HID specification v1.11 6.2.2.7 Global Items.
 195 *
 196 * Only exponent 1 length units are processed. Centimeters and inches are
 197 * converted to millimeters. Degrees are converted to radians.
 198 */
 199__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
 200{
 201	__s32 unit_exponent = field->unit_exponent;
 202	__s32 logical_extents = field->logical_maximum -
 203					field->logical_minimum;
 204	__s32 physical_extents = field->physical_maximum -
 205					field->physical_minimum;
 206	__s32 prev;
 207
 208	/* Check if the extents are sane */
 209	if (logical_extents <= 0 || physical_extents <= 0)
 210		return 0;
 211
 212	/*
 213	 * Verify and convert units.
 214	 * See HID specification v1.11 6.2.2.7 Global Items for unit decoding
 215	 */
 216	switch (code) {
 217	case ABS_X:
 218	case ABS_Y:
 219	case ABS_Z:
 220	case ABS_MT_POSITION_X:
 221	case ABS_MT_POSITION_Y:
 222	case ABS_MT_TOOL_X:
 223	case ABS_MT_TOOL_Y:
 224	case ABS_MT_TOUCH_MAJOR:
 225	case ABS_MT_TOUCH_MINOR:
 226		if (field->unit == 0x11) {		/* If centimeters */
 227			/* Convert to millimeters */
 228			unit_exponent += 1;
 229		} else if (field->unit == 0x13) {	/* If inches */
 230			/* Convert to millimeters */
 231			prev = physical_extents;
 232			physical_extents *= 254;
 233			if (physical_extents < prev)
 234				return 0;
 235			unit_exponent -= 1;
 236		} else {
 237			return 0;
 238		}
 239		break;
 240
 241	case ABS_RX:
 242	case ABS_RY:
 243	case ABS_RZ:
 244	case ABS_WHEEL:
 245	case ABS_TILT_X:
 246	case ABS_TILT_Y:
 247		if (field->unit == 0x14) {		/* If degrees */
 248			/* Convert to radians */
 249			prev = logical_extents;
 250			logical_extents *= 573;
 251			if (logical_extents < prev)
 252				return 0;
 253			unit_exponent += 1;
 254		} else if (field->unit != 0x12) {	/* If not radians */
 255			return 0;
 256		}
 257		break;
 258
 259	default:
 260		return 0;
 261	}
 262
 263	/* Apply negative unit exponent */
 264	for (; unit_exponent < 0; unit_exponent++) {
 265		prev = logical_extents;
 266		logical_extents *= 10;
 267		if (logical_extents < prev)
 268			return 0;
 269	}
 270	/* Apply positive unit exponent */
 271	for (; unit_exponent > 0; unit_exponent--) {
 272		prev = physical_extents;
 273		physical_extents *= 10;
 274		if (physical_extents < prev)
 275			return 0;
 276	}
 277
 278	/* Calculate resolution */
 279	return DIV_ROUND_CLOSEST(logical_extents, physical_extents);
 280}
 281EXPORT_SYMBOL_GPL(hidinput_calc_abs_res);
 282
 283#ifdef CONFIG_HID_BATTERY_STRENGTH
 284static enum power_supply_property hidinput_battery_props[] = {
 285	POWER_SUPPLY_PROP_PRESENT,
 286	POWER_SUPPLY_PROP_ONLINE,
 287	POWER_SUPPLY_PROP_CAPACITY,
 288	POWER_SUPPLY_PROP_MODEL_NAME,
 289	POWER_SUPPLY_PROP_STATUS,
 290	POWER_SUPPLY_PROP_SCOPE,
 291};
 292
 293#define HID_BATTERY_QUIRK_PERCENT	(1 << 0) /* always reports percent */
 294#define HID_BATTERY_QUIRK_FEATURE	(1 << 1) /* ask for feature report */
 295#define HID_BATTERY_QUIRK_IGNORE	(1 << 2) /* completely ignore the battery */
 
 296
 297static const struct hid_device_id hid_battery_quirks[] = {
 298	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 299		USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
 300	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 301	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 302		USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
 303	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 304	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 305		USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
 306	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 307	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 308			       USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
 309	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 310	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 311		USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
 312	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 
 
 
 313	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM,
 314		USB_DEVICE_ID_ELECOM_BM084),
 315	  HID_BATTERY_QUIRK_IGNORE },
 316	{ HID_USB_DEVICE(USB_VENDOR_ID_SYMBOL,
 317		USB_DEVICE_ID_SYMBOL_SCANNER_3),
 318	  HID_BATTERY_QUIRK_IGNORE },
 319	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK,
 320		USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD),
 321	  HID_BATTERY_QUIRK_IGNORE },
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 322	{}
 323};
 324
 325static unsigned find_battery_quirk(struct hid_device *hdev)
 326{
 327	unsigned quirks = 0;
 328	const struct hid_device_id *match;
 329
 330	match = hid_match_id(hdev, hid_battery_quirks);
 331	if (match != NULL)
 332		quirks = match->driver_data;
 333
 334	return quirks;
 335}
 336
 337static int hidinput_scale_battery_capacity(struct hid_device *dev,
 338					   int value)
 339{
 340	if (dev->battery_min < dev->battery_max &&
 341	    value >= dev->battery_min && value <= dev->battery_max)
 342		value = ((value - dev->battery_min) * 100) /
 343			(dev->battery_max - dev->battery_min);
 344
 345	return value;
 346}
 347
 348static int hidinput_query_battery_capacity(struct hid_device *dev)
 349{
 350	u8 *buf;
 351	int ret;
 352
 353	buf = kmalloc(4, GFP_KERNEL);
 354	if (!buf)
 355		return -ENOMEM;
 356
 357	ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 4,
 358				 dev->battery_report_type, HID_REQ_GET_REPORT);
 359	if (ret < 2) {
 360		kfree(buf);
 361		return -ENODATA;
 362	}
 363
 364	ret = hidinput_scale_battery_capacity(dev, buf[1]);
 365	kfree(buf);
 366	return ret;
 367}
 368
 369static int hidinput_get_battery_property(struct power_supply *psy,
 370					 enum power_supply_property prop,
 371					 union power_supply_propval *val)
 372{
 373	struct hid_device *dev = power_supply_get_drvdata(psy);
 374	int value;
 375	int ret = 0;
 376
 377	switch (prop) {
 378	case POWER_SUPPLY_PROP_PRESENT:
 379	case POWER_SUPPLY_PROP_ONLINE:
 380		val->intval = 1;
 381		break;
 382
 383	case POWER_SUPPLY_PROP_CAPACITY:
 384		if (dev->battery_status != HID_BATTERY_REPORTED &&
 385		    !dev->battery_avoid_query) {
 386			value = hidinput_query_battery_capacity(dev);
 387			if (value < 0)
 388				return value;
 389		} else  {
 390			value = dev->battery_capacity;
 391		}
 392
 393		val->intval = value;
 394		break;
 395
 396	case POWER_SUPPLY_PROP_MODEL_NAME:
 397		val->strval = dev->name;
 398		break;
 399
 400	case POWER_SUPPLY_PROP_STATUS:
 401		if (dev->battery_status != HID_BATTERY_REPORTED &&
 402		    !dev->battery_avoid_query) {
 403			value = hidinput_query_battery_capacity(dev);
 404			if (value < 0)
 405				return value;
 406
 407			dev->battery_capacity = value;
 408			dev->battery_status = HID_BATTERY_QUERIED;
 409		}
 410
 411		if (dev->battery_status == HID_BATTERY_UNKNOWN)
 412			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 413		else if (dev->battery_capacity == 100)
 414			val->intval = POWER_SUPPLY_STATUS_FULL;
 415		else
 416			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 417		break;
 418
 419	case POWER_SUPPLY_PROP_SCOPE:
 420		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
 421		break;
 422
 423	default:
 424		ret = -EINVAL;
 425		break;
 426	}
 427
 428	return ret;
 429}
 430
 431static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type, struct hid_field *field)
 
 432{
 433	struct power_supply_desc *psy_desc;
 434	struct power_supply_config psy_cfg = { .drv_data = dev, };
 435	unsigned quirks;
 436	s32 min, max;
 437	int error;
 438
 439	if (dev->battery)
 440		return 0;	/* already initialized? */
 441
 442	quirks = find_battery_quirk(dev);
 443
 444	hid_dbg(dev, "device %x:%x:%x %d quirks %d\n",
 445		dev->bus, dev->vendor, dev->product, dev->version, quirks);
 446
 447	if (quirks & HID_BATTERY_QUIRK_IGNORE)
 448		return 0;
 449
 450	psy_desc = kzalloc(sizeof(*psy_desc), GFP_KERNEL);
 451	if (!psy_desc)
 452		return -ENOMEM;
 453
 454	psy_desc->name = kasprintf(GFP_KERNEL, "hid-%s-battery",
 455				   strlen(dev->uniq) ?
 456					dev->uniq : dev_name(&dev->dev));
 457	if (!psy_desc->name) {
 458		error = -ENOMEM;
 459		goto err_free_mem;
 460	}
 461
 462	psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
 463	psy_desc->properties = hidinput_battery_props;
 464	psy_desc->num_properties = ARRAY_SIZE(hidinput_battery_props);
 465	psy_desc->use_for_apm = 0;
 466	psy_desc->get_property = hidinput_get_battery_property;
 467
 468	min = field->logical_minimum;
 469	max = field->logical_maximum;
 470
 471	if (quirks & HID_BATTERY_QUIRK_PERCENT) {
 472		min = 0;
 473		max = 100;
 474	}
 475
 476	if (quirks & HID_BATTERY_QUIRK_FEATURE)
 477		report_type = HID_FEATURE_REPORT;
 478
 479	dev->battery_min = min;
 480	dev->battery_max = max;
 481	dev->battery_report_type = report_type;
 482	dev->battery_report_id = field->report->id;
 
 483
 484	/*
 485	 * Stylus is normally not connected to the device and thus we
 486	 * can't query the device and get meaningful battery strength.
 487	 * We have to wait for the device to report it on its own.
 488	 */
 489	dev->battery_avoid_query = report_type == HID_INPUT_REPORT &&
 490				   field->physical == HID_DG_STYLUS;
 491
 
 
 
 492	dev->battery = power_supply_register(&dev->dev, psy_desc, &psy_cfg);
 493	if (IS_ERR(dev->battery)) {
 494		error = PTR_ERR(dev->battery);
 495		hid_warn(dev, "can't register power supply: %d\n", error);
 496		goto err_free_name;
 497	}
 498
 499	power_supply_powers(dev->battery, &dev->dev);
 500	return 0;
 501
 502err_free_name:
 503	kfree(psy_desc->name);
 504err_free_mem:
 505	kfree(psy_desc);
 506	dev->battery = NULL;
 507	return error;
 508}
 509
 510static void hidinput_cleanup_battery(struct hid_device *dev)
 511{
 512	const struct power_supply_desc *psy_desc;
 513
 514	if (!dev->battery)
 515		return;
 516
 517	psy_desc = dev->battery->desc;
 518	power_supply_unregister(dev->battery);
 519	kfree(psy_desc->name);
 520	kfree(psy_desc);
 521	dev->battery = NULL;
 522}
 523
 524static void hidinput_update_battery(struct hid_device *dev, int value)
 525{
 526	int capacity;
 527
 528	if (!dev->battery)
 529		return;
 530
 531	if (value == 0 || value < dev->battery_min || value > dev->battery_max)
 532		return;
 533
 534	capacity = hidinput_scale_battery_capacity(dev, value);
 535
 536	if (dev->battery_status != HID_BATTERY_REPORTED ||
 537	    capacity != dev->battery_capacity) {
 
 538		dev->battery_capacity = capacity;
 539		dev->battery_status = HID_BATTERY_REPORTED;
 
 
 540		power_supply_changed(dev->battery);
 541	}
 542}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 543#else  /* !CONFIG_HID_BATTERY_STRENGTH */
 544static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
 545				  struct hid_field *field)
 546{
 547	return 0;
 548}
 549
 550static void hidinput_cleanup_battery(struct hid_device *dev)
 551{
 552}
 553
 554static void hidinput_update_battery(struct hid_device *dev, int value)
 555{
 556}
 
 
 
 
 
 
 557#endif	/* CONFIG_HID_BATTERY_STRENGTH */
 558
 
 
 
 
 
 
 
 
 
 
 559static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
 560				     struct hid_usage *usage)
 561{
 562	struct input_dev *input = hidinput->input;
 563	struct hid_device *device = input_get_drvdata(input);
 
 564	int max = 0, code;
 
 565	unsigned long *bit = NULL;
 566
 567	field->hidinput = hidinput;
 568
 569	if (field->flags & HID_MAIN_ITEM_CONSTANT)
 570		goto ignore;
 571
 572	/* Ignore if report count is out of bounds. */
 573	if (field->report_count < 1)
 574		goto ignore;
 575
 576	/* only LED usages are supported in output fields */
 577	if (field->report_type == HID_OUTPUT_REPORT &&
 578			(usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
 579		goto ignore;
 580	}
 581
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 582	if (device->driver->input_mapping) {
 583		int ret = device->driver->input_mapping(device, hidinput, field,
 584				usage, &bit, &max);
 585		if (ret > 0)
 586			goto mapped;
 587		if (ret < 0)
 588			goto ignore;
 589	}
 590
 591	switch (usage->hid & HID_USAGE_PAGE) {
 592	case HID_UP_UNDEFINED:
 593		goto ignore;
 594
 595	case HID_UP_KEYBOARD:
 596		set_bit(EV_REP, input->evbit);
 597
 598		if ((usage->hid & HID_USAGE) < 256) {
 599			if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
 600			map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
 601		} else
 602			map_key(KEY_UNKNOWN);
 603
 604		break;
 605
 606	case HID_UP_BUTTON:
 607		code = ((usage->hid - 1) & HID_USAGE);
 608
 609		switch (field->application) {
 610		case HID_GD_MOUSE:
 611		case HID_GD_POINTER:  code += BTN_MOUSE; break;
 612		case HID_GD_JOYSTICK:
 613				if (code <= 0xf)
 614					code += BTN_JOYSTICK;
 615				else
 616					code += BTN_TRIGGER_HAPPY - 0x10;
 617				break;
 618		case HID_GD_GAMEPAD:
 619				if (code <= 0xf)
 620					code += BTN_GAMEPAD;
 621				else
 622					code += BTN_TRIGGER_HAPPY - 0x10;
 623				break;
 
 
 
 
 
 
 
 
 
 
 
 624		default:
 625			switch (field->physical) {
 626			case HID_GD_MOUSE:
 627			case HID_GD_POINTER:  code += BTN_MOUSE; break;
 628			case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;
 629			case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
 630			default:              code += BTN_MISC;
 631			}
 632		}
 633
 634		map_key(code);
 635		break;
 636
 637	case HID_UP_SIMULATION:
 638		switch (usage->hid & 0xffff) {
 639		case 0xba: map_abs(ABS_RUDDER);   break;
 640		case 0xbb: map_abs(ABS_THROTTLE); break;
 641		case 0xc4: map_abs(ABS_GAS);      break;
 642		case 0xc5: map_abs(ABS_BRAKE);    break;
 643		case 0xc8: map_abs(ABS_WHEEL);    break;
 644		default:   goto ignore;
 645		}
 646		break;
 647
 648	case HID_UP_GENDESK:
 649		if ((usage->hid & 0xf0) == 0x80) {	/* SystemControl */
 650			switch (usage->hid & 0xf) {
 651			case 0x1: map_key_clear(KEY_POWER);  break;
 652			case 0x2: map_key_clear(KEY_SLEEP);  break;
 653			case 0x3: map_key_clear(KEY_WAKEUP); break;
 654			case 0x4: map_key_clear(KEY_CONTEXT_MENU); break;
 655			case 0x5: map_key_clear(KEY_MENU); break;
 656			case 0x6: map_key_clear(KEY_PROG1); break;
 657			case 0x7: map_key_clear(KEY_HELP); break;
 658			case 0x8: map_key_clear(KEY_EXIT); break;
 659			case 0x9: map_key_clear(KEY_SELECT); break;
 660			case 0xa: map_key_clear(KEY_RIGHT); break;
 661			case 0xb: map_key_clear(KEY_LEFT); break;
 662			case 0xc: map_key_clear(KEY_UP); break;
 663			case 0xd: map_key_clear(KEY_DOWN); break;
 664			case 0xe: map_key_clear(KEY_POWER2); break;
 665			case 0xf: map_key_clear(KEY_RESTART); break;
 666			default: goto unknown;
 667			}
 668			break;
 669		}
 670
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 671		if ((usage->hid & 0xf0) == 0xb0) {	/* SC - Display */
 672			switch (usage->hid & 0xf) {
 673			case 0x05: map_key_clear(KEY_SWITCHVIDEOMODE); break;
 674			default: goto ignore;
 675			}
 676			break;
 677		}
 678
 679		/*
 680		 * Some lazy vendors declare 255 usages for System Control,
 681		 * leading to the creation of ABS_X|Y axis and too many others.
 682		 * It wouldn't be a problem if joydev doesn't consider the
 683		 * device as a joystick then.
 684		 */
 685		if (field->application == HID_GD_SYSTEM_CONTROL)
 686			goto ignore;
 687
 688		if ((usage->hid & 0xf0) == 0x90) {	/* D-pad */
 689			switch (usage->hid) {
 690			case HID_GD_UP:	   usage->hat_dir = 1; break;
 691			case HID_GD_DOWN:  usage->hat_dir = 5; break;
 692			case HID_GD_RIGHT: usage->hat_dir = 3; break;
 693			case HID_GD_LEFT:  usage->hat_dir = 7; break;
 694			default: goto unknown;
 695			}
 696			if (field->dpad) {
 697				map_abs(field->dpad);
 698				goto ignore;
 699			}
 700			map_abs(ABS_HAT0X);
 701			break;
 702		}
 703
 704		switch (usage->hid) {
 705		/* These usage IDs map directly to the usage codes. */
 706		case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
 707		case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
 708			if (field->flags & HID_MAIN_ITEM_RELATIVE)
 709				map_rel(usage->hid & 0xf);
 710			else
 711				map_abs_clear(usage->hid & 0xf);
 712			break;
 713
 714		case HID_GD_WHEEL:
 715			if (field->flags & HID_MAIN_ITEM_RELATIVE) {
 716				set_bit(REL_WHEEL, input->relbit);
 717				map_rel(REL_WHEEL_HI_RES);
 718			} else {
 719				map_abs(usage->hid & 0xf);
 720			}
 721			break;
 722		case HID_GD_SLIDER: case HID_GD_DIAL:
 723			if (field->flags & HID_MAIN_ITEM_RELATIVE)
 724				map_rel(usage->hid & 0xf);
 725			else
 726				map_abs(usage->hid & 0xf);
 727			break;
 728
 729		case HID_GD_HATSWITCH:
 730			usage->hat_min = field->logical_minimum;
 731			usage->hat_max = field->logical_maximum;
 732			map_abs(ABS_HAT0X);
 733			break;
 734
 735		case HID_GD_START:	map_key_clear(BTN_START);	break;
 736		case HID_GD_SELECT:	map_key_clear(BTN_SELECT);	break;
 737
 738		case HID_GD_RFKILL_BTN:
 739			/* MS wireless radio ctl extension, also check CA */
 740			if (field->application == HID_GD_WIRELESS_RADIO_CTLS) {
 741				map_key_clear(KEY_RFKILL);
 742				/* We need to simulate the btn release */
 743				field->flags |= HID_MAIN_ITEM_RELATIVE;
 744				break;
 745			}
 
 746
 747		default: goto unknown;
 748		}
 749
 750		break;
 751
 752	case HID_UP_LED:
 753		switch (usage->hid & 0xffff) {		      /* HID-Value:                   */
 754		case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
 755		case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
 756		case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
 757		case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
 758		case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
 759		case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
 760		case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
 761		case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
 762		case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
 763		case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
 764		case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
 765
 766		default: goto ignore;
 767		}
 768		break;
 769
 770	case HID_UP_DIGITIZER:
 771		if ((field->application & 0xff) == 0x01) /* Digitizer */
 772			__set_bit(INPUT_PROP_POINTER, input->propbit);
 773		else if ((field->application & 0xff) == 0x02) /* Pen */
 774			__set_bit(INPUT_PROP_DIRECT, input->propbit);
 775
 776		switch (usage->hid & 0xff) {
 777		case 0x00: /* Undefined */
 778			goto ignore;
 779
 780		case 0x30: /* TipPressure */
 781			if (!test_bit(BTN_TOUCH, input->keybit)) {
 782				device->quirks |= HID_QUIRK_NOTOUCH;
 783				set_bit(EV_KEY, input->evbit);
 784				set_bit(BTN_TOUCH, input->keybit);
 785			}
 786			map_abs_clear(ABS_PRESSURE);
 787			break;
 788
 789		case 0x32: /* InRange */
 790			switch (field->physical & 0xff) {
 791			case 0x21: map_key(BTN_TOOL_MOUSE); break;
 792			case 0x22: map_key(BTN_TOOL_FINGER); break;
 793			default: map_key(BTN_TOOL_PEN); break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 794			}
 795			break;
 796
 797		case 0x3b: /* Battery Strength */
 798			hidinput_setup_battery(device, HID_INPUT_REPORT, field);
 799			usage->type = EV_PWR;
 800			goto ignore;
 801
 802		case 0x3c: /* Invert */
 
 803			map_key_clear(BTN_TOOL_RUBBER);
 804			break;
 805
 806		case 0x3d: /* X Tilt */
 807			map_abs_clear(ABS_TILT_X);
 808			break;
 809
 810		case 0x3e: /* Y Tilt */
 811			map_abs_clear(ABS_TILT_Y);
 812			break;
 813
 814		case 0x33: /* Touch */
 815		case 0x42: /* TipSwitch */
 816		case 0x43: /* TipSwitch2 */
 817			device->quirks &= ~HID_QUIRK_NOTOUCH;
 818			map_key_clear(BTN_TOUCH);
 819			break;
 820
 821		case 0x44: /* BarrelSwitch */
 822			map_key_clear(BTN_STYLUS);
 823			break;
 824
 825		case 0x45: /* ERASER */
 826			/*
 827			 * This event is reported when eraser tip touches the surface.
 828			 * Actual eraser (BTN_TOOL_RUBBER) is set by Invert usage when
 829			 * tool gets in proximity.
 830			 */
 
 
 
 
 831			map_key_clear(BTN_TOUCH);
 832			break;
 833
 834		case 0x46: /* TabletPick */
 835		case 0x5a: /* SecondaryBarrelSwitch */
 836			map_key_clear(BTN_STYLUS2);
 837			break;
 838
 839		case 0x5b: /* TransducerSerialNumber */
 840			usage->type = EV_MSC;
 841			usage->code = MSC_SERIAL;
 842			bit = input->mscbit;
 843			max = MSC_MAX;
 844			break;
 845
 846		default:  goto unknown;
 847		}
 848		break;
 849
 850	case HID_UP_TELEPHONY:
 851		switch (usage->hid & HID_USAGE) {
 852		case 0x2f: map_key_clear(KEY_MICMUTE);		break;
 853		case 0xb0: map_key_clear(KEY_NUMERIC_0);	break;
 854		case 0xb1: map_key_clear(KEY_NUMERIC_1);	break;
 855		case 0xb2: map_key_clear(KEY_NUMERIC_2);	break;
 856		case 0xb3: map_key_clear(KEY_NUMERIC_3);	break;
 857		case 0xb4: map_key_clear(KEY_NUMERIC_4);	break;
 858		case 0xb5: map_key_clear(KEY_NUMERIC_5);	break;
 859		case 0xb6: map_key_clear(KEY_NUMERIC_6);	break;
 860		case 0xb7: map_key_clear(KEY_NUMERIC_7);	break;
 861		case 0xb8: map_key_clear(KEY_NUMERIC_8);	break;
 862		case 0xb9: map_key_clear(KEY_NUMERIC_9);	break;
 863		case 0xba: map_key_clear(KEY_NUMERIC_STAR);	break;
 864		case 0xbb: map_key_clear(KEY_NUMERIC_POUND);	break;
 865		case 0xbc: map_key_clear(KEY_NUMERIC_A);	break;
 866		case 0xbd: map_key_clear(KEY_NUMERIC_B);	break;
 867		case 0xbe: map_key_clear(KEY_NUMERIC_C);	break;
 868		case 0xbf: map_key_clear(KEY_NUMERIC_D);	break;
 869		default: goto ignore;
 870		}
 871		break;
 872
 873	case HID_UP_CONSUMER:	/* USB HUT v1.12, pages 75-84 */
 874		switch (usage->hid & HID_USAGE) {
 875		case 0x000: goto ignore;
 876		case 0x030: map_key_clear(KEY_POWER);		break;
 877		case 0x031: map_key_clear(KEY_RESTART);		break;
 878		case 0x032: map_key_clear(KEY_SLEEP);		break;
 879		case 0x034: map_key_clear(KEY_SLEEP);		break;
 880		case 0x035: map_key_clear(KEY_KBDILLUMTOGGLE);	break;
 881		case 0x036: map_key_clear(BTN_MISC);		break;
 882
 883		case 0x040: map_key_clear(KEY_MENU);		break; /* Menu */
 884		case 0x041: map_key_clear(KEY_SELECT);		break; /* Menu Pick */
 885		case 0x042: map_key_clear(KEY_UP);		break; /* Menu Up */
 886		case 0x043: map_key_clear(KEY_DOWN);		break; /* Menu Down */
 887		case 0x044: map_key_clear(KEY_LEFT);		break; /* Menu Left */
 888		case 0x045: map_key_clear(KEY_RIGHT);		break; /* Menu Right */
 889		case 0x046: map_key_clear(KEY_ESC);		break; /* Menu Escape */
 890		case 0x047: map_key_clear(KEY_KPPLUS);		break; /* Menu Value Increase */
 891		case 0x048: map_key_clear(KEY_KPMINUS);		break; /* Menu Value Decrease */
 892
 893		case 0x060: map_key_clear(KEY_INFO);		break; /* Data On Screen */
 894		case 0x061: map_key_clear(KEY_SUBTITLE);	break; /* Closed Caption */
 895		case 0x063: map_key_clear(KEY_VCR);		break; /* VCR/TV */
 896		case 0x065: map_key_clear(KEY_CAMERA);		break; /* Snapshot */
 897		case 0x069: map_key_clear(KEY_RED);		break;
 898		case 0x06a: map_key_clear(KEY_GREEN);		break;
 899		case 0x06b: map_key_clear(KEY_BLUE);		break;
 900		case 0x06c: map_key_clear(KEY_YELLOW);		break;
 901		case 0x06d: map_key_clear(KEY_ASPECT_RATIO);	break;
 902
 903		case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);		break;
 904		case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);		break;
 905		case 0x072: map_key_clear(KEY_BRIGHTNESS_TOGGLE);	break;
 906		case 0x073: map_key_clear(KEY_BRIGHTNESS_MIN);		break;
 907		case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);		break;
 908		case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);		break;
 909
 
 
 
 
 910		case 0x079: map_key_clear(KEY_KBDILLUMUP);	break;
 911		case 0x07a: map_key_clear(KEY_KBDILLUMDOWN);	break;
 912		case 0x07c: map_key_clear(KEY_KBDILLUMTOGGLE);	break;
 913
 914		case 0x082: map_key_clear(KEY_VIDEO_NEXT);	break;
 915		case 0x083: map_key_clear(KEY_LAST);		break;
 916		case 0x084: map_key_clear(KEY_ENTER);		break;
 917		case 0x088: map_key_clear(KEY_PC);		break;
 918		case 0x089: map_key_clear(KEY_TV);		break;
 919		case 0x08a: map_key_clear(KEY_WWW);		break;
 920		case 0x08b: map_key_clear(KEY_DVD);		break;
 921		case 0x08c: map_key_clear(KEY_PHONE);		break;
 922		case 0x08d: map_key_clear(KEY_PROGRAM);		break;
 923		case 0x08e: map_key_clear(KEY_VIDEOPHONE);	break;
 924		case 0x08f: map_key_clear(KEY_GAMES);		break;
 925		case 0x090: map_key_clear(KEY_MEMO);		break;
 926		case 0x091: map_key_clear(KEY_CD);		break;
 927		case 0x092: map_key_clear(KEY_VCR);		break;
 928		case 0x093: map_key_clear(KEY_TUNER);		break;
 929		case 0x094: map_key_clear(KEY_EXIT);		break;
 930		case 0x095: map_key_clear(KEY_HELP);		break;
 931		case 0x096: map_key_clear(KEY_TAPE);		break;
 932		case 0x097: map_key_clear(KEY_TV2);		break;
 933		case 0x098: map_key_clear(KEY_SAT);		break;
 934		case 0x09a: map_key_clear(KEY_PVR);		break;
 935
 936		case 0x09c: map_key_clear(KEY_CHANNELUP);	break;
 937		case 0x09d: map_key_clear(KEY_CHANNELDOWN);	break;
 938		case 0x0a0: map_key_clear(KEY_VCR2);		break;
 939
 940		case 0x0b0: map_key_clear(KEY_PLAY);		break;
 941		case 0x0b1: map_key_clear(KEY_PAUSE);		break;
 942		case 0x0b2: map_key_clear(KEY_RECORD);		break;
 943		case 0x0b3: map_key_clear(KEY_FASTFORWARD);	break;
 944		case 0x0b4: map_key_clear(KEY_REWIND);		break;
 945		case 0x0b5: map_key_clear(KEY_NEXTSONG);	break;
 946		case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);	break;
 947		case 0x0b7: map_key_clear(KEY_STOPCD);		break;
 948		case 0x0b8: map_key_clear(KEY_EJECTCD);		break;
 949		case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);	break;
 950		case 0x0b9: map_key_clear(KEY_SHUFFLE);		break;
 951		case 0x0bf: map_key_clear(KEY_SLOW);		break;
 952
 953		case 0x0cd: map_key_clear(KEY_PLAYPAUSE);	break;
 954		case 0x0cf: map_key_clear(KEY_VOICECOMMAND);	break;
 
 
 
 
 955		case 0x0e0: map_abs_clear(ABS_VOLUME);		break;
 956		case 0x0e2: map_key_clear(KEY_MUTE);		break;
 957		case 0x0e5: map_key_clear(KEY_BASSBOOST);	break;
 958		case 0x0e9: map_key_clear(KEY_VOLUMEUP);	break;
 959		case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);	break;
 960		case 0x0f5: map_key_clear(KEY_SLOW);		break;
 961
 962		case 0x181: map_key_clear(KEY_BUTTONCONFIG);	break;
 963		case 0x182: map_key_clear(KEY_BOOKMARKS);	break;
 964		case 0x183: map_key_clear(KEY_CONFIG);		break;
 965		case 0x184: map_key_clear(KEY_WORDPROCESSOR);	break;
 966		case 0x185: map_key_clear(KEY_EDITOR);		break;
 967		case 0x186: map_key_clear(KEY_SPREADSHEET);	break;
 968		case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);	break;
 969		case 0x188: map_key_clear(KEY_PRESENTATION);	break;
 970		case 0x189: map_key_clear(KEY_DATABASE);	break;
 971		case 0x18a: map_key_clear(KEY_MAIL);		break;
 972		case 0x18b: map_key_clear(KEY_NEWS);		break;
 973		case 0x18c: map_key_clear(KEY_VOICEMAIL);	break;
 974		case 0x18d: map_key_clear(KEY_ADDRESSBOOK);	break;
 975		case 0x18e: map_key_clear(KEY_CALENDAR);	break;
 976		case 0x18f: map_key_clear(KEY_TASKMANAGER);	break;
 977		case 0x190: map_key_clear(KEY_JOURNAL);		break;
 978		case 0x191: map_key_clear(KEY_FINANCE);		break;
 979		case 0x192: map_key_clear(KEY_CALC);		break;
 980		case 0x193: map_key_clear(KEY_PLAYER);		break;
 981		case 0x194: map_key_clear(KEY_FILE);		break;
 982		case 0x196: map_key_clear(KEY_WWW);		break;
 983		case 0x199: map_key_clear(KEY_CHAT);		break;
 984		case 0x19c: map_key_clear(KEY_LOGOFF);		break;
 985		case 0x19e: map_key_clear(KEY_COFFEE);		break;
 986		case 0x19f: map_key_clear(KEY_CONTROLPANEL);		break;
 987		case 0x1a2: map_key_clear(KEY_APPSELECT);		break;
 988		case 0x1a3: map_key_clear(KEY_NEXT);		break;
 989		case 0x1a4: map_key_clear(KEY_PREVIOUS);	break;
 990		case 0x1a6: map_key_clear(KEY_HELP);		break;
 991		case 0x1a7: map_key_clear(KEY_DOCUMENTS);	break;
 992		case 0x1ab: map_key_clear(KEY_SPELLCHECK);	break;
 993		case 0x1ae: map_key_clear(KEY_KEYBOARD);	break;
 994		case 0x1b1: map_key_clear(KEY_SCREENSAVER);		break;
 995		case 0x1b4: map_key_clear(KEY_FILE);		break;
 996		case 0x1b6: map_key_clear(KEY_IMAGES);		break;
 997		case 0x1b7: map_key_clear(KEY_AUDIO);		break;
 998		case 0x1b8: map_key_clear(KEY_VIDEO);		break;
 999		case 0x1bc: map_key_clear(KEY_MESSENGER);	break;
1000		case 0x1bd: map_key_clear(KEY_INFO);		break;
1001		case 0x1cb: map_key_clear(KEY_ASSISTANT);	break;
1002		case 0x201: map_key_clear(KEY_NEW);		break;
1003		case 0x202: map_key_clear(KEY_OPEN);		break;
1004		case 0x203: map_key_clear(KEY_CLOSE);		break;
1005		case 0x204: map_key_clear(KEY_EXIT);		break;
1006		case 0x207: map_key_clear(KEY_SAVE);		break;
1007		case 0x208: map_key_clear(KEY_PRINT);		break;
1008		case 0x209: map_key_clear(KEY_PROPS);		break;
1009		case 0x21a: map_key_clear(KEY_UNDO);		break;
1010		case 0x21b: map_key_clear(KEY_COPY);		break;
1011		case 0x21c: map_key_clear(KEY_CUT);		break;
1012		case 0x21d: map_key_clear(KEY_PASTE);		break;
1013		case 0x21f: map_key_clear(KEY_FIND);		break;
1014		case 0x221: map_key_clear(KEY_SEARCH);		break;
1015		case 0x222: map_key_clear(KEY_GOTO);		break;
1016		case 0x223: map_key_clear(KEY_HOMEPAGE);	break;
1017		case 0x224: map_key_clear(KEY_BACK);		break;
1018		case 0x225: map_key_clear(KEY_FORWARD);		break;
1019		case 0x226: map_key_clear(KEY_STOP);		break;
1020		case 0x227: map_key_clear(KEY_REFRESH);		break;
1021		case 0x22a: map_key_clear(KEY_BOOKMARKS);	break;
1022		case 0x22d: map_key_clear(KEY_ZOOMIN);		break;
1023		case 0x22e: map_key_clear(KEY_ZOOMOUT);		break;
1024		case 0x22f: map_key_clear(KEY_ZOOMRESET);	break;
1025		case 0x232: map_key_clear(KEY_FULL_SCREEN);	break;
1026		case 0x233: map_key_clear(KEY_SCROLLUP);	break;
1027		case 0x234: map_key_clear(KEY_SCROLLDOWN);	break;
1028		case 0x238: /* AC Pan */
1029			set_bit(REL_HWHEEL, input->relbit);
1030			map_rel(REL_HWHEEL_HI_RES);
1031			break;
1032		case 0x23d: map_key_clear(KEY_EDIT);		break;
1033		case 0x25f: map_key_clear(KEY_CANCEL);		break;
1034		case 0x269: map_key_clear(KEY_INSERT);		break;
1035		case 0x26a: map_key_clear(KEY_DELETE);		break;
1036		case 0x279: map_key_clear(KEY_REDO);		break;
1037
1038		case 0x289: map_key_clear(KEY_REPLY);		break;
1039		case 0x28b: map_key_clear(KEY_FORWARDMAIL);	break;
1040		case 0x28c: map_key_clear(KEY_SEND);		break;
1041
1042		case 0x29d: map_key_clear(KEY_KBD_LAYOUT_NEXT);	break;
1043
 
 
1044		case 0x2c7: map_key_clear(KEY_KBDINPUTASSIST_PREV);		break;
1045		case 0x2c8: map_key_clear(KEY_KBDINPUTASSIST_NEXT);		break;
1046		case 0x2c9: map_key_clear(KEY_KBDINPUTASSIST_PREVGROUP);		break;
1047		case 0x2ca: map_key_clear(KEY_KBDINPUTASSIST_NEXTGROUP);		break;
1048		case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);	break;
1049		case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);	break;
1050
1051		case 0x29f: map_key_clear(KEY_SCALE);		break;
1052
1053		default: map_key_clear(KEY_UNKNOWN);
1054		}
1055		break;
1056
1057	case HID_UP_GENDEVCTRLS:
1058		switch (usage->hid) {
1059		case HID_DC_BATTERYSTRENGTH:
1060			hidinput_setup_battery(device, HID_INPUT_REPORT, field);
1061			usage->type = EV_PWR;
1062			goto ignore;
1063		}
1064		goto unknown;
1065
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1066	case HID_UP_HPVENDOR:	/* Reported on a Dutch layout HP5308 */
1067		set_bit(EV_REP, input->evbit);
1068		switch (usage->hid & HID_USAGE) {
1069		case 0x021: map_key_clear(KEY_PRINT);           break;
1070		case 0x070: map_key_clear(KEY_HP);		break;
1071		case 0x071: map_key_clear(KEY_CAMERA);		break;
1072		case 0x072: map_key_clear(KEY_SOUND);		break;
1073		case 0x073: map_key_clear(KEY_QUESTION);	break;
1074		case 0x080: map_key_clear(KEY_EMAIL);		break;
1075		case 0x081: map_key_clear(KEY_CHAT);		break;
1076		case 0x082: map_key_clear(KEY_SEARCH);		break;
1077		case 0x083: map_key_clear(KEY_CONNECT);	        break;
1078		case 0x084: map_key_clear(KEY_FINANCE);		break;
1079		case 0x085: map_key_clear(KEY_SPORT);		break;
1080		case 0x086: map_key_clear(KEY_SHOP);	        break;
1081		default:    goto ignore;
1082		}
1083		break;
1084
1085	case HID_UP_HPVENDOR2:
1086		set_bit(EV_REP, input->evbit);
1087		switch (usage->hid & HID_USAGE) {
1088		case 0x001: map_key_clear(KEY_MICMUTE);		break;
1089		case 0x003: map_key_clear(KEY_BRIGHTNESSDOWN);	break;
1090		case 0x004: map_key_clear(KEY_BRIGHTNESSUP);	break;
1091		default:    goto ignore;
1092		}
1093		break;
1094
1095	case HID_UP_MSVENDOR:
1096		goto ignore;
1097
1098	case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
1099		set_bit(EV_REP, input->evbit);
1100		goto ignore;
1101
1102	case HID_UP_LOGIVENDOR:
1103		/* intentional fallback */
1104	case HID_UP_LOGIVENDOR2:
1105		/* intentional fallback */
1106	case HID_UP_LOGIVENDOR3:
1107		goto ignore;
1108
1109	case HID_UP_PID:
1110		switch (usage->hid & HID_USAGE) {
1111		case 0xa4: map_key_clear(BTN_DEAD);	break;
1112		default: goto ignore;
1113		}
1114		break;
1115
1116	default:
1117	unknown:
1118		if (field->report_size == 1) {
1119			if (field->report->type == HID_OUTPUT_REPORT) {
1120				map_led(LED_MISC);
1121				break;
1122			}
1123			map_key(BTN_MISC);
1124			break;
1125		}
1126		if (field->flags & HID_MAIN_ITEM_RELATIVE) {
1127			map_rel(REL_MISC);
1128			break;
1129		}
1130		map_abs(ABS_MISC);
1131		break;
1132	}
1133
1134mapped:
1135	/* Mapping failed, bail out */
1136	if (!bit)
1137		return;
1138
1139	if (device->driver->input_mapped &&
1140	    device->driver->input_mapped(device, hidinput, field, usage,
1141					 &bit, &max) < 0) {
1142		/*
1143		 * The driver indicated that no further generic handling
1144		 * of the usage is desired.
1145		 */
1146		return;
1147	}
1148
1149	set_bit(usage->type, input->evbit);
1150
1151	/*
1152	 * This part is *really* controversial:
1153	 * - HID aims at being generic so we should do our best to export
1154	 *   all incoming events
1155	 * - HID describes what events are, so there is no reason for ABS_X
1156	 *   to be mapped to ABS_Y
1157	 * - HID is using *_MISC+N as a default value, but nothing prevents
1158	 *   *_MISC+N to overwrite a legitimate even, which confuses userspace
1159	 *   (for instance ABS_MISC + 7 is ABS_MT_SLOT, which has a different
1160	 *   processing)
1161	 *
1162	 * If devices still want to use this (at their own risk), they will
1163	 * have to use the quirk HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE, but
1164	 * the default should be a reliable mapping.
1165	 */
1166	while (usage->code <= max && test_and_set_bit(usage->code, bit)) {
1167		if (device->quirks & HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE) {
1168			usage->code = find_next_zero_bit(bit,
1169							 max + 1,
1170							 usage->code);
1171		} else {
1172			device->status |= HID_STAT_DUP_DETECTED;
1173			goto ignore;
1174		}
1175	}
1176
1177	if (usage->code > max)
1178		goto ignore;
1179
1180	if (usage->type == EV_ABS) {
1181
1182		int a = field->logical_minimum;
1183		int b = field->logical_maximum;
1184
1185		if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
1186			a = field->logical_minimum = 0;
1187			b = field->logical_maximum = 255;
1188		}
1189
1190		if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
1191			input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
1192		else	input_set_abs_params(input, usage->code, a, b, 0, 0);
1193
1194		input_abs_set_res(input, usage->code,
1195				  hidinput_calc_abs_res(field, usage->code));
1196
1197		/* use a larger default input buffer for MT devices */
1198		if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
1199			input_set_events_per_packet(input, 60);
1200	}
1201
1202	if (usage->type == EV_ABS &&
1203	    (usage->hat_min < usage->hat_max || usage->hat_dir)) {
1204		int i;
1205		for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
1206			input_set_abs_params(input, i, -1, 1, 0, 0);
1207			set_bit(i, input->absbit);
1208		}
1209		if (usage->hat_dir && !field->dpad)
1210			field->dpad = usage->code;
1211	}
1212
1213	/* for those devices which produce Consumer volume usage as relative,
1214	 * we emulate pressing volumeup/volumedown appropriate number of times
1215	 * in hidinput_hid_event()
1216	 */
1217	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
1218			(usage->code == ABS_VOLUME)) {
1219		set_bit(KEY_VOLUMEUP, input->keybit);
1220		set_bit(KEY_VOLUMEDOWN, input->keybit);
1221	}
1222
1223	if (usage->type == EV_KEY) {
1224		set_bit(EV_MSC, input->evbit);
1225		set_bit(MSC_SCAN, input->mscbit);
1226	}
1227
1228	return;
1229
1230ignore:
1231	usage->type = 0;
1232	usage->code = 0;
1233}
1234
1235static void hidinput_handle_scroll(struct hid_usage *usage,
1236				   struct input_dev *input,
1237				   __s32 value)
1238{
1239	int code;
1240	int hi_res, lo_res;
1241
1242	if (value == 0)
1243		return;
1244
1245	if (usage->code == REL_WHEEL_HI_RES)
1246		code = REL_WHEEL;
1247	else
1248		code = REL_HWHEEL;
1249
1250	/*
1251	 * Windows reports one wheel click as value 120. Where a high-res
1252	 * scroll wheel is present, a fraction of 120 is reported instead.
1253	 * Our REL_WHEEL_HI_RES axis does the same because all HW must
1254	 * adhere to the 120 expectation.
1255	 */
1256	hi_res = value * 120/usage->resolution_multiplier;
1257
1258	usage->wheel_accumulated += hi_res;
1259	lo_res = usage->wheel_accumulated/120;
1260	if (lo_res)
1261		usage->wheel_accumulated -= lo_res * 120;
1262
1263	input_event(input, EV_REL, code, lo_res);
1264	input_event(input, EV_REL, usage->code, hi_res);
1265}
1266
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1267void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
1268{
1269	struct input_dev *input;
 
1270	unsigned *quirks = &hid->quirks;
1271
1272	if (!usage->type)
1273		return;
1274
1275	if (usage->type == EV_PWR) {
1276		hidinput_update_battery(hid, value);
 
 
 
 
1277		return;
1278	}
1279
1280	if (!field->hidinput)
1281		return;
1282
1283	input = field->hidinput->input;
1284
1285	if (usage->hat_min < usage->hat_max || usage->hat_dir) {
1286		int hat_dir = usage->hat_dir;
1287		if (!hat_dir)
1288			hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
1289		if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
1290		input_event(input, usage->type, usage->code    , hid_hat_to_axis[hat_dir].x);
1291		input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
1292		return;
1293	}
1294
1295	if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
1296		*quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
1297		return;
1298	}
1299
1300	if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
1301		if (value) {
1302			input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
1303			return;
1304		}
1305		input_event(input, usage->type, usage->code, 0);
1306		input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
1307		return;
1308	}
1309
1310	if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
1311		int a = field->logical_minimum;
1312		int b = field->logical_maximum;
1313		input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
1314	}
1315
1316	if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
1317		dbg_hid("Maximum Effects - %d\n",value);
1318		return;
1319	}
1320
1321	if (usage->hid == (HID_UP_PID | 0x7fUL)) {
1322		dbg_hid("PID Pool Report\n");
1323		return;
1324	}
1325
1326	if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
1327		return;
1328
1329	if ((usage->type == EV_REL) && (usage->code == REL_WHEEL_HI_RES ||
1330					usage->code == REL_HWHEEL_HI_RES)) {
1331		hidinput_handle_scroll(usage, input, value);
1332		return;
1333	}
1334
1335	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
1336			(usage->code == ABS_VOLUME)) {
1337		int count = abs(value);
1338		int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
1339		int i;
1340
1341		for (i = 0; i < count; i++) {
1342			input_event(input, EV_KEY, direction, 1);
1343			input_sync(input);
1344			input_event(input, EV_KEY, direction, 0);
1345			input_sync(input);
1346		}
1347		return;
1348	}
1349
1350	/*
1351	 * Ignore out-of-range values as per HID specification,
1352	 * section 5.10 and 6.2.25, when NULL state bit is present.
1353	 * When it's not, clamp the value to match Microsoft's input
1354	 * driver as mentioned in "Required HID usages for digitizers":
1355	 * https://msdn.microsoft.com/en-us/library/windows/hardware/dn672278(v=vs.85).asp
1356	 *
1357	 * The logical_minimum < logical_maximum check is done so that we
1358	 * don't unintentionally discard values sent by devices which
1359	 * don't specify logical min and max.
1360	 */
1361	if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
1362	    (field->logical_minimum < field->logical_maximum)) {
1363		if (field->flags & HID_MAIN_ITEM_NULL_STATE &&
1364		    (value < field->logical_minimum ||
1365		     value > field->logical_maximum)) {
1366			dbg_hid("Ignoring out-of-range value %x\n", value);
1367			return;
1368		}
1369		value = clamp(value,
1370			      field->logical_minimum,
1371			      field->logical_maximum);
1372	}
1373
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1374	/*
1375	 * Ignore reports for absolute data if the data didn't change. This is
1376	 * not only an optimization but also fixes 'dead' key reports. Some
1377	 * RollOver implementations for localized keys (like BACKSLASH/PIPE; HID
1378	 * 0x31 and 0x32) report multiple keys, even though a localized keyboard
1379	 * can only have one of them physically available. The 'dead' keys
1380	 * report constant 0. As all map to the same keycode, they'd confuse
1381	 * the input layer. If we filter the 'dead' keys on the HID level, we
1382	 * skip the keycode translation and only forward real events.
1383	 */
1384	if (!(field->flags & (HID_MAIN_ITEM_RELATIVE |
1385	                      HID_MAIN_ITEM_BUFFERED_BYTE)) &&
1386			      (field->flags & HID_MAIN_ITEM_VARIABLE) &&
1387	    usage->usage_index < field->maxusage &&
1388	    value == field->value[usage->usage_index])
1389		return;
1390
1391	/* report the usage code as scancode if the key status has changed */
1392	if (usage->type == EV_KEY &&
1393	    (!test_bit(usage->code, input->key)) == value)
1394		input_event(input, EV_MSC, MSC_SCAN, usage->hid);
1395
1396	input_event(input, usage->type, usage->code, value);
1397
1398	if ((field->flags & HID_MAIN_ITEM_RELATIVE) &&
1399	    usage->type == EV_KEY && value) {
1400		input_sync(input);
1401		input_event(input, usage->type, usage->code, 0);
1402	}
1403}
1404
1405void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
1406{
1407	struct hid_input *hidinput;
1408
1409	if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
1410		return;
1411
1412	list_for_each_entry(hidinput, &hid->inputs, list)
1413		input_sync(hidinput->input);
1414}
1415EXPORT_SYMBOL_GPL(hidinput_report_event);
1416
1417int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
 
1418{
1419	struct hid_report *report;
1420	int i, j;
1421
1422	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
1423		for (i = 0; i < report->maxfield; i++) {
1424			*field = report->field[i];
1425			for (j = 0; j < (*field)->maxusage; j++)
1426				if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
1427					return j;
1428		}
1429	}
1430	return -1;
1431}
1432EXPORT_SYMBOL_GPL(hidinput_find_field);
1433
1434struct hid_field *hidinput_get_led_field(struct hid_device *hid)
1435{
1436	struct hid_report *report;
1437	struct hid_field *field;
1438	int i, j;
1439
1440	list_for_each_entry(report,
1441			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1442			    list) {
1443		for (i = 0; i < report->maxfield; i++) {
1444			field = report->field[i];
1445			for (j = 0; j < field->maxusage; j++)
1446				if (field->usage[j].type == EV_LED)
1447					return field;
1448		}
1449	}
1450	return NULL;
1451}
1452EXPORT_SYMBOL_GPL(hidinput_get_led_field);
1453
1454unsigned int hidinput_count_leds(struct hid_device *hid)
1455{
1456	struct hid_report *report;
1457	struct hid_field *field;
1458	int i, j;
1459	unsigned int count = 0;
1460
1461	list_for_each_entry(report,
1462			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1463			    list) {
1464		for (i = 0; i < report->maxfield; i++) {
1465			field = report->field[i];
1466			for (j = 0; j < field->maxusage; j++)
1467				if (field->usage[j].type == EV_LED &&
1468				    field->value[j])
1469					count += 1;
1470		}
1471	}
1472	return count;
1473}
1474EXPORT_SYMBOL_GPL(hidinput_count_leds);
1475
1476static void hidinput_led_worker(struct work_struct *work)
1477{
1478	struct hid_device *hid = container_of(work, struct hid_device,
1479					      led_work);
1480	struct hid_field *field;
1481	struct hid_report *report;
1482	int ret;
1483	u32 len;
1484	__u8 *buf;
1485
1486	field = hidinput_get_led_field(hid);
1487	if (!field)
1488		return;
1489
1490	/*
1491	 * field->report is accessed unlocked regarding HID core. So there might
1492	 * be another incoming SET-LED request from user-space, which changes
1493	 * the LED state while we assemble our outgoing buffer. However, this
1494	 * doesn't matter as hid_output_report() correctly converts it into a
1495	 * boolean value no matter what information is currently set on the LED
1496	 * field (even garbage). So the remote device will always get a valid
1497	 * request.
1498	 * And in case we send a wrong value, a next led worker is spawned
1499	 * for every SET-LED request so the following worker will send the
1500	 * correct value, guaranteed!
1501	 */
1502
1503	report = field->report;
1504
1505	/* use custom SET_REPORT request if possible (asynchronous) */
1506	if (hid->ll_driver->request)
1507		return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
1508
1509	/* fall back to generic raw-output-report */
1510	len = hid_report_len(report);
1511	buf = hid_alloc_report_buf(report, GFP_KERNEL);
1512	if (!buf)
1513		return;
1514
1515	hid_output_report(report, buf);
1516	/* synchronous output report */
1517	ret = hid_hw_output_report(hid, buf, len);
1518	if (ret == -ENOSYS)
1519		hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
1520				HID_REQ_SET_REPORT);
1521	kfree(buf);
1522}
1523
1524static int hidinput_input_event(struct input_dev *dev, unsigned int type,
1525				unsigned int code, int value)
1526{
1527	struct hid_device *hid = input_get_drvdata(dev);
1528	struct hid_field *field;
1529	int offset;
1530
1531	if (type == EV_FF)
1532		return input_ff_event(dev, type, code, value);
1533
1534	if (type != EV_LED)
1535		return -1;
1536
1537	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
1538		hid_warn(dev, "event field not found\n");
1539		return -1;
1540	}
1541
1542	hid_set_field(field, offset, value);
1543
1544	schedule_work(&hid->led_work);
1545	return 0;
1546}
1547
1548static int hidinput_open(struct input_dev *dev)
1549{
1550	struct hid_device *hid = input_get_drvdata(dev);
1551
1552	return hid_hw_open(hid);
1553}
1554
1555static void hidinput_close(struct input_dev *dev)
1556{
1557	struct hid_device *hid = input_get_drvdata(dev);
1558
1559	hid_hw_close(hid);
1560}
1561
1562static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
1563		struct hid_report *report, bool use_logical_max)
1564{
1565	struct hid_usage *usage;
1566	bool update_needed = false;
1567	bool get_report_completed = false;
1568	int i, j;
1569
1570	if (report->maxfield == 0)
1571		return false;
1572
1573	for (i = 0; i < report->maxfield; i++) {
1574		__s32 value = use_logical_max ?
1575			      report->field[i]->logical_maximum :
1576			      report->field[i]->logical_minimum;
1577
1578		/* There is no good reason for a Resolution
1579		 * Multiplier to have a count other than 1.
1580		 * Ignore that case.
1581		 */
1582		if (report->field[i]->report_count != 1)
1583			continue;
1584
1585		for (j = 0; j < report->field[i]->maxusage; j++) {
1586			usage = &report->field[i]->usage[j];
1587
1588			if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
1589				continue;
1590
1591			/*
1592			 * If we have more than one feature within this
1593			 * report we need to fill in the bits from the
1594			 * others before we can overwrite the ones for the
1595			 * Resolution Multiplier.
1596			 *
1597			 * But if we're not allowed to read from the device,
1598			 * we just bail. Such a device should not exist
1599			 * anyway.
1600			 */
1601			if (!get_report_completed && report->maxfield > 1) {
1602				if (hid->quirks & HID_QUIRK_NO_INIT_REPORTS)
1603					return update_needed;
1604
1605				hid_hw_request(hid, report, HID_REQ_GET_REPORT);
1606				hid_hw_wait(hid);
1607				get_report_completed = true;
1608			}
1609
1610			report->field[i]->value[j] = value;
1611			update_needed = true;
1612		}
1613	}
1614
1615	return update_needed;
1616}
1617
1618static void hidinput_change_resolution_multipliers(struct hid_device *hid)
1619{
1620	struct hid_report_enum *rep_enum;
1621	struct hid_report *rep;
1622	int ret;
1623
1624	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1625	list_for_each_entry(rep, &rep_enum->report_list, list) {
1626		bool update_needed = __hidinput_change_resolution_multipliers(hid,
1627								     rep, true);
1628
1629		if (update_needed) {
1630			ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
1631			if (ret) {
1632				__hidinput_change_resolution_multipliers(hid,
1633								    rep, false);
1634				return;
1635			}
1636		}
1637	}
1638
1639	/* refresh our structs */
1640	hid_setup_resolution_multiplier(hid);
1641}
1642
1643static void report_features(struct hid_device *hid)
1644{
1645	struct hid_driver *drv = hid->driver;
1646	struct hid_report_enum *rep_enum;
1647	struct hid_report *rep;
1648	struct hid_usage *usage;
1649	int i, j;
1650
1651	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1652	list_for_each_entry(rep, &rep_enum->report_list, list)
1653		for (i = 0; i < rep->maxfield; i++) {
1654			/* Ignore if report count is out of bounds. */
1655			if (rep->field[i]->report_count < 1)
1656				continue;
1657
1658			for (j = 0; j < rep->field[i]->maxusage; j++) {
1659				usage = &rep->field[i]->usage[j];
1660
1661				/* Verify if Battery Strength feature is available */
1662				if (usage->hid == HID_DC_BATTERYSTRENGTH)
1663					hidinput_setup_battery(hid, HID_FEATURE_REPORT,
1664							       rep->field[i]);
1665
1666				if (drv->feature_mapping)
1667					drv->feature_mapping(hid, rep->field[i], usage);
1668			}
1669		}
1670}
1671
1672static struct hid_input *hidinput_allocate(struct hid_device *hid,
1673					   unsigned int application)
1674{
1675	struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
1676	struct input_dev *input_dev = input_allocate_device();
1677	const char *suffix = NULL;
1678	size_t suffix_len, name_len;
1679
1680	if (!hidinput || !input_dev)
1681		goto fail;
1682
1683	if ((hid->quirks & HID_QUIRK_INPUT_PER_APP) &&
1684	    hid->maxapplication > 1) {
1685		switch (application) {
1686		case HID_GD_KEYBOARD:
1687			suffix = "Keyboard";
1688			break;
1689		case HID_GD_KEYPAD:
1690			suffix = "Keypad";
1691			break;
1692		case HID_GD_MOUSE:
1693			suffix = "Mouse";
1694			break;
 
 
 
 
 
 
 
 
 
 
1695		case HID_DG_STYLUS:
1696			suffix = "Pen";
1697			break;
1698		case HID_DG_TOUCHSCREEN:
1699			suffix = "Touchscreen";
1700			break;
1701		case HID_DG_TOUCHPAD:
1702			suffix = "Touchpad";
1703			break;
1704		case HID_GD_SYSTEM_CONTROL:
1705			suffix = "System Control";
1706			break;
1707		case HID_CP_CONSUMER_CONTROL:
1708			suffix = "Consumer Control";
1709			break;
1710		case HID_GD_WIRELESS_RADIO_CTLS:
1711			suffix = "Wireless Radio Control";
1712			break;
1713		case HID_GD_SYSTEM_MULTIAXIS:
1714			suffix = "System Multi Axis";
1715			break;
1716		default:
1717			break;
1718		}
1719	}
1720
1721	if (suffix) {
1722		name_len = strlen(hid->name);
1723		suffix_len = strlen(suffix);
1724		if ((name_len < suffix_len) ||
1725		    strcmp(hid->name + name_len - suffix_len, suffix)) {
1726			hidinput->name = kasprintf(GFP_KERNEL, "%s %s",
1727						   hid->name, suffix);
1728			if (!hidinput->name)
1729				goto fail;
1730		}
1731	}
1732
1733	input_set_drvdata(input_dev, hid);
1734	input_dev->event = hidinput_input_event;
1735	input_dev->open = hidinput_open;
1736	input_dev->close = hidinput_close;
1737	input_dev->setkeycode = hidinput_setkeycode;
1738	input_dev->getkeycode = hidinput_getkeycode;
1739
1740	input_dev->name = hidinput->name ? hidinput->name : hid->name;
1741	input_dev->phys = hid->phys;
1742	input_dev->uniq = hid->uniq;
1743	input_dev->id.bustype = hid->bus;
1744	input_dev->id.vendor  = hid->vendor;
1745	input_dev->id.product = hid->product;
1746	input_dev->id.version = hid->version;
1747	input_dev->dev.parent = &hid->dev;
1748
1749	hidinput->input = input_dev;
1750	hidinput->application = application;
1751	list_add_tail(&hidinput->list, &hid->inputs);
1752
1753	INIT_LIST_HEAD(&hidinput->reports);
1754
1755	return hidinput;
1756
1757fail:
1758	kfree(hidinput);
1759	input_free_device(input_dev);
1760	hid_err(hid, "Out of memory during hid input probe\n");
1761	return NULL;
1762}
1763
1764static bool hidinput_has_been_populated(struct hid_input *hidinput)
1765{
1766	int i;
1767	unsigned long r = 0;
1768
1769	for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
1770		r |= hidinput->input->evbit[i];
1771
1772	for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
1773		r |= hidinput->input->keybit[i];
1774
1775	for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
1776		r |= hidinput->input->relbit[i];
1777
1778	for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
1779		r |= hidinput->input->absbit[i];
1780
1781	for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
1782		r |= hidinput->input->mscbit[i];
1783
1784	for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
1785		r |= hidinput->input->ledbit[i];
1786
1787	for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
1788		r |= hidinput->input->sndbit[i];
1789
1790	for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
1791		r |= hidinput->input->ffbit[i];
1792
1793	for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
1794		r |= hidinput->input->swbit[i];
1795
1796	return !!r;
1797}
1798
1799static void hidinput_cleanup_hidinput(struct hid_device *hid,
1800		struct hid_input *hidinput)
1801{
1802	struct hid_report *report;
1803	int i, k;
1804
1805	list_del(&hidinput->list);
1806	input_free_device(hidinput->input);
1807	kfree(hidinput->name);
1808
1809	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
1810		if (k == HID_OUTPUT_REPORT &&
1811			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
1812			continue;
1813
1814		list_for_each_entry(report, &hid->report_enum[k].report_list,
1815				    list) {
1816
1817			for (i = 0; i < report->maxfield; i++)
1818				if (report->field[i]->hidinput == hidinput)
1819					report->field[i]->hidinput = NULL;
1820		}
1821	}
1822
1823	kfree(hidinput);
1824}
1825
1826static struct hid_input *hidinput_match(struct hid_report *report)
1827{
1828	struct hid_device *hid = report->device;
1829	struct hid_input *hidinput;
1830
1831	list_for_each_entry(hidinput, &hid->inputs, list) {
1832		if (hidinput->report &&
1833		    hidinput->report->id == report->id)
1834			return hidinput;
1835	}
1836
1837	return NULL;
1838}
1839
1840static struct hid_input *hidinput_match_application(struct hid_report *report)
1841{
1842	struct hid_device *hid = report->device;
1843	struct hid_input *hidinput;
1844
1845	list_for_each_entry(hidinput, &hid->inputs, list) {
1846		if (hidinput->application == report->application)
1847			return hidinput;
 
 
 
 
 
 
 
 
 
 
1848	}
1849
1850	return NULL;
1851}
1852
1853static inline void hidinput_configure_usages(struct hid_input *hidinput,
1854					     struct hid_report *report)
1855{
1856	int i, j;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1857
1858	for (i = 0; i < report->maxfield; i++)
1859		for (j = 0; j < report->field[i]->maxusage; j++)
1860			hidinput_configure_usage(hidinput, report->field[i],
1861						 report->field[i]->usage + j);
 
1862}
1863
1864/*
1865 * Register the input device; print a message.
1866 * Configure the input layer interface
1867 * Read all reports and initialize the absolute field values.
1868 */
1869
1870int hidinput_connect(struct hid_device *hid, unsigned int force)
1871{
1872	struct hid_driver *drv = hid->driver;
1873	struct hid_report *report;
1874	struct hid_input *next, *hidinput = NULL;
1875	unsigned int application;
1876	int i, k;
1877
1878	INIT_LIST_HEAD(&hid->inputs);
1879	INIT_WORK(&hid->led_work, hidinput_led_worker);
1880
1881	hid->status &= ~HID_STAT_DUP_DETECTED;
1882
1883	if (!force) {
1884		for (i = 0; i < hid->maxcollection; i++) {
1885			struct hid_collection *col = &hid->collection[i];
1886			if (col->type == HID_COLLECTION_APPLICATION ||
1887					col->type == HID_COLLECTION_PHYSICAL)
1888				if (IS_INPUT_APPLICATION(col->usage))
1889					break;
1890		}
1891
1892		if (i == hid->maxcollection)
1893			return -1;
1894	}
1895
1896	report_features(hid);
1897
1898	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
1899		if (k == HID_OUTPUT_REPORT &&
1900			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
1901			continue;
1902
1903		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
1904
1905			if (!report->maxfield)
1906				continue;
1907
1908			application = report->application;
1909
1910			/*
1911			 * Find the previous hidinput report attached
1912			 * to this report id.
1913			 */
1914			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
1915				hidinput = hidinput_match(report);
1916			else if (hid->maxapplication > 1 &&
1917				 (hid->quirks & HID_QUIRK_INPUT_PER_APP))
1918				hidinput = hidinput_match_application(report);
1919
1920			if (!hidinput) {
1921				hidinput = hidinput_allocate(hid, application);
1922				if (!hidinput)
1923					goto out_unwind;
1924			}
1925
1926			hidinput_configure_usages(hidinput, report);
1927
1928			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
1929				hidinput->report = report;
1930
1931			list_add_tail(&report->hidinput_list,
1932				      &hidinput->reports);
1933		}
1934	}
1935
1936	hidinput_change_resolution_multipliers(hid);
1937
1938	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
1939		if (drv->input_configured &&
1940		    drv->input_configured(hid, hidinput))
1941			goto out_unwind;
1942
1943		if (!hidinput_has_been_populated(hidinput)) {
1944			/* no need to register an input device not populated */
1945			hidinput_cleanup_hidinput(hid, hidinput);
1946			continue;
1947		}
1948
1949		if (input_register_device(hidinput->input))
1950			goto out_unwind;
1951		hidinput->registered = true;
1952	}
1953
1954	if (list_empty(&hid->inputs)) {
1955		hid_err(hid, "No inputs registered, leaving\n");
1956		goto out_unwind;
1957	}
1958
1959	if (hid->status & HID_STAT_DUP_DETECTED)
1960		hid_dbg(hid,
1961			"Some usages could not be mapped, please use HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE if this is legitimate.\n");
1962
1963	return 0;
1964
1965out_unwind:
1966	/* unwind the ones we already registered */
1967	hidinput_disconnect(hid);
1968
1969	return -1;
1970}
1971EXPORT_SYMBOL_GPL(hidinput_connect);
1972
1973void hidinput_disconnect(struct hid_device *hid)
1974{
1975	struct hid_input *hidinput, *next;
1976
1977	hidinput_cleanup_battery(hid);
1978
1979	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
1980		list_del(&hidinput->list);
1981		if (hidinput->registered)
1982			input_unregister_device(hidinput->input);
1983		else
1984			input_free_device(hidinput->input);
1985		kfree(hidinput->name);
1986		kfree(hidinput);
1987	}
1988
1989	/* led_work is spawned by input_dev callbacks, but doesn't access the
1990	 * parent input_dev at all. Once all input devices are removed, we
1991	 * know that led_work will never get restarted, so we can cancel it
1992	 * synchronously and are safe. */
1993	cancel_work_sync(&hid->led_work);
1994}
1995EXPORT_SYMBOL_GPL(hidinput_disconnect);