Lines Matching +full:value +full:- +full:start
1 // SPDX-License-Identifier: GPL-2.0-or-later
6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8 * Copyright (c) 2006-2012 Jiri Kosina
33 #include <linux/hid-debug.h>
36 #include "hid-ids.h"
56 struct hid_report_enum *report_enum = device->report_enum + type; in hid_register_report()
61 if (report_enum->report_id_hash[id]) in hid_register_report()
62 return report_enum->report_id_hash[id]; in hid_register_report()
69 report_enum->numbered = 1; in hid_register_report()
71 report->id = id; in hid_register_report()
72 report->type = type; in hid_register_report()
73 report->size = 0; in hid_register_report()
74 report->device = device; in hid_register_report()
75 report->application = application; in hid_register_report()
76 report_enum->report_id_hash[id] = report; in hid_register_report()
78 list_add_tail(&report->list, &report_enum->report_list); in hid_register_report()
79 INIT_LIST_HEAD(&report->field_entry_list); in hid_register_report()
93 if (report->maxfield == HID_MAX_FIELDS) { in hid_register_field()
94 hid_err(report->device, "too many fields in report\n"); in hid_register_field()
104 field->index = report->maxfield++; in hid_register_field()
105 report->field[field->index] = field; in hid_register_field()
106 field->usage = (struct hid_usage *)(field + 1); in hid_register_field()
107 field->value = (s32 *)(field->usage + usages); in hid_register_field()
108 field->new_value = (s32 *)(field->value + usages); in hid_register_field()
109 field->usages_priorities = (s32 *)(field->new_value + usages); in hid_register_field()
110 field->report = report; in hid_register_field()
125 usage = parser->local.usage[0]; in open_collection()
127 if (parser->collection_stack_ptr == parser->collection_stack_size) { in open_collection()
129 unsigned int new_size = parser->collection_stack_size + in open_collection()
132 collection_stack = krealloc(parser->collection_stack, in open_collection()
136 return -ENOMEM; in open_collection()
138 parser->collection_stack = collection_stack; in open_collection()
139 parser->collection_stack_size = new_size; in open_collection()
142 if (parser->device->maxcollection == parser->device->collection_size) { in open_collection()
145 parser->device->collection_size, in open_collection()
149 hid_err(parser->device, "failed to reallocate collection array\n"); in open_collection()
150 return -ENOMEM; in open_collection()
152 memcpy(collection, parser->device->collection, in open_collection()
154 parser->device->collection_size); in open_collection()
155 memset(collection + parser->device->collection_size, 0, in open_collection()
157 parser->device->collection_size); in open_collection()
158 kfree(parser->device->collection); in open_collection()
159 parser->device->collection = collection; in open_collection()
160 parser->device->collection_size *= 2; in open_collection()
163 parser->collection_stack[parser->collection_stack_ptr++] = in open_collection()
164 parser->device->maxcollection; in open_collection()
166 collection_index = parser->device->maxcollection++; in open_collection()
167 collection = parser->device->collection + collection_index; in open_collection()
168 collection->type = type; in open_collection()
169 collection->usage = usage; in open_collection()
170 collection->level = parser->collection_stack_ptr - 1; in open_collection()
171 collection->parent_idx = (collection->level == 0) ? -1 : in open_collection()
172 parser->collection_stack[collection->level - 1]; in open_collection()
175 parser->device->maxapplication++; in open_collection()
186 if (!parser->collection_stack_ptr) { in close_collection()
187 hid_err(parser->device, "collection stack underflow\n"); in close_collection()
188 return -EINVAL; in close_collection()
190 parser->collection_stack_ptr--; in close_collection()
201 struct hid_collection *collection = parser->device->collection; in hid_lookup_collection()
204 for (n = parser->collection_stack_ptr - 1; n >= 0; n--) { in hid_lookup_collection()
205 unsigned index = parser->collection_stack[n]; in hid_lookup_collection()
219 parser->local.usage[index] &= 0xFFFF; in complete_usage()
220 parser->local.usage[index] |= in complete_usage()
221 (parser->global.usage_page & 0xFFFF) << 16; in complete_usage()
230 if (parser->local.usage_index >= HID_MAX_USAGES) { in hid_add_usage()
231 hid_err(parser->device, "usage index exceeded\n"); in hid_add_usage()
232 return -1; in hid_add_usage()
234 parser->local.usage[parser->local.usage_index] = usage; in hid_add_usage()
241 complete_usage(parser, parser->local.usage_index); in hid_add_usage()
243 parser->local.usage_size[parser->local.usage_index] = size; in hid_add_usage()
244 parser->local.collection_index[parser->local.usage_index] = in hid_add_usage()
245 parser->collection_stack_ptr ? in hid_add_usage()
246 parser->collection_stack[parser->collection_stack_ptr - 1] : 0; in hid_add_usage()
247 parser->local.usage_index++; in hid_add_usage()
267 report = hid_register_report(parser->device, report_type, in hid_add_field()
268 parser->global.report_id, application); in hid_add_field()
270 hid_err(parser->device, "hid_register_report failed\n"); in hid_add_field()
271 return -1; in hid_add_field()
275 if ((parser->global.logical_minimum < 0 && in hid_add_field()
276 parser->global.logical_maximum < in hid_add_field()
277 parser->global.logical_minimum) || in hid_add_field()
278 (parser->global.logical_minimum >= 0 && in hid_add_field()
279 (__u32)parser->global.logical_maximum < in hid_add_field()
280 (__u32)parser->global.logical_minimum)) { in hid_add_field()
282 parser->global.logical_minimum, in hid_add_field()
283 parser->global.logical_maximum); in hid_add_field()
284 return -1; in hid_add_field()
287 offset = report->size; in hid_add_field()
288 report->size += parser->global.report_size * parser->global.report_count; in hid_add_field()
290 if (parser->device->ll_driver->max_buffer_size) in hid_add_field()
291 max_buffer_size = parser->device->ll_driver->max_buffer_size; in hid_add_field()
294 if (report->size > (max_buffer_size - 1) << 3) { in hid_add_field()
295 hid_err(parser->device, "report is too long\n"); in hid_add_field()
296 return -1; in hid_add_field()
299 if (!parser->local.usage_index) /* Ignore padding fields */ in hid_add_field()
302 usages = max_t(unsigned, parser->local.usage_index, in hid_add_field()
303 parser->global.report_count); in hid_add_field()
309 field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL); in hid_add_field()
310 field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL); in hid_add_field()
311 field->application = application; in hid_add_field()
316 if (i >= parser->local.usage_index) in hid_add_field()
317 j = parser->local.usage_index - 1; in hid_add_field()
318 field->usage[i].hid = parser->local.usage[j]; in hid_add_field()
319 field->usage[i].collection_index = in hid_add_field()
320 parser->local.collection_index[j]; in hid_add_field()
321 field->usage[i].usage_index = i; in hid_add_field()
322 field->usage[i].resolution_multiplier = 1; in hid_add_field()
325 field->maxusage = usages; in hid_add_field()
326 field->flags = flags; in hid_add_field()
327 field->report_offset = offset; in hid_add_field()
328 field->report_type = report_type; in hid_add_field()
329 field->report_size = parser->global.report_size; in hid_add_field()
330 field->report_count = parser->global.report_count; in hid_add_field()
331 field->logical_minimum = parser->global.logical_minimum; in hid_add_field()
332 field->logical_maximum = parser->global.logical_maximum; in hid_add_field()
333 field->physical_minimum = parser->global.physical_minimum; in hid_add_field()
334 field->physical_maximum = parser->global.physical_maximum; in hid_add_field()
335 field->unit_exponent = parser->global.unit_exponent; in hid_add_field()
336 field->unit = parser->global.unit; in hid_add_field()
342 * Read data value from item.
347 switch (item->size) { in item_udata()
348 case 1: return item->data.u8; in item_udata()
349 case 2: return item->data.u16; in item_udata()
350 case 4: return item->data.u32; in item_udata()
357 switch (item->size) { in item_sdata()
358 case 1: return item->data.s8; in item_sdata()
359 case 2: return item->data.s16; in item_sdata()
360 case 4: return item->data.s32; in item_sdata()
372 switch (item->tag) { in hid_parser_global()
375 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) { in hid_parser_global()
376 hid_err(parser->device, "global environment stack overflow\n"); in hid_parser_global()
377 return -1; in hid_parser_global()
380 memcpy(parser->global_stack + parser->global_stack_ptr++, in hid_parser_global()
381 &parser->global, sizeof(struct hid_global)); in hid_parser_global()
386 if (!parser->global_stack_ptr) { in hid_parser_global()
387 hid_err(parser->device, "global environment stack underflow\n"); in hid_parser_global()
388 return -1; in hid_parser_global()
391 memcpy(&parser->global, parser->global_stack + in hid_parser_global()
392 --parser->global_stack_ptr, sizeof(struct hid_global)); in hid_parser_global()
396 parser->global.usage_page = item_udata(item); in hid_parser_global()
400 parser->global.logical_minimum = item_sdata(item); in hid_parser_global()
404 if (parser->global.logical_minimum < 0) in hid_parser_global()
405 parser->global.logical_maximum = item_sdata(item); in hid_parser_global()
407 parser->global.logical_maximum = item_udata(item); in hid_parser_global()
411 parser->global.physical_minimum = item_sdata(item); in hid_parser_global()
415 if (parser->global.physical_minimum < 0) in hid_parser_global()
416 parser->global.physical_maximum = item_sdata(item); in hid_parser_global()
418 parser->global.physical_maximum = item_udata(item); in hid_parser_global()
428 parser->global.unit_exponent = hid_snto32(raw_value, 4); in hid_parser_global()
430 parser->global.unit_exponent = raw_value; in hid_parser_global()
434 parser->global.unit = item_udata(item); in hid_parser_global()
438 parser->global.report_size = item_udata(item); in hid_parser_global()
439 if (parser->global.report_size > 256) { in hid_parser_global()
440 hid_err(parser->device, "invalid report_size %d\n", in hid_parser_global()
441 parser->global.report_size); in hid_parser_global()
442 return -1; in hid_parser_global()
447 parser->global.report_count = item_udata(item); in hid_parser_global()
448 if (parser->global.report_count > HID_MAX_USAGES) { in hid_parser_global()
449 hid_err(parser->device, "invalid report_count %d\n", in hid_parser_global()
450 parser->global.report_count); in hid_parser_global()
451 return -1; in hid_parser_global()
456 parser->global.report_id = item_udata(item); in hid_parser_global()
457 if (parser->global.report_id == 0 || in hid_parser_global()
458 parser->global.report_id >= HID_MAX_IDS) { in hid_parser_global()
459 hid_err(parser->device, "report_id %u is invalid\n", in hid_parser_global()
460 parser->global.report_id); in hid_parser_global()
461 return -1; in hid_parser_global()
466 hid_err(parser->device, "unknown global tag 0x%x\n", item->tag); in hid_parser_global()
467 return -1; in hid_parser_global()
483 switch (item->tag) { in hid_parser_local()
493 if (parser->local.delimiter_depth != 0) { in hid_parser_local()
494 hid_err(parser->device, "nested delimiters\n"); in hid_parser_local()
495 return -1; in hid_parser_local()
497 parser->local.delimiter_depth++; in hid_parser_local()
498 parser->local.delimiter_branch++; in hid_parser_local()
500 if (parser->local.delimiter_depth < 1) { in hid_parser_local()
501 hid_err(parser->device, "bogus close delimiter\n"); in hid_parser_local()
502 return -1; in hid_parser_local()
504 parser->local.delimiter_depth--; in hid_parser_local()
510 if (parser->local.delimiter_branch > 1) { in hid_parser_local()
515 return hid_add_usage(parser, data, item->size); in hid_parser_local()
519 if (parser->local.delimiter_branch > 1) { in hid_parser_local()
524 parser->local.usage_minimum = data; in hid_parser_local()
529 if (parser->local.delimiter_branch > 1) { in hid_parser_local()
534 count = data - parser->local.usage_minimum; in hid_parser_local()
535 if (count + parser->local.usage_index >= HID_MAX_USAGES) { in hid_parser_local()
538 * actually pre-scanning the device. in hid_parser_local()
540 if (dev_name(&parser->device->dev)) in hid_parser_local()
541 hid_warn(parser->device, in hid_parser_local()
543 data = HID_MAX_USAGES - parser->local.usage_index + in hid_parser_local()
544 parser->local.usage_minimum - 1; in hid_parser_local()
546 hid_err(parser->device, in hid_parser_local()
548 return -1; in hid_parser_local()
552 for (n = parser->local.usage_minimum; n <= data; n++) in hid_parser_local()
553 if (hid_add_usage(parser, n, item->size)) { in hid_parser_local()
555 return -1; in hid_parser_local()
561 dbg_hid("unknown local item tag 0x%x\n", item->tag); in hid_parser_local()
571 * usage value."
580 if (!parser->local.usage_index) in hid_concatenate_last_usage_page()
583 usage_page = parser->global.usage_page; in hid_concatenate_last_usage_page()
589 for (i = parser->local.usage_index - 1; i >= 0; i--) { in hid_concatenate_last_usage_page()
590 if (parser->local.usage_size[i] > 2) in hid_concatenate_last_usage_page()
594 current_page = parser->local.usage[i] >> 16; in hid_concatenate_last_usage_page()
615 switch (item->tag) { in hid_parser_main()
632 hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag); in hid_parser_main()
636 memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */ in hid_parser_main()
647 dbg_hid("reserved item type, tag 0x%x\n", item->tag); in hid_parser_reserved()
652 * Free a report and all registered fields. The field->usage and
653 * field->value table's are allocated behind the field, so we need
661 kfree(report->field_entries); in hid_free_report()
663 for (n = 0; n < report->maxfield; n++) in hid_free_report()
664 kfree(report->field[n]); in hid_free_report()
677 struct hid_report_enum *report_enum = device->report_enum + i; in hid_close_report()
680 struct hid_report *report = report_enum->report_id_hash[j]; in hid_close_report()
685 INIT_LIST_HEAD(&report_enum->report_list); in hid_close_report()
688 kfree(device->rdesc); in hid_close_report()
689 device->rdesc = NULL; in hid_close_report()
690 device->rsize = 0; in hid_close_report()
692 kfree(device->collection); in hid_close_report()
693 device->collection = NULL; in hid_close_report()
694 device->collection_size = 0; in hid_close_report()
695 device->maxcollection = 0; in hid_close_report()
696 device->maxapplication = 0; in hid_close_report()
698 device->status &= ~HID_STAT_PARSED; in hid_close_report()
710 kfree(hid->dev_rdesc); in hiddev_free()
718 kref_put(&hid->ref, hiddev_free); in hid_device_release()
726 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item) in fetch_item() argument
730 if ((end - start) <= 0) in fetch_item()
733 b = *start++; in fetch_item()
735 item->type = (b >> 2) & 3; in fetch_item()
736 item->tag = (b >> 4) & 15; in fetch_item()
738 if (item->tag == HID_ITEM_TAG_LONG) { in fetch_item()
740 item->format = HID_ITEM_FORMAT_LONG; in fetch_item()
742 if ((end - start) < 2) in fetch_item()
745 item->size = *start++; in fetch_item()
746 item->tag = *start++; in fetch_item()
748 if ((end - start) < item->size) in fetch_item()
751 item->data.longdata = start; in fetch_item()
752 start += item->size; in fetch_item()
753 return start; in fetch_item()
756 item->format = HID_ITEM_FORMAT_SHORT; in fetch_item()
757 item->size = b & 3; in fetch_item()
759 switch (item->size) { in fetch_item()
761 return start; in fetch_item()
764 if ((end - start) < 1) in fetch_item()
766 item->data.u8 = *start++; in fetch_item()
767 return start; in fetch_item()
770 if ((end - start) < 2) in fetch_item()
772 item->data.u16 = get_unaligned_le16(start); in fetch_item()
773 start = (__u8 *)((__le16 *)start + 1); in fetch_item()
774 return start; in fetch_item()
777 item->size++; in fetch_item()
778 if ((end - start) < 4) in fetch_item()
780 item->data.u32 = get_unaligned_le32(start); in fetch_item()
781 start = (__u8 *)((__le32 *)start + 1); in fetch_item()
782 return start; in fetch_item()
790 struct hid_device *hid = parser->device; in hid_scan_input_usage()
793 hid->group = HID_GROUP_MULTITOUCH; in hid_scan_input_usage()
798 if (usage == 0xff0000c5 && parser->global.report_count == 256 && in hid_scan_feature_usage()
799 parser->global.report_size == 8) in hid_scan_feature_usage()
800 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; in hid_scan_feature_usage()
802 if (usage == 0xff0000c6 && parser->global.report_count == 1 && in hid_scan_feature_usage()
803 parser->global.report_size == 8) in hid_scan_feature_usage()
804 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; in hid_scan_feature_usage()
809 struct hid_device *hid = parser->device; in hid_scan_collection()
812 if (((parser->global.usage_page << 16) == HID_UP_SENSOR) && in hid_scan_collection()
815 hid->group = HID_GROUP_SENSOR_HUB; in hid_scan_collection()
817 if (hid->vendor == USB_VENDOR_ID_MICROSOFT && in hid_scan_collection()
818 hid->product == USB_DEVICE_ID_MS_POWER_COVER && in hid_scan_collection()
819 hid->group == HID_GROUP_MULTITOUCH) in hid_scan_collection()
820 hid->group = HID_GROUP_GENERIC; in hid_scan_collection()
822 if ((parser->global.usage_page << 16) == HID_UP_GENDESK) in hid_scan_collection()
823 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_collection()
824 if (parser->local.usage[i] == HID_GD_POINTER) in hid_scan_collection()
825 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER; in hid_scan_collection()
827 if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR) in hid_scan_collection()
828 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC; in hid_scan_collection()
830 if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR) in hid_scan_collection()
831 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_collection()
832 if (parser->local.usage[i] == in hid_scan_collection()
834 parser->device->group = in hid_scan_collection()
847 switch (item->tag) { in hid_scan_main()
854 /* ignore constant inputs, they will be ignored by hid-input */ in hid_scan_main()
857 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_main()
858 hid_scan_input_usage(parser, parser->local.usage[i]); in hid_scan_main()
863 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_main()
864 hid_scan_feature_usage(parser, parser->local.usage[i]); in hid_scan_main()
869 memset(&parser->local, 0, sizeof(parser->local)); in hid_scan_main()
883 __u8 *start = hid->dev_rdesc; in hid_scan_report() local
884 __u8 *end = start + hid->dev_rsize; in hid_scan_report()
895 return -ENOMEM; in hid_scan_report()
897 parser->device = hid; in hid_scan_report()
898 hid->group = HID_GROUP_GENERIC; in hid_scan_report()
905 while ((start = fetch_item(start, end, &item)) != NULL) in hid_scan_report()
911 if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) && in hid_scan_report()
912 (hid->group == HID_GROUP_MULTITOUCH)) in hid_scan_report()
913 hid->group = HID_GROUP_MULTITOUCH_WIN_8; in hid_scan_report()
918 switch (hid->vendor) { in hid_scan_report()
920 hid->group = HID_GROUP_WACOM; in hid_scan_report()
923 if (hid->group == HID_GROUP_GENERIC) in hid_scan_report()
924 if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC) in hid_scan_report()
925 && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER)) in hid_scan_report()
927 * hid-rmi should take care of them, in hid_scan_report()
928 * not hid-generic in hid_scan_report()
930 hid->group = HID_GROUP_RMI; in hid_scan_report()
934 kfree(parser->collection_stack); in hid_scan_report()
940 * hid_parse_report - parse device report
943 * @start: report start
949 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size) in hid_parse_report() argument
951 hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL); in hid_parse_report()
952 if (!hid->dev_rdesc) in hid_parse_report()
953 return -ENOMEM; in hid_parse_report()
954 hid->dev_rsize = size; in hid_parse_report()
965 * hid_validate_values - validate existing device report's value indexes
995 * ->numbered being checked, which may not always be the case when in hid_validate_values()
1004 &hid->report_enum[type].report_list, in hid_validate_values()
1007 report = hid->report_enum[type].report_id_hash[id]; in hid_validate_values()
1013 if (report->maxfield <= field_index) { in hid_validate_values()
1018 if (report->field[field_index]->report_count < report_counts) { in hid_validate_values()
1031 __s32 v = *multiplier->value; in hid_calculate_multiplier()
1032 __s32 lmin = multiplier->logical_minimum; in hid_calculate_multiplier()
1033 __s32 lmax = multiplier->logical_maximum; in hid_calculate_multiplier()
1034 __s32 pmin = multiplier->physical_minimum; in hid_calculate_multiplier()
1035 __s32 pmax = multiplier->physical_maximum; in hid_calculate_multiplier()
1044 if (lmax - lmin == 0) in hid_calculate_multiplier()
1050 m = ((v - lmin)/(lmax - lmin) * (pmax - pmin) + pmin); in hid_calculate_multiplier()
1051 if (unlikely(multiplier->unit_exponent != 0)) { in hid_calculate_multiplier()
1054 multiplier->unit_exponent); in hid_calculate_multiplier()
1058 if (unlikely(m == 0 || m > 255 || m < -255)) { in hid_calculate_multiplier()
1081 for (i = 0; i < field->maxusage; i++) { in hid_apply_multiplier_to_field()
1082 usage = &field->usage[i]; in hid_apply_multiplier_to_field()
1084 collection = &hid->collection[usage->collection_index]; in hid_apply_multiplier_to_field()
1085 while (collection->parent_idx != -1 && in hid_apply_multiplier_to_field()
1087 collection = &hid->collection[collection->parent_idx]; in hid_apply_multiplier_to_field()
1089 if (collection->parent_idx != -1 || in hid_apply_multiplier_to_field()
1091 usage->resolution_multiplier = effective_multiplier; in hid_apply_multiplier_to_field()
1124 multiplier_collection = &hid->collection[multiplier->usage->collection_index]; in hid_apply_multiplier()
1125 while (multiplier_collection->parent_idx != -1 && in hid_apply_multiplier()
1126 multiplier_collection->type != HID_COLLECTION_LOGICAL) in hid_apply_multiplier()
1127 multiplier_collection = &hid->collection[multiplier_collection->parent_idx]; in hid_apply_multiplier()
1131 rep_enum = &hid->report_enum[HID_INPUT_REPORT]; in hid_apply_multiplier()
1132 list_for_each_entry(rep, &rep_enum->report_list, list) { in hid_apply_multiplier()
1133 for (i = 0; i < rep->maxfield; i++) { in hid_apply_multiplier()
1134 field = rep->field[i]; in hid_apply_multiplier()
1143 * hid_setup_resolution_multiplier - set up all resolution multipliers
1148 * value to all matching Input items. This only updates the internal struct
1152 * is anything other than 1, the hardware will send pre-multiplied events
1154 * accumulated_value = value * * multiplier
1156 * - "value * multiplier" for each event, or
1157 * - "value" but "multiplier" times as frequently, or
1158 * - a combination of the above
1160 * an accumulated 'value * multiplier'.
1172 rep_enum = &hid->report_enum[HID_FEATURE_REPORT]; in hid_setup_resolution_multiplier()
1173 list_for_each_entry(rep, &rep_enum->report_list, list) { in hid_setup_resolution_multiplier()
1174 for (i = 0; i < rep->maxfield; i++) { in hid_setup_resolution_multiplier()
1176 if (rep->field[i]->report_count < 1) in hid_setup_resolution_multiplier()
1179 for (j = 0; j < rep->field[i]->maxusage; j++) { in hid_setup_resolution_multiplier()
1180 usage = &rep->field[i]->usage[j]; in hid_setup_resolution_multiplier()
1181 if (usage->hid == HID_GD_RESOLUTION_MULTIPLIER) in hid_setup_resolution_multiplier()
1183 rep->field[i]); in hid_setup_resolution_multiplier()
1191 * hid_open_report - open a driver-specific device report
1197 * 0 returned on success, otherwise nonzero error value.
1207 __u8 *start; in hid_open_report() local
1221 if (WARN_ON(device->status & HID_STAT_PARSED)) in hid_open_report()
1222 return -EBUSY; in hid_open_report()
1224 start = device->dev_rdesc; in hid_open_report()
1225 if (WARN_ON(!start)) in hid_open_report()
1226 return -ENODEV; in hid_open_report()
1227 size = device->dev_rsize; in hid_open_report()
1230 buf = call_hid_bpf_rdesc_fixup(device, start, &size); in hid_open_report()
1232 return -ENOMEM; in hid_open_report()
1234 if (device->driver->report_fixup) in hid_open_report()
1235 start = device->driver->report_fixup(device, buf, &size); in hid_open_report()
1237 start = buf; in hid_open_report()
1239 start = kmemdup(start, size, GFP_KERNEL); in hid_open_report()
1241 if (start == NULL) in hid_open_report()
1242 return -ENOMEM; in hid_open_report()
1244 device->rdesc = start; in hid_open_report()
1245 device->rsize = size; in hid_open_report()
1249 ret = -ENOMEM; in hid_open_report()
1253 parser->device = device; in hid_open_report()
1255 end = start + size; in hid_open_report()
1257 device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS, in hid_open_report()
1259 if (!device->collection) { in hid_open_report()
1260 ret = -ENOMEM; in hid_open_report()
1263 device->collection_size = HID_DEFAULT_NUM_COLLECTIONS; in hid_open_report()
1265 device->collection[i].parent_idx = -1; in hid_open_report()
1267 ret = -EINVAL; in hid_open_report()
1268 while ((next = fetch_item(start, end, &item)) != NULL) { in hid_open_report()
1269 start = next; in hid_open_report()
1283 if (start == end) { in hid_open_report()
1284 if (parser->collection_stack_ptr) { in hid_open_report()
1288 if (parser->local.delimiter_depth) { in hid_open_report()
1299 kfree(parser->collection_stack); in hid_open_report()
1301 device->status |= HID_STAT_PARSED; in hid_open_report()
1308 size - (unsigned int)(end - start), size); in hid_open_report()
1310 kfree(parser->collection_stack); in hid_open_report()
1319 * Convert a signed n-bit integer to signed 32-bit integer. Common
1324 static s32 snto32(__u32 value, unsigned n) in snto32() argument
1326 if (!value || !n) in snto32()
1333 case 8: return ((__s8)value); in snto32()
1334 case 16: return ((__s16)value); in snto32()
1335 case 32: return ((__s32)value); in snto32()
1337 return value & (1 << (n - 1)) ? value | (~0U << n) : value; in snto32()
1340 s32 hid_snto32(__u32 value, unsigned n) in hid_snto32() argument
1342 return snto32(value, n); in hid_snto32()
1347 * Convert a signed 32-bit integer to a signed n-bit integer.
1350 static u32 s32ton(__s32 value, unsigned n) in s32ton() argument
1352 s32 a = value >> (n - 1); in s32ton()
1353 if (a && a != -1) in s32ton()
1354 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1; in s32ton()
1355 return value & ((1 << n) - 1); in s32ton()
1361 * Code sort-of follows HID spec:
1366 * One model of UPS is claimed to report "LINEV" as a 32-bit field.
1367 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1375 int bits_to_copy = 8 - bit_shift; in __extract()
1376 u32 value = 0; in __extract() local
1377 u32 mask = n < 32 ? (1U << n) - 1 : ~0U; in __extract()
1380 value |= ((u32)report[idx] >> bit_shift) << bit_nr; in __extract()
1381 n -= bits_to_copy; in __extract()
1388 return value & mask; in __extract()
1396 __func__, n, current->comm); in hid_field_extract()
1413 static void __implement(u8 *report, unsigned offset, int n, u32 value) in __implement() argument
1417 int bits_to_set = 8 - bit_shift; in __implement()
1419 while (n - bits_to_set >= 0) { in __implement()
1421 report[idx] |= value << bit_shift; in __implement()
1422 value >>= bits_to_set; in __implement()
1423 n -= bits_to_set; in __implement()
1431 u8 bit_mask = ((1U << n) - 1); in __implement()
1433 report[idx] |= value << bit_shift; in __implement()
1438 unsigned offset, unsigned n, u32 value) in implement() argument
1442 __func__, n, current->comm); in implement()
1445 u32 m = (1U << n) - 1; in implement()
1447 if (unlikely(value > m)) { in implement()
1449 "%s() called with too large value %d (n: %d)! (%s)\n", in implement()
1450 __func__, value, n, current->comm); in implement()
1452 value &= m; in implement()
1456 __implement(report, offset, n, value); in implement()
1460 * Search an array for a value.
1463 static int search(__s32 *array, __s32 value, unsigned n) in search() argument
1465 while (n--) { in search()
1466 if (*array++ == value) in search()
1469 return -1; in search()
1473 * hid_match_report - check if driver's raw_event should be called
1478 * compare hid->driver->report_table->report_type to report->type
1482 const struct hid_report_id *id = hid->driver->report_table; in hid_match_report()
1487 for (; id->report_type != HID_TERMINATOR; id++) in hid_match_report()
1488 if (id->report_type == HID_ANY_ID || in hid_match_report()
1489 id->report_type == report->type) in hid_match_report()
1495 * hid_match_usage - check if driver's event should be called
1500 * compare hid->driver->usage_table->usage_{type,code} to
1501 * usage->usage_{type,code}
1505 const struct hid_usage_id *id = hid->driver->usage_table; in hid_match_usage()
1510 for (; id->usage_type != HID_ANY_ID - 1; id++) in hid_match_usage()
1511 if ((id->usage_hid == HID_ANY_ID || in hid_match_usage()
1512 id->usage_hid == usage->hid) && in hid_match_usage()
1513 (id->usage_type == HID_ANY_ID || in hid_match_usage()
1514 id->usage_type == usage->type) && in hid_match_usage()
1515 (id->usage_code == HID_ANY_ID || in hid_match_usage()
1516 id->usage_code == usage->code)) in hid_match_usage()
1522 struct hid_usage *usage, __s32 value, int interrupt) in hid_process_event() argument
1524 struct hid_driver *hdrv = hid->driver; in hid_process_event()
1527 if (!list_empty(&hid->debug_list)) in hid_process_event()
1528 hid_dump_input(hid, usage, value); in hid_process_event()
1530 if (hdrv && hdrv->event && hid_match_usage(hid, usage)) { in hid_process_event()
1531 ret = hdrv->event(hid, field, usage, value); in hid_process_event()
1535 hdrv->name, ret); in hid_process_event()
1540 if (hid->claimed & HID_CLAIMED_INPUT) in hid_process_event()
1541 hidinput_hid_event(hid, field, usage, value); in hid_process_event()
1542 if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event) in hid_process_event()
1543 hid->hiddev_hid_event(hid, field, usage, value); in hid_process_event()
1547 * Checks if the given value is valid within this field
1550 __s32 value) in hid_array_value_is_valid() argument
1552 __s32 min = field->logical_minimum; in hid_array_value_is_valid()
1555 * Value needs to be between logical min and max, and in hid_array_value_is_valid()
1556 * (value - min) is used as an index in the usage array. in hid_array_value_is_valid()
1557 * This array is of size field->maxusage in hid_array_value_is_valid()
1559 return value >= min && in hid_array_value_is_valid()
1560 value <= field->logical_maximum && in hid_array_value_is_valid()
1561 value - min < field->maxusage; in hid_array_value_is_valid()
1573 unsigned count = field->report_count; in hid_input_fetch_field()
1574 unsigned offset = field->report_offset; in hid_input_fetch_field()
1575 unsigned size = field->report_size; in hid_input_fetch_field()
1576 __s32 min = field->logical_minimum; in hid_input_fetch_field()
1577 __s32 *value; in hid_input_fetch_field() local
1579 value = field->new_value; in hid_input_fetch_field()
1580 memset(value, 0, count * sizeof(__s32)); in hid_input_fetch_field()
1581 field->ignored = false; in hid_input_fetch_field()
1585 value[n] = min < 0 ? in hid_input_fetch_field()
1591 if (!(field->flags & HID_MAIN_ITEM_VARIABLE) && in hid_input_fetch_field()
1592 hid_array_value_is_valid(field, value[n]) && in hid_input_fetch_field()
1593 field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) { in hid_input_fetch_field()
1594 field->ignored = true; in hid_input_fetch_field()
1608 unsigned int count = field->report_count; in hid_input_var_field()
1609 __s32 *value = field->new_value; in hid_input_var_field() local
1615 &field->usage[n], in hid_input_var_field()
1616 value[n], in hid_input_var_field()
1619 memcpy(field->value, value, count * sizeof(__s32)); in hid_input_var_field()
1632 unsigned int count = field->report_count; in hid_input_array_field()
1633 __s32 min = field->logical_minimum; in hid_input_array_field()
1634 __s32 *value; in hid_input_array_field() local
1636 value = field->new_value; in hid_input_array_field()
1639 if (field->ignored) in hid_input_array_field()
1643 if (hid_array_value_is_valid(field, field->value[n]) && in hid_input_array_field()
1644 search(value, field->value[n], count)) in hid_input_array_field()
1647 &field->usage[field->value[n] - min], in hid_input_array_field()
1651 if (hid_array_value_is_valid(field, value[n]) && in hid_input_array_field()
1652 search(field->value, value[n], count)) in hid_input_array_field()
1655 &field->usage[value[n] - min], in hid_input_array_field()
1660 memcpy(field->value, value, count * sizeof(__s32)); in hid_input_array_field()
1678 for (a = 0; a < report->maxfield; a++) in hid_process_report()
1679 hid_input_fetch_field(hid, report->field[a], data); in hid_process_report()
1681 if (!list_empty(&report->field_entry_list)) { in hid_process_report()
1684 &report->field_entry_list, in hid_process_report()
1686 field = entry->field; in hid_process_report()
1688 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1691 &field->usage[entry->index], in hid_process_report()
1692 field->new_value[entry->index], in hid_process_report()
1699 for (a = 0; a < report->maxfield; a++) { in hid_process_report()
1700 field = report->field[a]; in hid_process_report()
1702 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1703 memcpy(field->value, field->new_value, in hid_process_report()
1704 field->report_count * sizeof(__s32)); in hid_process_report()
1708 for (a = 0; a < report->maxfield; a++) { in hid_process_report()
1709 field = report->field[a]; in hid_process_report()
1711 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1734 entry->field = field; in __hid_insert_field_entry()
1735 entry->index = usage_index; in __hid_insert_field_entry()
1736 entry->priority = field->usages_priorities[usage_index]; in __hid_insert_field_entry()
1740 &report->field_entry_list, in __hid_insert_field_entry()
1746 if (entry->priority > next->priority) { in __hid_insert_field_entry()
1747 list_add_tail(&entry->list, &next->list); in __hid_insert_field_entry()
1753 list_add_tail(&entry->list, &report->field_entry_list); in __hid_insert_field_entry()
1765 for (a = 0; a < report->maxfield; a++) { in hid_report_process_ordering()
1766 field = report->field[a]; in hid_report_process_ordering()
1768 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_report_process_ordering()
1769 count += field->report_count; in hid_report_process_ordering()
1779 report->field_entries = entries; in hid_report_process_ordering()
1783 * store them by priority order in report->field_entry_list in hid_report_process_ordering()
1785 * - Var elements are individualized (field + usage_index) in hid_report_process_ordering()
1786 * - Arrays are taken as one, we can not chose an order for them in hid_report_process_ordering()
1789 for (a = 0; a < report->maxfield; a++) { in hid_report_process_ordering()
1790 field = report->field[a]; in hid_report_process_ordering()
1792 if (field->flags & HID_MAIN_ITEM_VARIABLE) { in hid_report_process_ordering()
1793 for (u = 0; u < field->report_count; u++) { in hid_report_process_ordering()
1810 struct hid_report_enum *report_enum = &hid->report_enum[HID_INPUT_REPORT]; in hid_process_ordering()
1812 list_for_each_entry(report, &report_enum->report_list, list) in hid_process_ordering()
1823 unsigned count = field->report_count; in hid_output_field()
1824 unsigned offset = field->report_offset; in hid_output_field()
1825 unsigned size = field->report_size; in hid_output_field()
1829 if (field->logical_minimum < 0) /* signed values */ in hid_output_field()
1831 s32ton(field->value[n], size)); in hid_output_field()
1834 field->value[n]); in hid_output_field()
1843 if (report->size) in hid_compute_report_size()
1844 return ((report->size - 1) >> 3) + 1; in hid_compute_report_size()
1858 if (report->id > 0) in hid_output_report()
1859 *data++ = report->id; in hid_output_report()
1862 for (n = 0; n < report->maxfield; n++) in hid_output_report()
1863 hid_output_field(report->device, report->field[n], data); in hid_output_report()
1884 * Set a field value. The report this field belongs to has to be
1885 * created and transferred to the device, to set this value in the
1889 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value) in hid_set_field() argument
1894 return -1; in hid_set_field()
1896 size = field->report_size; in hid_set_field()
1898 hid_dump_input(field->report->device, field->usage + offset, value); in hid_set_field()
1900 if (offset >= field->report_count) { in hid_set_field()
1901 hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n", in hid_set_field()
1902 offset, field->report_count); in hid_set_field()
1903 return -1; in hid_set_field()
1905 if (field->logical_minimum < 0) { in hid_set_field()
1906 if (value != snto32(s32ton(value, size), size)) { in hid_set_field()
1907 hid_err(field->report->device, "value %d is out of range\n", value); in hid_set_field()
1908 return -1; in hid_set_field()
1911 field->value[offset] = value; in hid_set_field()
1923 if (report_enum->numbered) in hid_get_report()
1926 report = report_enum->report_id_hash[n]; in hid_get_report()
1946 return -ENOMEM; in __hid_request()
1953 ret = hid->ll_driver->raw_request(hid, report->id, buf, len, in __hid_request()
1954 report->type, reqtype); in __hid_request()
1961 hid_input_report(hid, report->type, buf, ret, 0); in __hid_request()
1974 struct hid_report_enum *report_enum = hid->report_enum + type; in hid_report_raw_event()
1986 if (report_enum->numbered) { in hid_report_raw_event()
1988 csize--; in hid_report_raw_event()
1993 if (hid->ll_driver->max_buffer_size) in hid_report_raw_event()
1994 max_buffer_size = hid->ll_driver->max_buffer_size; in hid_report_raw_event()
1996 if (report_enum->numbered && rsize >= max_buffer_size) in hid_report_raw_event()
1997 rsize = max_buffer_size - 1; in hid_report_raw_event()
2002 dbg_hid("report %d is too short, (%d < %d)\n", report->id, in hid_report_raw_event()
2004 memset(cdata + csize, 0, rsize - csize); in hid_report_raw_event()
2007 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) in hid_report_raw_event()
2008 hid->hiddev_report_event(hid, report); in hid_report_raw_event()
2009 if (hid->claimed & HID_CLAIMED_HIDRAW) { in hid_report_raw_event()
2015 if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) { in hid_report_raw_event()
2017 hdrv = hid->driver; in hid_report_raw_event()
2018 if (hdrv && hdrv->report) in hid_report_raw_event()
2019 hdrv->report(hid, report); in hid_report_raw_event()
2022 if (hid->claimed & HID_CLAIMED_INPUT) in hid_report_raw_event()
2030 * hid_input_report - report data from lower layer (usb, bt...)
2049 return -ENODEV; in hid_input_report()
2051 if (down_trylock(&hid->driver_input_lock)) in hid_input_report()
2052 return -EBUSY; in hid_input_report()
2054 if (!hid->driver) { in hid_input_report()
2055 ret = -ENODEV; in hid_input_report()
2058 report_enum = hid->report_enum + type; in hid_input_report()
2059 hdrv = hid->driver; in hid_input_report()
2069 ret = -1; in hid_input_report()
2074 if (!list_empty(&hid->debug_list)) in hid_input_report()
2080 ret = -1; in hid_input_report()
2084 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) { in hid_input_report()
2085 ret = hdrv->raw_event(hid, report, data, size); in hid_input_report()
2093 up(&hid->driver_input_lock); in hid_input_report()
2101 return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) && in hid_match_one_id()
2102 (id->group == HID_GROUP_ANY || id->group == hdev->group) && in hid_match_one_id()
2103 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) && in hid_match_one_id()
2104 (id->product == HID_ANY_ID || id->product == hdev->product); in hid_match_one_id()
2110 for (; id->bus; id++) in hid_match_id()
2138 if (off >= hdev->rsize) in read_report_descriptor()
2141 if (off + count > hdev->rsize) in read_report_descriptor()
2142 count = hdev->rsize - off; in read_report_descriptor()
2144 memcpy(buf, hdev->rdesc + off, count); in read_report_descriptor()
2155 return sprintf(buf, "%02x\n", hdev->country & 0xff); in show_country()
2173 "Multi-Axis Controller" in hid_connect()
2185 if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE) in hid_connect()
2187 if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE) in hid_connect()
2189 if (hdev->bus != BUS_USB) in hid_connect()
2196 hdev->claimed |= HID_CLAIMED_INPUT; in hid_connect()
2198 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect && in hid_connect()
2199 !hdev->hiddev_connect(hdev, in hid_connect()
2201 hdev->claimed |= HID_CLAIMED_HIDDEV; in hid_connect()
2203 hdev->claimed |= HID_CLAIMED_HIDRAW; in hid_connect()
2206 hdev->claimed |= HID_CLAIMED_DRIVER; in hid_connect()
2208 /* Drivers with the ->raw_event callback set are not required to connect in hid_connect()
2210 if (!hdev->claimed && !hdev->driver->raw_event) { in hid_connect()
2212 return -ENODEV; in hid_connect()
2217 if ((hdev->claimed & HID_CLAIMED_INPUT) && in hid_connect()
2218 (connect_mask & HID_CONNECT_FF) && hdev->ff_init) in hid_connect()
2219 hdev->ff_init(hdev); in hid_connect()
2222 if (hdev->claimed & HID_CLAIMED_INPUT) in hid_connect()
2224 if (hdev->claimed & HID_CLAIMED_HIDDEV) in hid_connect()
2226 ((struct hiddev *)hdev->hiddev)->minor); in hid_connect()
2227 if (hdev->claimed & HID_CLAIMED_HIDRAW) in hid_connect()
2229 ((struct hidraw *)hdev->hidraw)->minor); in hid_connect()
2232 for (i = 0; i < hdev->maxcollection; i++) { in hid_connect()
2233 struct hid_collection *col = &hdev->collection[i]; in hid_connect()
2234 if (col->type == HID_COLLECTION_APPLICATION && in hid_connect()
2235 (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK && in hid_connect()
2236 (col->usage & 0xffff) < ARRAY_SIZE(types)) { in hid_connect()
2237 type = types[col->usage & 0xffff]; in hid_connect()
2242 switch (hdev->bus) { in hid_connect()
2263 ret = device_create_file(&hdev->dev, &dev_attr_country); in hid_connect()
2269 buf, bus, hdev->version >> 8, hdev->version & 0xff, in hid_connect()
2270 type, hdev->name, hdev->phys); in hid_connect()
2278 device_remove_file(&hdev->dev, &dev_attr_country); in hid_disconnect()
2279 if (hdev->claimed & HID_CLAIMED_INPUT) in hid_disconnect()
2281 if (hdev->claimed & HID_CLAIMED_HIDDEV) in hid_disconnect()
2282 hdev->hiddev_disconnect(hdev); in hid_disconnect()
2283 if (hdev->claimed & HID_CLAIMED_HIDRAW) in hid_disconnect()
2285 hdev->claimed = 0; in hid_disconnect()
2292 * hid_hw_start - start underlying HW
2297 * buffers and start the device (if not defeirred to device open).
2304 error = hdev->ll_driver->start(hdev); in hid_hw_start()
2311 hdev->ll_driver->stop(hdev); in hid_hw_start()
2321 * hid_hw_stop - stop underlying HW
2330 hdev->ll_driver->stop(hdev); in hid_hw_stop()
2335 * hid_hw_open - signal underlying HW to start delivering events
2338 * Tell underlying HW to start delivering events from the device.
2346 ret = mutex_lock_killable(&hdev->ll_open_lock); in hid_hw_open()
2350 if (!hdev->ll_open_count++) { in hid_hw_open()
2351 ret = hdev->ll_driver->open(hdev); in hid_hw_open()
2353 hdev->ll_open_count--; in hid_hw_open()
2356 mutex_unlock(&hdev->ll_open_lock); in hid_hw_open()
2362 * hid_hw_close - signal underlaying HW to stop delivering events
2372 mutex_lock(&hdev->ll_open_lock); in hid_hw_close()
2373 if (!--hdev->ll_open_count) in hid_hw_close()
2374 hdev->ll_driver->close(hdev); in hid_hw_close()
2375 mutex_unlock(&hdev->ll_open_lock); in hid_hw_close()
2380 * hid_hw_request - send report request to device
2389 if (hdev->ll_driver->request) in hid_hw_request()
2390 return hdev->ll_driver->request(hdev, report, reqtype); in hid_hw_request()
2397 * hid_hw_raw_request - send report request to device
2416 if (hdev->ll_driver->max_buffer_size) in hid_hw_raw_request()
2417 max_buffer_size = hdev->ll_driver->max_buffer_size; in hid_hw_raw_request()
2420 return -EINVAL; in hid_hw_raw_request()
2422 return hdev->ll_driver->raw_request(hdev, reportnum, buf, len, in hid_hw_raw_request()
2428 * hid_hw_output_report - send output report to device
2440 if (hdev->ll_driver->max_buffer_size) in hid_hw_output_report()
2441 max_buffer_size = hdev->ll_driver->max_buffer_size; in hid_hw_output_report()
2444 return -EINVAL; in hid_hw_output_report()
2446 if (hdev->ll_driver->output_report) in hid_hw_output_report()
2447 return hdev->ll_driver->output_report(hdev, buf, len); in hid_hw_output_report()
2449 return -ENOSYS; in hid_hw_output_report()
2456 if (hdev->driver && hdev->driver->suspend) in hid_driver_suspend()
2457 return hdev->driver->suspend(hdev, state); in hid_driver_suspend()
2465 if (hdev->driver && hdev->driver->reset_resume) in hid_driver_reset_resume()
2466 return hdev->driver->reset_resume(hdev); in hid_driver_reset_resume()
2474 if (hdev->driver && hdev->driver->resume) in hid_driver_resume()
2475 return hdev->driver->resume(hdev); in hid_driver_resume()
2488 * new_id_store - add a new HID device ID to this driver and re-probe devices
2508 return -EINVAL; in new_id_store()
2512 return -ENOMEM; in new_id_store()
2514 dynid->id.bus = bus; in new_id_store()
2515 dynid->id.group = HID_GROUP_ANY; in new_id_store()
2516 dynid->id.vendor = vendor; in new_id_store()
2517 dynid->id.product = product; in new_id_store()
2518 dynid->id.driver_data = driver_data; in new_id_store()
2520 spin_lock(&hdrv->dyn_lock); in new_id_store()
2521 list_add_tail(&dynid->list, &hdrv->dyn_list); in new_id_store()
2522 spin_unlock(&hdrv->dyn_lock); in new_id_store()
2524 ret = driver_attach(&hdrv->driver); in new_id_store()
2540 spin_lock(&hdrv->dyn_lock); in hid_free_dynids()
2541 list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) { in hid_free_dynids()
2542 list_del(&dynid->list); in hid_free_dynids()
2545 spin_unlock(&hdrv->dyn_lock); in hid_free_dynids()
2553 spin_lock(&hdrv->dyn_lock); in hid_match_device()
2554 list_for_each_entry(dynid, &hdrv->dyn_list, list) { in hid_match_device()
2555 if (hid_match_one_id(hdev, &dynid->id)) { in hid_match_device()
2556 spin_unlock(&hdrv->dyn_lock); in hid_match_device()
2557 return &dynid->id; in hid_match_device()
2560 spin_unlock(&hdrv->dyn_lock); in hid_match_device()
2562 return hid_match_id(hdev, hdrv->id_table); in hid_match_device()
2575 * hid_compare_device_paths - check if both devices share the same path
2581 * the separator char. Both paths must exist (i.e., zero-length paths
2587 int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys; in hid_compare_device_paths()
2588 int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys; in hid_compare_device_paths()
2593 return !strncmp(hdev_a->phys, hdev_b->phys, n1); in hid_compare_device_paths()
2605 if (hdrv->match) in hid_check_device_match()
2606 return hdrv->match(hdev, hid_ignore_special_drivers); in hid_check_device_match()
2609 * hid-generic implements .match(), so we must be dealing with a in hid_check_device_match()
2622 return -ENODEV; in __hid_device_probe()
2624 hdev->devres_group_id = devres_open_group(&hdev->dev, NULL, GFP_KERNEL); in __hid_device_probe()
2625 if (!hdev->devres_group_id) in __hid_device_probe()
2626 return -ENOMEM; in __hid_device_probe()
2629 hdev->quirks = hid_lookup_quirk(hdev); in __hid_device_probe()
2630 hdev->driver = hdrv; in __hid_device_probe()
2632 if (hdrv->probe) { in __hid_device_probe()
2633 ret = hdrv->probe(hdev, id); in __hid_device_probe()
2649 devres_release_group(&hdev->dev, hdev->devres_group_id); in __hid_device_probe()
2651 hdev->driver = NULL; in __hid_device_probe()
2660 struct hid_driver *hdrv = to_hid_driver(dev->driver); in hid_device_probe()
2663 if (down_interruptible(&hdev->driver_input_lock)) in hid_device_probe()
2664 return -EINTR; in hid_device_probe()
2666 hdev->io_started = false; in hid_device_probe()
2667 clear_bit(ffs(HID_STAT_REPROBED), &hdev->status); in hid_device_probe()
2669 if (!hdev->driver) in hid_device_probe()
2672 if (!hdev->io_started) in hid_device_probe()
2673 up(&hdev->driver_input_lock); in hid_device_probe()
2683 down(&hdev->driver_input_lock); in hid_device_remove()
2684 hdev->io_started = false; in hid_device_remove()
2686 hdrv = hdev->driver; in hid_device_remove()
2688 if (hdrv->remove) in hid_device_remove()
2689 hdrv->remove(hdev); in hid_device_remove()
2694 devres_release_group(&hdev->dev, hdev->devres_group_id); in hid_device_remove()
2697 hdev->driver = NULL; in hid_device_remove()
2700 if (!hdev->io_started) in hid_device_remove()
2701 up(&hdev->driver_input_lock); in hid_device_remove()
2710 hdev->bus, hdev->group, hdev->vendor, hdev->product); in modalias_show()
2733 hdev->bus, hdev->vendor, hdev->product)) in hid_uevent()
2734 return -ENOMEM; in hid_uevent()
2736 if (add_uevent_var(env, "HID_NAME=%s", hdev->name)) in hid_uevent()
2737 return -ENOMEM; in hid_uevent()
2739 if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys)) in hid_uevent()
2740 return -ENOMEM; in hid_uevent()
2742 if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq)) in hid_uevent()
2743 return -ENOMEM; in hid_uevent()
2746 hdev->bus, hdev->group, hdev->vendor, hdev->product)) in hid_uevent()
2747 return -ENOMEM; in hid_uevent()
2768 if (WARN_ON(hdev->status & HID_STAT_ADDED)) in hid_add_device()
2769 return -EBUSY; in hid_add_device()
2771 hdev->quirks = hid_lookup_quirk(hdev); in hid_add_device()
2776 return -ENODEV; in hid_add_device()
2781 if (!hdev->ll_driver->raw_request) { in hid_add_device()
2783 return -EINVAL; in hid_add_device()
2788 * for the driver-specific modifications. in hid_add_device()
2790 ret = hdev->ll_driver->parse(hdev); in hid_add_device()
2793 if (!hdev->dev_rdesc) in hid_add_device()
2794 return -ENODEV; in hid_add_device()
2800 hdev->group = HID_GROUP_GENERIC; in hid_add_device()
2801 } else if (!hdev->group && in hid_add_device()
2802 !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) { in hid_add_device()
2808 hdev->id = atomic_inc_return(&id); in hid_add_device()
2812 dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus, in hid_add_device()
2813 hdev->vendor, hdev->product, hdev->id); in hid_add_device()
2815 hid_debug_register(hdev, dev_name(&hdev->dev)); in hid_add_device()
2816 ret = device_add(&hdev->dev); in hid_add_device()
2818 hdev->status |= HID_STAT_ADDED; in hid_add_device()
2827 * hid_allocate_device - allocate new hid device descriptor
2833 * error value.
2838 int ret = -ENOMEM; in hid_allocate_device()
2844 device_initialize(&hdev->dev); in hid_allocate_device()
2845 hdev->dev.release = hid_device_release; in hid_allocate_device()
2846 hdev->dev.bus = &hid_bus_type; in hid_allocate_device()
2847 device_enable_async_suspend(&hdev->dev); in hid_allocate_device()
2851 init_waitqueue_head(&hdev->debug_wait); in hid_allocate_device()
2852 INIT_LIST_HEAD(&hdev->debug_list); in hid_allocate_device()
2853 spin_lock_init(&hdev->debug_list_lock); in hid_allocate_device()
2854 sema_init(&hdev->driver_input_lock, 1); in hid_allocate_device()
2855 mutex_init(&hdev->ll_open_lock); in hid_allocate_device()
2856 kref_init(&hdev->ref); in hid_allocate_device()
2866 if (hdev->status & HID_STAT_ADDED) { in hid_remove_device()
2867 device_del(&hdev->dev); in hid_remove_device()
2869 hdev->status &= ~HID_STAT_ADDED; in hid_remove_device()
2871 kfree(hdev->dev_rdesc); in hid_remove_device()
2872 hdev->dev_rdesc = NULL; in hid_remove_device()
2873 hdev->dev_rsize = 0; in hid_remove_device()
2877 * hid_destroy_device - free previously allocated device
2888 put_device(&hdev->dev); in hid_destroy_device()
2898 if (hdev->driver == hdrv && in __hid_bus_reprobe_drivers()
2899 !hdrv->match(hdev, hid_ignore_special_drivers) && in __hid_bus_reprobe_drivers()
2900 !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status)) in __hid_bus_reprobe_drivers()
2910 if (hdrv->match) { in __hid_bus_driver_added()
2928 hdrv->driver.name = hdrv->name; in __hid_register_driver()
2929 hdrv->driver.bus = &hid_bus_type; in __hid_register_driver()
2930 hdrv->driver.owner = owner; in __hid_register_driver()
2931 hdrv->driver.mod_name = mod_name; in __hid_register_driver()
2933 INIT_LIST_HEAD(&hdrv->dyn_list); in __hid_register_driver()
2934 spin_lock_init(&hdrv->dyn_lock); in __hid_register_driver()
2936 ret = driver_register(&hdrv->driver); in __hid_register_driver()
2948 driver_unregister(&hdrv->driver); in hid_unregister_driver()
2960 if (!(hid->claimed & HID_CLAIMED_INPUT)) in hid_check_keys_pressed()
2963 list_for_each_entry(hidinput, &hid->inputs, list) { in hid_check_keys_pressed()
2965 if (hidinput->input->key[i]) in hid_check_keys_pressed()