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