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(2, GFP_KERNEL);
 354	if (!buf)
 355		return -ENOMEM;
 356
 357	ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 2,
 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	if (device->driver->input_mapped && device->driver->input_mapped(device,
1136				hidinput, field, usage, &bit, &max) < 0)
1137		goto ignore;
1138
1139	set_bit(usage->type, input->evbit);
1140
1141	/*
1142	 * This part is *really* controversial:
1143	 * - HID aims at being generic so we should do our best to export
1144	 *   all incoming events
1145	 * - HID describes what events are, so there is no reason for ABS_X
1146	 *   to be mapped to ABS_Y
1147	 * - HID is using *_MISC+N as a default value, but nothing prevents
1148	 *   *_MISC+N to overwrite a legitimate even, which confuses userspace
1149	 *   (for instance ABS_MISC + 7 is ABS_MT_SLOT, which has a different
1150	 *   processing)
1151	 *
1152	 * If devices still want to use this (at their own risk), they will
1153	 * have to use the quirk HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE, but
1154	 * the default should be a reliable mapping.
1155	 */
1156	while (usage->code <= max && test_and_set_bit(usage->code, bit)) {
1157		if (device->quirks & HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE) {
1158			usage->code = find_next_zero_bit(bit,
1159							 max + 1,
1160							 usage->code);
1161		} else {
1162			device->status |= HID_STAT_DUP_DETECTED;
1163			goto ignore;
1164		}
1165	}
1166
1167	if (usage->code > max)
1168		goto ignore;
1169
 
1170	if (usage->type == EV_ABS) {
1171
1172		int a = field->logical_minimum;
1173		int b = field->logical_maximum;
1174
1175		if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
1176			a = field->logical_minimum = 0;
1177			b = field->logical_maximum = 255;
1178		}
1179
1180		if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
1181			input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
1182		else	input_set_abs_params(input, usage->code, a, b, 0, 0);
1183
1184		input_abs_set_res(input, usage->code,
1185				  hidinput_calc_abs_res(field, usage->code));
1186
1187		/* use a larger default input buffer for MT devices */
1188		if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
1189			input_set_events_per_packet(input, 60);
1190	}
1191
1192	if (usage->type == EV_ABS &&
1193	    (usage->hat_min < usage->hat_max || usage->hat_dir)) {
1194		int i;
1195		for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
1196			input_set_abs_params(input, i, -1, 1, 0, 0);
1197			set_bit(i, input->absbit);
1198		}
1199		if (usage->hat_dir && !field->dpad)
1200			field->dpad = usage->code;
1201	}
1202
1203	/* for those devices which produce Consumer volume usage as relative,
1204	 * we emulate pressing volumeup/volumedown appropriate number of times
1205	 * in hidinput_hid_event()
1206	 */
1207	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
1208			(usage->code == ABS_VOLUME)) {
1209		set_bit(KEY_VOLUMEUP, input->keybit);
1210		set_bit(KEY_VOLUMEDOWN, input->keybit);
1211	}
1212
1213	if (usage->type == EV_KEY) {
1214		set_bit(EV_MSC, input->evbit);
1215		set_bit(MSC_SCAN, input->mscbit);
1216	}
1217
1218ignore:
1219	return;
1220
1221}
1222
1223static void hidinput_handle_scroll(struct hid_usage *usage,
1224				   struct input_dev *input,
1225				   __s32 value)
1226{
1227	int code;
1228	int hi_res, lo_res;
1229
1230	if (value == 0)
1231		return;
1232
1233	if (usage->code == REL_WHEEL_HI_RES)
1234		code = REL_WHEEL;
1235	else
1236		code = REL_HWHEEL;
1237
1238	/*
1239	 * Windows reports one wheel click as value 120. Where a high-res
1240	 * scroll wheel is present, a fraction of 120 is reported instead.
1241	 * Our REL_WHEEL_HI_RES axis does the same because all HW must
1242	 * adhere to the 120 expectation.
1243	 */
1244	hi_res = value * 120/usage->resolution_multiplier;
1245
1246	usage->wheel_accumulated += hi_res;
1247	lo_res = usage->wheel_accumulated/120;
1248	if (lo_res)
1249		usage->wheel_accumulated -= lo_res * 120;
1250
1251	input_event(input, EV_REL, code, lo_res);
1252	input_event(input, EV_REL, usage->code, hi_res);
1253}
1254
1255void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
1256{
1257	struct input_dev *input;
1258	unsigned *quirks = &hid->quirks;
1259
1260	if (!usage->type)
1261		return;
1262
1263	if (usage->type == EV_PWR) {
1264		hidinput_update_battery(hid, value);
1265		return;
1266	}
1267
1268	if (!field->hidinput)
1269		return;
1270
1271	input = field->hidinput->input;
1272
 
 
 
1273	if (usage->hat_min < usage->hat_max || usage->hat_dir) {
1274		int hat_dir = usage->hat_dir;
1275		if (!hat_dir)
1276			hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
1277		if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
1278		input_event(input, usage->type, usage->code    , hid_hat_to_axis[hat_dir].x);
1279		input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
1280		return;
1281	}
1282
1283	if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
1284		*quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
1285		return;
1286	}
1287
1288	if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
1289		if (value) {
1290			input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
1291			return;
1292		}
1293		input_event(input, usage->type, usage->code, 0);
1294		input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
1295		return;
1296	}
1297
1298	if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
1299		int a = field->logical_minimum;
1300		int b = field->logical_maximum;
1301		input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
1302	}
1303
1304	if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
1305		dbg_hid("Maximum Effects - %d\n",value);
1306		return;
1307	}
1308
1309	if (usage->hid == (HID_UP_PID | 0x7fUL)) {
1310		dbg_hid("PID Pool Report\n");
1311		return;
1312	}
1313
1314	if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
1315		return;
1316
1317	if ((usage->type == EV_REL) && (usage->code == REL_WHEEL_HI_RES ||
1318					usage->code == REL_HWHEEL_HI_RES)) {
1319		hidinput_handle_scroll(usage, input, value);
1320		return;
1321	}
1322
1323	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
1324			(usage->code == ABS_VOLUME)) {
1325		int count = abs(value);
1326		int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
1327		int i;
1328
1329		for (i = 0; i < count; i++) {
1330			input_event(input, EV_KEY, direction, 1);
1331			input_sync(input);
1332			input_event(input, EV_KEY, direction, 0);
1333			input_sync(input);
1334		}
1335		return;
1336	}
1337
1338	/*
1339	 * Ignore out-of-range values as per HID specification,
1340	 * section 5.10 and 6.2.25, when NULL state bit is present.
1341	 * When it's not, clamp the value to match Microsoft's input
1342	 * driver as mentioned in "Required HID usages for digitizers":
1343	 * https://msdn.microsoft.com/en-us/library/windows/hardware/dn672278(v=vs.85).asp
1344	 *
1345	 * The logical_minimum < logical_maximum check is done so that we
1346	 * don't unintentionally discard values sent by devices which
1347	 * don't specify logical min and max.
1348	 */
1349	if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
1350	    (field->logical_minimum < field->logical_maximum)) {
1351		if (field->flags & HID_MAIN_ITEM_NULL_STATE &&
1352		    (value < field->logical_minimum ||
1353		     value > field->logical_maximum)) {
1354			dbg_hid("Ignoring out-of-range value %x\n", value);
1355			return;
1356		}
1357		value = clamp(value,
1358			      field->logical_minimum,
1359			      field->logical_maximum);
1360	}
1361
1362	/*
1363	 * Ignore reports for absolute data if the data didn't change. This is
1364	 * not only an optimization but also fixes 'dead' key reports. Some
1365	 * RollOver implementations for localized keys (like BACKSLASH/PIPE; HID
1366	 * 0x31 and 0x32) report multiple keys, even though a localized keyboard
1367	 * can only have one of them physically available. The 'dead' keys
1368	 * report constant 0. As all map to the same keycode, they'd confuse
1369	 * the input layer. If we filter the 'dead' keys on the HID level, we
1370	 * skip the keycode translation and only forward real events.
1371	 */
1372	if (!(field->flags & (HID_MAIN_ITEM_RELATIVE |
1373	                      HID_MAIN_ITEM_BUFFERED_BYTE)) &&
1374			      (field->flags & HID_MAIN_ITEM_VARIABLE) &&
1375	    usage->usage_index < field->maxusage &&
1376	    value == field->value[usage->usage_index])
1377		return;
 
1378
1379	/* report the usage code as scancode if the key status has changed */
1380	if (usage->type == EV_KEY &&
1381	    (!test_bit(usage->code, input->key)) == value)
1382		input_event(input, EV_MSC, MSC_SCAN, usage->hid);
1383
1384	input_event(input, usage->type, usage->code, value);
1385
1386	if ((field->flags & HID_MAIN_ITEM_RELATIVE) &&
1387	    usage->type == EV_KEY && value) {
1388		input_sync(input);
1389		input_event(input, usage->type, usage->code, 0);
1390	}
1391}
1392
1393void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
1394{
1395	struct hid_input *hidinput;
1396
1397	if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
1398		return;
1399
1400	list_for_each_entry(hidinput, &hid->inputs, list)
1401		input_sync(hidinput->input);
1402}
1403EXPORT_SYMBOL_GPL(hidinput_report_event);
1404
1405int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
1406{
1407	struct hid_report *report;
1408	int i, j;
1409
1410	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
1411		for (i = 0; i < report->maxfield; i++) {
1412			*field = report->field[i];
1413			for (j = 0; j < (*field)->maxusage; j++)
1414				if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
1415					return j;
1416		}
1417	}
1418	return -1;
1419}
1420EXPORT_SYMBOL_GPL(hidinput_find_field);
1421
1422struct hid_field *hidinput_get_led_field(struct hid_device *hid)
1423{
1424	struct hid_report *report;
1425	struct hid_field *field;
1426	int i, j;
1427
1428	list_for_each_entry(report,
1429			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1430			    list) {
1431		for (i = 0; i < report->maxfield; i++) {
1432			field = report->field[i];
1433			for (j = 0; j < field->maxusage; j++)
1434				if (field->usage[j].type == EV_LED)
1435					return field;
1436		}
1437	}
1438	return NULL;
1439}
1440EXPORT_SYMBOL_GPL(hidinput_get_led_field);
1441
1442unsigned int hidinput_count_leds(struct hid_device *hid)
1443{
1444	struct hid_report *report;
1445	struct hid_field *field;
1446	int i, j;
1447	unsigned int count = 0;
1448
1449	list_for_each_entry(report,
1450			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1451			    list) {
1452		for (i = 0; i < report->maxfield; i++) {
1453			field = report->field[i];
1454			for (j = 0; j < field->maxusage; j++)
1455				if (field->usage[j].type == EV_LED &&
1456				    field->value[j])
1457					count += 1;
1458		}
1459	}
1460	return count;
1461}
1462EXPORT_SYMBOL_GPL(hidinput_count_leds);
1463
1464static void hidinput_led_worker(struct work_struct *work)
1465{
1466	struct hid_device *hid = container_of(work, struct hid_device,
1467					      led_work);
1468	struct hid_field *field;
1469	struct hid_report *report;
1470	int ret;
1471	u32 len;
1472	__u8 *buf;
1473
1474	field = hidinput_get_led_field(hid);
1475	if (!field)
1476		return;
1477
1478	/*
1479	 * field->report is accessed unlocked regarding HID core. So there might
1480	 * be another incoming SET-LED request from user-space, which changes
1481	 * the LED state while we assemble our outgoing buffer. However, this
1482	 * doesn't matter as hid_output_report() correctly converts it into a
1483	 * boolean value no matter what information is currently set on the LED
1484	 * field (even garbage). So the remote device will always get a valid
1485	 * request.
1486	 * And in case we send a wrong value, a next led worker is spawned
1487	 * for every SET-LED request so the following worker will send the
1488	 * correct value, guaranteed!
1489	 */
1490
1491	report = field->report;
1492
1493	/* use custom SET_REPORT request if possible (asynchronous) */
1494	if (hid->ll_driver->request)
1495		return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
1496
1497	/* fall back to generic raw-output-report */
1498	len = hid_report_len(report);
1499	buf = hid_alloc_report_buf(report, GFP_KERNEL);
1500	if (!buf)
1501		return;
1502
1503	hid_output_report(report, buf);
1504	/* synchronous output report */
1505	ret = hid_hw_output_report(hid, buf, len);
1506	if (ret == -ENOSYS)
1507		hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
1508				HID_REQ_SET_REPORT);
1509	kfree(buf);
1510}
1511
1512static int hidinput_input_event(struct input_dev *dev, unsigned int type,
1513				unsigned int code, int value)
1514{
1515	struct hid_device *hid = input_get_drvdata(dev);
1516	struct hid_field *field;
1517	int offset;
1518
1519	if (type == EV_FF)
1520		return input_ff_event(dev, type, code, value);
1521
1522	if (type != EV_LED)
1523		return -1;
1524
1525	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
1526		hid_warn(dev, "event field not found\n");
1527		return -1;
1528	}
1529
1530	hid_set_field(field, offset, value);
1531
1532	schedule_work(&hid->led_work);
1533	return 0;
1534}
1535
1536static int hidinput_open(struct input_dev *dev)
1537{
1538	struct hid_device *hid = input_get_drvdata(dev);
1539
1540	return hid_hw_open(hid);
1541}
1542
1543static void hidinput_close(struct input_dev *dev)
1544{
1545	struct hid_device *hid = input_get_drvdata(dev);
1546
1547	hid_hw_close(hid);
1548}
1549
1550static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
1551		struct hid_report *report, bool use_logical_max)
1552{
1553	struct hid_usage *usage;
1554	bool update_needed = false;
1555	int i, j;
1556
1557	if (report->maxfield == 0)
1558		return false;
1559
1560	/*
1561	 * If we have more than one feature within this report we
1562	 * need to fill in the bits from the others before we can
1563	 * overwrite the ones for the Resolution Multiplier.
1564	 */
1565	if (report->maxfield > 1) {
1566		hid_hw_request(hid, report, HID_REQ_GET_REPORT);
1567		hid_hw_wait(hid);
1568	}
1569
1570	for (i = 0; i < report->maxfield; i++) {
1571		__s32 value = use_logical_max ?
1572			      report->field[i]->logical_maximum :
1573			      report->field[i]->logical_minimum;
1574
1575		/* There is no good reason for a Resolution
1576		 * Multiplier to have a count other than 1.
1577		 * Ignore that case.
1578		 */
1579		if (report->field[i]->report_count != 1)
1580			continue;
1581
1582		for (j = 0; j < report->field[i]->maxusage; j++) {
1583			usage = &report->field[i]->usage[j];
1584
1585			if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
1586				continue;
1587
1588			report->field[i]->value[j] = value;
1589			update_needed = true;
1590		}
1591	}
1592
1593	return update_needed;
1594}
1595
1596static void hidinput_change_resolution_multipliers(struct hid_device *hid)
1597{
1598	struct hid_report_enum *rep_enum;
1599	struct hid_report *rep;
1600	int ret;
1601
1602	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1603	list_for_each_entry(rep, &rep_enum->report_list, list) {
1604		bool update_needed = __hidinput_change_resolution_multipliers(hid,
1605								     rep, true);
1606
1607		if (update_needed) {
1608			ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
1609			if (ret) {
1610				__hidinput_change_resolution_multipliers(hid,
1611								    rep, false);
1612				return;
1613			}
1614		}
1615	}
1616
1617	/* refresh our structs */
1618	hid_setup_resolution_multiplier(hid);
1619}
1620
1621static void report_features(struct hid_device *hid)
1622{
1623	struct hid_driver *drv = hid->driver;
1624	struct hid_report_enum *rep_enum;
1625	struct hid_report *rep;
1626	struct hid_usage *usage;
1627	int i, j;
1628
1629	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1630	list_for_each_entry(rep, &rep_enum->report_list, list)
1631		for (i = 0; i < rep->maxfield; i++) {
1632			/* Ignore if report count is out of bounds. */
1633			if (rep->field[i]->report_count < 1)
1634				continue;
1635
1636			for (j = 0; j < rep->field[i]->maxusage; j++) {
1637				usage = &rep->field[i]->usage[j];
1638
1639				/* Verify if Battery Strength feature is available */
1640				if (usage->hid == HID_DC_BATTERYSTRENGTH)
1641					hidinput_setup_battery(hid, HID_FEATURE_REPORT,
1642							       rep->field[i]);
1643
1644				if (drv->feature_mapping)
1645					drv->feature_mapping(hid, rep->field[i], usage);
 
1646			}
1647		}
1648}
1649
1650static struct hid_input *hidinput_allocate(struct hid_device *hid,
1651					   unsigned int application)
1652{
1653	struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
1654	struct input_dev *input_dev = input_allocate_device();
1655	const char *suffix = NULL;
1656	size_t suffix_len, name_len;
1657
1658	if (!hidinput || !input_dev)
1659		goto fail;
1660
1661	if ((hid->quirks & HID_QUIRK_INPUT_PER_APP) &&
1662	    hid->maxapplication > 1) {
1663		switch (application) {
1664		case HID_GD_KEYBOARD:
1665			suffix = "Keyboard";
1666			break;
1667		case HID_GD_KEYPAD:
1668			suffix = "Keypad";
1669			break;
1670		case HID_GD_MOUSE:
1671			suffix = "Mouse";
1672			break;
1673		case HID_DG_STYLUS:
1674			suffix = "Pen";
1675			break;
1676		case HID_DG_TOUCHSCREEN:
1677			suffix = "Touchscreen";
1678			break;
1679		case HID_DG_TOUCHPAD:
1680			suffix = "Touchpad";
1681			break;
1682		case HID_GD_SYSTEM_CONTROL:
1683			suffix = "System Control";
1684			break;
1685		case HID_CP_CONSUMER_CONTROL:
1686			suffix = "Consumer Control";
1687			break;
1688		case HID_GD_WIRELESS_RADIO_CTLS:
1689			suffix = "Wireless Radio Control";
1690			break;
1691		case HID_GD_SYSTEM_MULTIAXIS:
1692			suffix = "System Multi Axis";
1693			break;
1694		default:
1695			break;
1696		}
1697	}
1698
1699	if (suffix) {
1700		name_len = strlen(hid->name);
1701		suffix_len = strlen(suffix);
1702		if ((name_len < suffix_len) ||
1703		    strcmp(hid->name + name_len - suffix_len, suffix)) {
1704			hidinput->name = kasprintf(GFP_KERNEL, "%s %s",
1705						   hid->name, suffix);
1706			if (!hidinput->name)
1707				goto fail;
1708		}
1709	}
1710
1711	input_set_drvdata(input_dev, hid);
1712	input_dev->event = hidinput_input_event;
1713	input_dev->open = hidinput_open;
1714	input_dev->close = hidinput_close;
1715	input_dev->setkeycode = hidinput_setkeycode;
1716	input_dev->getkeycode = hidinput_getkeycode;
1717
1718	input_dev->name = hidinput->name ? hidinput->name : hid->name;
1719	input_dev->phys = hid->phys;
1720	input_dev->uniq = hid->uniq;
1721	input_dev->id.bustype = hid->bus;
1722	input_dev->id.vendor  = hid->vendor;
1723	input_dev->id.product = hid->product;
1724	input_dev->id.version = hid->version;
1725	input_dev->dev.parent = &hid->dev;
1726
1727	hidinput->input = input_dev;
1728	hidinput->application = application;
1729	list_add_tail(&hidinput->list, &hid->inputs);
1730
1731	INIT_LIST_HEAD(&hidinput->reports);
1732
1733	return hidinput;
1734
1735fail:
1736	kfree(hidinput);
1737	input_free_device(input_dev);
1738	hid_err(hid, "Out of memory during hid input probe\n");
1739	return NULL;
1740}
1741
1742static bool hidinput_has_been_populated(struct hid_input *hidinput)
1743{
1744	int i;
1745	unsigned long r = 0;
1746
1747	for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
1748		r |= hidinput->input->evbit[i];
1749
1750	for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
1751		r |= hidinput->input->keybit[i];
1752
1753	for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
1754		r |= hidinput->input->relbit[i];
1755
1756	for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
1757		r |= hidinput->input->absbit[i];
1758
1759	for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
1760		r |= hidinput->input->mscbit[i];
1761
1762	for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
1763		r |= hidinput->input->ledbit[i];
1764
1765	for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
1766		r |= hidinput->input->sndbit[i];
1767
1768	for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
1769		r |= hidinput->input->ffbit[i];
1770
1771	for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
1772		r |= hidinput->input->swbit[i];
1773
1774	return !!r;
1775}
1776
1777static void hidinput_cleanup_hidinput(struct hid_device *hid,
1778		struct hid_input *hidinput)
1779{
1780	struct hid_report *report;
1781	int i, k;
1782
1783	list_del(&hidinput->list);
1784	input_free_device(hidinput->input);
1785	kfree(hidinput->name);
1786
1787	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
1788		if (k == HID_OUTPUT_REPORT &&
1789			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
1790			continue;
1791
1792		list_for_each_entry(report, &hid->report_enum[k].report_list,
1793				    list) {
1794
1795			for (i = 0; i < report->maxfield; i++)
1796				if (report->field[i]->hidinput == hidinput)
1797					report->field[i]->hidinput = NULL;
1798		}
1799	}
1800
1801	kfree(hidinput);
1802}
1803
1804static struct hid_input *hidinput_match(struct hid_report *report)
1805{
1806	struct hid_device *hid = report->device;
1807	struct hid_input *hidinput;
1808
1809	list_for_each_entry(hidinput, &hid->inputs, list) {
1810		if (hidinput->report &&
1811		    hidinput->report->id == report->id)
1812			return hidinput;
1813	}
1814
1815	return NULL;
1816}
1817
1818static struct hid_input *hidinput_match_application(struct hid_report *report)
1819{
1820	struct hid_device *hid = report->device;
1821	struct hid_input *hidinput;
1822
1823	list_for_each_entry(hidinput, &hid->inputs, list) {
1824		if (hidinput->application == report->application)
1825			return hidinput;
1826	}
1827
1828	return NULL;
1829}
1830
1831static inline void hidinput_configure_usages(struct hid_input *hidinput,
1832					     struct hid_report *report)
1833{
1834	int i, j;
1835
1836	for (i = 0; i < report->maxfield; i++)
1837		for (j = 0; j < report->field[i]->maxusage; j++)
1838			hidinput_configure_usage(hidinput, report->field[i],
1839						 report->field[i]->usage + j);
1840}
1841
1842/*
1843 * Register the input device; print a message.
1844 * Configure the input layer interface
1845 * Read all reports and initialize the absolute field values.
1846 */
1847
1848int hidinput_connect(struct hid_device *hid, unsigned int force)
1849{
1850	struct hid_driver *drv = hid->driver;
1851	struct hid_report *report;
1852	struct hid_input *next, *hidinput = NULL;
1853	unsigned int application;
1854	int i, k;
1855
1856	INIT_LIST_HEAD(&hid->inputs);
1857	INIT_WORK(&hid->led_work, hidinput_led_worker);
1858
1859	hid->status &= ~HID_STAT_DUP_DETECTED;
1860
1861	if (!force) {
1862		for (i = 0; i < hid->maxcollection; i++) {
1863			struct hid_collection *col = &hid->collection[i];
1864			if (col->type == HID_COLLECTION_APPLICATION ||
1865					col->type == HID_COLLECTION_PHYSICAL)
1866				if (IS_INPUT_APPLICATION(col->usage))
1867					break;
1868		}
1869
1870		if (i == hid->maxcollection)
1871			return -1;
1872	}
1873
1874	report_features(hid);
1875
1876	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
1877		if (k == HID_OUTPUT_REPORT &&
1878			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
1879			continue;
1880
1881		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
1882
1883			if (!report->maxfield)
1884				continue;
1885
1886			application = report->application;
1887
1888			/*
1889			 * Find the previous hidinput report attached
1890			 * to this report id.
1891			 */
1892			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
1893				hidinput = hidinput_match(report);
1894			else if (hid->maxapplication > 1 &&
1895				 (hid->quirks & HID_QUIRK_INPUT_PER_APP))
1896				hidinput = hidinput_match_application(report);
1897
1898			if (!hidinput) {
1899				hidinput = hidinput_allocate(hid, application);
1900				if (!hidinput)
 
 
 
 
1901					goto out_unwind;
1902			}
1903
1904			hidinput_configure_usages(hidinput, report);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1905
1906			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
 
 
 
 
 
 
 
 
 
 
1907				hidinput->report = report;
1908
1909			list_add_tail(&report->hidinput_list,
1910				      &hidinput->reports);
 
1911		}
1912	}
1913
1914	hidinput_change_resolution_multipliers(hid);
1915
1916	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
1917		if (drv->input_configured &&
1918		    drv->input_configured(hid, hidinput))
1919			goto out_unwind;
1920
1921		if (!hidinput_has_been_populated(hidinput)) {
1922			/* no need to register an input device not populated */
1923			hidinput_cleanup_hidinput(hid, hidinput);
1924			continue;
1925		}
1926
1927		if (input_register_device(hidinput->input))
1928			goto out_unwind;
1929		hidinput->registered = true;
1930	}
1931
1932	if (list_empty(&hid->inputs)) {
1933		hid_err(hid, "No inputs registered, leaving\n");
1934		goto out_unwind;
1935	}
1936
1937	if (hid->status & HID_STAT_DUP_DETECTED)
1938		hid_dbg(hid,
1939			"Some usages could not be mapped, please use HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE if this is legitimate.\n");
1940
1941	return 0;
1942
 
 
 
 
1943out_unwind:
1944	/* unwind the ones we already registered */
1945	hidinput_disconnect(hid);
1946
1947	return -1;
1948}
1949EXPORT_SYMBOL_GPL(hidinput_connect);
1950
1951void hidinput_disconnect(struct hid_device *hid)
1952{
1953	struct hid_input *hidinput, *next;
1954
1955	hidinput_cleanup_battery(hid);
1956
1957	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
1958		list_del(&hidinput->list);
1959		if (hidinput->registered)
1960			input_unregister_device(hidinput->input);
1961		else
1962			input_free_device(hidinput->input);
1963		kfree(hidinput->name);
1964		kfree(hidinput);
1965	}
1966
1967	/* led_work is spawned by input_dev callbacks, but doesn't access the
1968	 * parent input_dev at all. Once all input devices are removed, we
1969	 * know that led_work will never get restarted, so we can cancel it
1970	 * synchronously and are safe. */
1971	cancel_work_sync(&hid->led_work);
1972}
1973EXPORT_SYMBOL_GPL(hidinput_disconnect);