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 hid_device_release()
719 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item) in fetch_item() argument
723 if ((end - start) <= 0) in fetch_item()
726 b = *start++; in fetch_item()
728 item->type = (b >> 2) & 3; in fetch_item()
729 item->tag = (b >> 4) & 15; in fetch_item()
731 if (item->tag == HID_ITEM_TAG_LONG) { in fetch_item()
733 item->format = HID_ITEM_FORMAT_LONG; in fetch_item()
735 if ((end - start) < 2) in fetch_item()
738 item->size = *start++; in fetch_item()
739 item->tag = *start++; in fetch_item()
741 if ((end - start) < item->size) in fetch_item()
744 item->data.longdata = start; in fetch_item()
745 start += item->size; in fetch_item()
746 return start; in fetch_item()
749 item->format = HID_ITEM_FORMAT_SHORT; in fetch_item()
750 item->size = b & 3; in fetch_item()
752 switch (item->size) { in fetch_item()
754 return start; in fetch_item()
757 if ((end - start) < 1) in fetch_item()
759 item->data.u8 = *start++; in fetch_item()
760 return start; in fetch_item()
763 if ((end - start) < 2) in fetch_item()
765 item->data.u16 = get_unaligned_le16(start); in fetch_item()
766 start = (__u8 *)((__le16 *)start + 1); in fetch_item()
767 return start; in fetch_item()
770 item->size++; in fetch_item()
771 if ((end - start) < 4) in fetch_item()
773 item->data.u32 = get_unaligned_le32(start); in fetch_item()
774 start = (__u8 *)((__le32 *)start + 1); in fetch_item()
775 return start; in fetch_item()
783 struct hid_device *hid = parser->device; in hid_scan_input_usage()
786 hid->group = HID_GROUP_MULTITOUCH; in hid_scan_input_usage()
791 if (usage == 0xff0000c5 && parser->global.report_count == 256 && in hid_scan_feature_usage()
792 parser->global.report_size == 8) in hid_scan_feature_usage()
793 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; in hid_scan_feature_usage()
795 if (usage == 0xff0000c6 && parser->global.report_count == 1 && in hid_scan_feature_usage()
796 parser->global.report_size == 8) in hid_scan_feature_usage()
797 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8; in hid_scan_feature_usage()
802 struct hid_device *hid = parser->device; in hid_scan_collection()
805 if (((parser->global.usage_page << 16) == HID_UP_SENSOR) && in hid_scan_collection()
808 hid->group = HID_GROUP_SENSOR_HUB; in hid_scan_collection()
810 if (hid->vendor == USB_VENDOR_ID_MICROSOFT && in hid_scan_collection()
811 hid->product == USB_DEVICE_ID_MS_POWER_COVER && in hid_scan_collection()
812 hid->group == HID_GROUP_MULTITOUCH) in hid_scan_collection()
813 hid->group = HID_GROUP_GENERIC; in hid_scan_collection()
815 if ((parser->global.usage_page << 16) == HID_UP_GENDESK) in hid_scan_collection()
816 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_collection()
817 if (parser->local.usage[i] == HID_GD_POINTER) in hid_scan_collection()
818 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER; in hid_scan_collection()
820 if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR) in hid_scan_collection()
821 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC; in hid_scan_collection()
823 if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR) in hid_scan_collection()
824 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_collection()
825 if (parser->local.usage[i] == in hid_scan_collection()
827 parser->device->group = in hid_scan_collection()
840 switch (item->tag) { in hid_scan_main()
847 /* ignore constant inputs, they will be ignored by hid-input */ in hid_scan_main()
850 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_main()
851 hid_scan_input_usage(parser, parser->local.usage[i]); in hid_scan_main()
856 for (i = 0; i < parser->local.usage_index; i++) in hid_scan_main()
857 hid_scan_feature_usage(parser, parser->local.usage[i]); in hid_scan_main()
862 memset(&parser->local, 0, sizeof(parser->local)); in hid_scan_main()
876 __u8 *start = hid->dev_rdesc; in hid_scan_report() local
877 __u8 *end = start + hid->dev_rsize; in hid_scan_report()
888 return -ENOMEM; in hid_scan_report()
890 parser->device = hid; in hid_scan_report()
891 hid->group = HID_GROUP_GENERIC; in hid_scan_report()
898 while ((start = fetch_item(start, end, &item)) != NULL) in hid_scan_report()
904 if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) && in hid_scan_report()
905 (hid->group == HID_GROUP_MULTITOUCH)) in hid_scan_report()
906 hid->group = HID_GROUP_MULTITOUCH_WIN_8; in hid_scan_report()
911 switch (hid->vendor) { in hid_scan_report()
913 hid->group = HID_GROUP_WACOM; in hid_scan_report()
916 if (hid->group == HID_GROUP_GENERIC) in hid_scan_report()
917 if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC) in hid_scan_report()
918 && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER)) in hid_scan_report()
920 * hid-rmi should take care of them, in hid_scan_report()
921 * not hid-generic in hid_scan_report()
923 hid->group = HID_GROUP_RMI; in hid_scan_report()
927 kfree(parser->collection_stack); in hid_scan_report()
933 * hid_parse_report - parse device report
936 * @start: report start
942 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size) in hid_parse_report() argument
944 hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL); in hid_parse_report()
945 if (!hid->dev_rdesc) in hid_parse_report()
946 return -ENOMEM; in hid_parse_report()
947 hid->dev_rsize = size; in hid_parse_report()
958 * hid_validate_values - validate existing device report's value indexes
988 * ->numbered being checked, which may not always be the case when in hid_validate_values()
997 &hid->report_enum[type].report_list, in hid_validate_values()
1000 report = hid->report_enum[type].report_id_hash[id]; in hid_validate_values()
1006 if (report->maxfield <= field_index) { in hid_validate_values()
1011 if (report->field[field_index]->report_count < report_counts) { in hid_validate_values()
1024 __s32 v = *multiplier->value; in hid_calculate_multiplier()
1025 __s32 lmin = multiplier->logical_minimum; in hid_calculate_multiplier()
1026 __s32 lmax = multiplier->logical_maximum; in hid_calculate_multiplier()
1027 __s32 pmin = multiplier->physical_minimum; in hid_calculate_multiplier()
1028 __s32 pmax = multiplier->physical_maximum; in hid_calculate_multiplier()
1037 if (lmax - lmin == 0) in hid_calculate_multiplier()
1043 m = ((v - lmin)/(lmax - lmin) * (pmax - pmin) + pmin); in hid_calculate_multiplier()
1044 if (unlikely(multiplier->unit_exponent != 0)) { in hid_calculate_multiplier()
1047 multiplier->unit_exponent); in hid_calculate_multiplier()
1051 if (unlikely(m == 0 || m > 255 || m < -255)) { in hid_calculate_multiplier()
1074 for (i = 0; i < field->maxusage; i++) { in hid_apply_multiplier_to_field()
1075 usage = &field->usage[i]; in hid_apply_multiplier_to_field()
1077 collection = &hid->collection[usage->collection_index]; in hid_apply_multiplier_to_field()
1078 while (collection->parent_idx != -1 && in hid_apply_multiplier_to_field()
1080 collection = &hid->collection[collection->parent_idx]; in hid_apply_multiplier_to_field()
1082 if (collection->parent_idx != -1 || in hid_apply_multiplier_to_field()
1084 usage->resolution_multiplier = effective_multiplier; in hid_apply_multiplier_to_field()
1117 multiplier_collection = &hid->collection[multiplier->usage->collection_index]; in hid_apply_multiplier()
1118 while (multiplier_collection->parent_idx != -1 && in hid_apply_multiplier()
1119 multiplier_collection->type != HID_COLLECTION_LOGICAL) in hid_apply_multiplier()
1120 multiplier_collection = &hid->collection[multiplier_collection->parent_idx]; in hid_apply_multiplier()
1124 rep_enum = &hid->report_enum[HID_INPUT_REPORT]; in hid_apply_multiplier()
1125 list_for_each_entry(rep, &rep_enum->report_list, list) { in hid_apply_multiplier()
1126 for (i = 0; i < rep->maxfield; i++) { in hid_apply_multiplier()
1127 field = rep->field[i]; in hid_apply_multiplier()
1136 * hid_setup_resolution_multiplier - set up all resolution multipliers
1141 * value to all matching Input items. This only updates the internal struct
1145 * is anything other than 1, the hardware will send pre-multiplied events
1147 * accumulated_value = value * * multiplier
1149 * - "value * multiplier" for each event, or
1150 * - "value" but "multiplier" times as frequently, or
1151 * - a combination of the above
1153 * an accumulated 'value * multiplier'.
1165 rep_enum = &hid->report_enum[HID_FEATURE_REPORT]; in hid_setup_resolution_multiplier()
1166 list_for_each_entry(rep, &rep_enum->report_list, list) { in hid_setup_resolution_multiplier()
1167 for (i = 0; i < rep->maxfield; i++) { in hid_setup_resolution_multiplier()
1169 if (rep->field[i]->report_count < 1) in hid_setup_resolution_multiplier()
1172 for (j = 0; j < rep->field[i]->maxusage; j++) { in hid_setup_resolution_multiplier()
1173 usage = &rep->field[i]->usage[j]; in hid_setup_resolution_multiplier()
1174 if (usage->hid == HID_GD_RESOLUTION_MULTIPLIER) in hid_setup_resolution_multiplier()
1176 rep->field[i]); in hid_setup_resolution_multiplier()
1184 * hid_open_report - open a driver-specific device report
1190 * 0 returned on success, otherwise nonzero error value.
1200 __u8 *start; in hid_open_report() local
1214 if (WARN_ON(device->status & HID_STAT_PARSED)) in hid_open_report()
1215 return -EBUSY; in hid_open_report()
1217 start = device->dev_rdesc; in hid_open_report()
1218 if (WARN_ON(!start)) in hid_open_report()
1219 return -ENODEV; in hid_open_report()
1220 size = device->dev_rsize; in hid_open_report()
1223 buf = call_hid_bpf_rdesc_fixup(device, start, &size); in hid_open_report()
1225 return -ENOMEM; in hid_open_report()
1227 if (device->driver->report_fixup) in hid_open_report()
1228 start = device->driver->report_fixup(device, buf, &size); in hid_open_report()
1230 start = buf; in hid_open_report()
1232 start = kmemdup(start, size, GFP_KERNEL); in hid_open_report()
1234 if (start == NULL) in hid_open_report()
1235 return -ENOMEM; in hid_open_report()
1237 device->rdesc = start; in hid_open_report()
1238 device->rsize = size; in hid_open_report()
1242 ret = -ENOMEM; in hid_open_report()
1246 parser->device = device; in hid_open_report()
1248 end = start + size; in hid_open_report()
1250 device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS, in hid_open_report()
1252 if (!device->collection) { in hid_open_report()
1253 ret = -ENOMEM; in hid_open_report()
1256 device->collection_size = HID_DEFAULT_NUM_COLLECTIONS; in hid_open_report()
1258 device->collection[i].parent_idx = -1; in hid_open_report()
1260 ret = -EINVAL; in hid_open_report()
1261 while ((next = fetch_item(start, end, &item)) != NULL) { in hid_open_report()
1262 start = next; in hid_open_report()
1276 if (start == end) { in hid_open_report()
1277 if (parser->collection_stack_ptr) { in hid_open_report()
1281 if (parser->local.delimiter_depth) { in hid_open_report()
1292 kfree(parser->collection_stack); in hid_open_report()
1294 device->status |= HID_STAT_PARSED; in hid_open_report()
1301 size - (unsigned int)(end - start), size); in hid_open_report()
1303 kfree(parser->collection_stack); in hid_open_report()
1312 * Convert a signed n-bit integer to signed 32-bit integer. Common
1317 static s32 snto32(__u32 value, unsigned n) in snto32() argument
1319 if (!value || !n) in snto32()
1326 case 8: return ((__s8)value); in snto32()
1327 case 16: return ((__s16)value); in snto32()
1328 case 32: return ((__s32)value); in snto32()
1330 return value & (1 << (n - 1)) ? value | (~0U << n) : value; in snto32()
1333 s32 hid_snto32(__u32 value, unsigned n) in hid_snto32() argument
1335 return snto32(value, n); in hid_snto32()
1340 * Convert a signed 32-bit integer to a signed n-bit integer.
1343 static u32 s32ton(__s32 value, unsigned n) in s32ton() argument
1345 s32 a = value >> (n - 1); in s32ton()
1346 if (a && a != -1) in s32ton()
1347 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1; in s32ton()
1348 return value & ((1 << n) - 1); in s32ton()
1354 * Code sort-of follows HID spec:
1359 * One model of UPS is claimed to report "LINEV" as a 32-bit field.
1360 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1368 int bits_to_copy = 8 - bit_shift; in __extract()
1369 u32 value = 0; in __extract() local
1370 u32 mask = n < 32 ? (1U << n) - 1 : ~0U; in __extract()
1373 value |= ((u32)report[idx] >> bit_shift) << bit_nr; in __extract()
1374 n -= bits_to_copy; in __extract()
1381 return value & mask; in __extract()
1389 __func__, n, current->comm); in hid_field_extract()
1406 static void __implement(u8 *report, unsigned offset, int n, u32 value) in __implement() argument
1410 int bits_to_set = 8 - bit_shift; in __implement()
1412 while (n - bits_to_set >= 0) { in __implement()
1414 report[idx] |= value << bit_shift; in __implement()
1415 value >>= bits_to_set; in __implement()
1416 n -= bits_to_set; in __implement()
1424 u8 bit_mask = ((1U << n) - 1); in __implement()
1426 report[idx] |= value << bit_shift; in __implement()
1431 unsigned offset, unsigned n, u32 value) in implement() argument
1435 __func__, n, current->comm); in implement()
1438 u32 m = (1U << n) - 1; in implement()
1440 if (unlikely(value > m)) { in implement()
1442 "%s() called with too large value %d (n: %d)! (%s)\n", in implement()
1443 __func__, value, n, current->comm); in implement()
1445 value &= m; in implement()
1449 __implement(report, offset, n, value); in implement()
1453 * Search an array for a value.
1456 static int search(__s32 *array, __s32 value, unsigned n) in search() argument
1458 while (n--) { in search()
1459 if (*array++ == value) in search()
1462 return -1; in search()
1466 * hid_match_report - check if driver's raw_event should be called
1471 * compare hid->driver->report_table->report_type to report->type
1475 const struct hid_report_id *id = hid->driver->report_table; in hid_match_report()
1480 for (; id->report_type != HID_TERMINATOR; id++) in hid_match_report()
1481 if (id->report_type == HID_ANY_ID || in hid_match_report()
1482 id->report_type == report->type) in hid_match_report()
1488 * hid_match_usage - check if driver's event should be called
1493 * compare hid->driver->usage_table->usage_{type,code} to
1494 * usage->usage_{type,code}
1498 const struct hid_usage_id *id = hid->driver->usage_table; in hid_match_usage()
1503 for (; id->usage_type != HID_ANY_ID - 1; id++) in hid_match_usage()
1504 if ((id->usage_hid == HID_ANY_ID || in hid_match_usage()
1505 id->usage_hid == usage->hid) && in hid_match_usage()
1506 (id->usage_type == HID_ANY_ID || in hid_match_usage()
1507 id->usage_type == usage->type) && in hid_match_usage()
1508 (id->usage_code == HID_ANY_ID || in hid_match_usage()
1509 id->usage_code == usage->code)) in hid_match_usage()
1515 struct hid_usage *usage, __s32 value, int interrupt) in hid_process_event() argument
1517 struct hid_driver *hdrv = hid->driver; in hid_process_event()
1520 if (!list_empty(&hid->debug_list)) in hid_process_event()
1521 hid_dump_input(hid, usage, value); in hid_process_event()
1523 if (hdrv && hdrv->event && hid_match_usage(hid, usage)) { in hid_process_event()
1524 ret = hdrv->event(hid, field, usage, value); in hid_process_event()
1528 hdrv->name, ret); in hid_process_event()
1533 if (hid->claimed & HID_CLAIMED_INPUT) in hid_process_event()
1534 hidinput_hid_event(hid, field, usage, value); in hid_process_event()
1535 if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event) in hid_process_event()
1536 hid->hiddev_hid_event(hid, field, usage, value); in hid_process_event()
1540 * Checks if the given value is valid within this field
1543 __s32 value) in hid_array_value_is_valid() argument
1545 __s32 min = field->logical_minimum; in hid_array_value_is_valid()
1548 * Value needs to be between logical min and max, and in hid_array_value_is_valid()
1549 * (value - min) is used as an index in the usage array. in hid_array_value_is_valid()
1550 * This array is of size field->maxusage in hid_array_value_is_valid()
1552 return value >= min && in hid_array_value_is_valid()
1553 value <= field->logical_maximum && in hid_array_value_is_valid()
1554 value - min < field->maxusage; in hid_array_value_is_valid()
1566 unsigned count = field->report_count; in hid_input_fetch_field()
1567 unsigned offset = field->report_offset; in hid_input_fetch_field()
1568 unsigned size = field->report_size; in hid_input_fetch_field()
1569 __s32 min = field->logical_minimum; in hid_input_fetch_field()
1570 __s32 *value; in hid_input_fetch_field() local
1572 value = field->new_value; in hid_input_fetch_field()
1573 memset(value, 0, count * sizeof(__s32)); in hid_input_fetch_field()
1574 field->ignored = false; in hid_input_fetch_field()
1578 value[n] = min < 0 ? in hid_input_fetch_field()
1584 if (!(field->flags & HID_MAIN_ITEM_VARIABLE) && in hid_input_fetch_field()
1585 hid_array_value_is_valid(field, value[n]) && in hid_input_fetch_field()
1586 field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) { in hid_input_fetch_field()
1587 field->ignored = true; in hid_input_fetch_field()
1601 unsigned int count = field->report_count; in hid_input_var_field()
1602 __s32 *value = field->new_value; in hid_input_var_field() local
1608 &field->usage[n], in hid_input_var_field()
1609 value[n], in hid_input_var_field()
1612 memcpy(field->value, value, count * sizeof(__s32)); in hid_input_var_field()
1625 unsigned int count = field->report_count; in hid_input_array_field()
1626 __s32 min = field->logical_minimum; in hid_input_array_field()
1627 __s32 *value; in hid_input_array_field() local
1629 value = field->new_value; in hid_input_array_field()
1632 if (field->ignored) in hid_input_array_field()
1636 if (hid_array_value_is_valid(field, field->value[n]) && in hid_input_array_field()
1637 search(value, field->value[n], count)) in hid_input_array_field()
1640 &field->usage[field->value[n] - min], in hid_input_array_field()
1644 if (hid_array_value_is_valid(field, value[n]) && in hid_input_array_field()
1645 search(field->value, value[n], count)) in hid_input_array_field()
1648 &field->usage[value[n] - min], in hid_input_array_field()
1653 memcpy(field->value, value, count * sizeof(__s32)); in hid_input_array_field()
1671 for (a = 0; a < report->maxfield; a++) in hid_process_report()
1672 hid_input_fetch_field(hid, report->field[a], data); in hid_process_report()
1674 if (!list_empty(&report->field_entry_list)) { in hid_process_report()
1677 &report->field_entry_list, in hid_process_report()
1679 field = entry->field; in hid_process_report()
1681 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1684 &field->usage[entry->index], in hid_process_report()
1685 field->new_value[entry->index], in hid_process_report()
1692 for (a = 0; a < report->maxfield; a++) { in hid_process_report()
1693 field = report->field[a]; in hid_process_report()
1695 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1696 memcpy(field->value, field->new_value, in hid_process_report()
1697 field->report_count * sizeof(__s32)); in hid_process_report()
1701 for (a = 0; a < report->maxfield; a++) { in hid_process_report()
1702 field = report->field[a]; in hid_process_report()
1704 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_process_report()
1727 entry->field = field; in __hid_insert_field_entry()
1728 entry->index = usage_index; in __hid_insert_field_entry()
1729 entry->priority = field->usages_priorities[usage_index]; in __hid_insert_field_entry()
1733 &report->field_entry_list, in __hid_insert_field_entry()
1739 if (entry->priority > next->priority) { in __hid_insert_field_entry()
1740 list_add_tail(&entry->list, &next->list); in __hid_insert_field_entry()
1746 list_add_tail(&entry->list, &report->field_entry_list); in __hid_insert_field_entry()
1758 for (a = 0; a < report->maxfield; a++) { in hid_report_process_ordering()
1759 field = report->field[a]; in hid_report_process_ordering()
1761 if (field->flags & HID_MAIN_ITEM_VARIABLE) in hid_report_process_ordering()
1762 count += field->report_count; in hid_report_process_ordering()
1772 report->field_entries = entries; in hid_report_process_ordering()
1776 * store them by priority order in report->field_entry_list in hid_report_process_ordering()
1778 * - Var elements are individualized (field + usage_index) in hid_report_process_ordering()
1779 * - Arrays are taken as one, we can not chose an order for them in hid_report_process_ordering()
1782 for (a = 0; a < report->maxfield; a++) { in hid_report_process_ordering()
1783 field = report->field[a]; in hid_report_process_ordering()
1785 if (field->flags & HID_MAIN_ITEM_VARIABLE) { in hid_report_process_ordering()
1786 for (u = 0; u < field->report_count; u++) { in hid_report_process_ordering()
1803 struct hid_report_enum *report_enum = &hid->report_enum[HID_INPUT_REPORT]; in hid_process_ordering()
1805 list_for_each_entry(report, &report_enum->report_list, list) in hid_process_ordering()
1816 unsigned count = field->report_count; in hid_output_field()
1817 unsigned offset = field->report_offset; in hid_output_field()
1818 unsigned size = field->report_size; in hid_output_field()
1822 if (field->logical_minimum < 0) /* signed values */ in hid_output_field()
1824 s32ton(field->value[n], size)); in hid_output_field()
1827 field->value[n]); in hid_output_field()
1836 if (report->size) in hid_compute_report_size()
1837 return ((report->size - 1) >> 3) + 1; in hid_compute_report_size()
1851 if (report->id > 0) in hid_output_report()
1852 *data++ = report->id; in hid_output_report()
1855 for (n = 0; n < report->maxfield; n++) in hid_output_report()
1856 hid_output_field(report->device, report->field[n], data); in hid_output_report()
1877 * Set a field value. The report this field belongs to has to be
1878 * created and transferred to the device, to set this value in the
1882 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value) in hid_set_field() argument
1887 return -1; in hid_set_field()
1889 size = field->report_size; in hid_set_field()
1891 hid_dump_input(field->report->device, field->usage + offset, value); in hid_set_field()
1893 if (offset >= field->report_count) { in hid_set_field()
1894 hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n", in hid_set_field()
1895 offset, field->report_count); in hid_set_field()
1896 return -1; in hid_set_field()
1898 if (field->logical_minimum < 0) { in hid_set_field()
1899 if (value != snto32(s32ton(value, size), size)) { in hid_set_field()
1900 hid_err(field->report->device, "value %d is out of range\n", value); in hid_set_field()
1901 return -1; in hid_set_field()
1904 field->value[offset] = value; in hid_set_field()
1916 if (report_enum->numbered) in hid_get_report()
1919 report = report_enum->report_id_hash[n]; in hid_get_report()
1939 return -ENOMEM; in __hid_request()
1946 ret = hid->ll_driver->raw_request(hid, report->id, buf, len, in __hid_request()
1947 report->type, reqtype); in __hid_request()
1954 hid_input_report(hid, report->type, buf, ret, 0); in __hid_request()
1967 struct hid_report_enum *report_enum = hid->report_enum + type; in hid_report_raw_event()
1979 if (report_enum->numbered) { in hid_report_raw_event()
1981 csize--; in hid_report_raw_event()
1986 if (hid->ll_driver->max_buffer_size) in hid_report_raw_event()
1987 max_buffer_size = hid->ll_driver->max_buffer_size; in hid_report_raw_event()
1989 if (report_enum->numbered && rsize >= max_buffer_size) in hid_report_raw_event()
1990 rsize = max_buffer_size - 1; in hid_report_raw_event()
1995 dbg_hid("report %d is too short, (%d < %d)\n", report->id, in hid_report_raw_event()
1997 memset(cdata + csize, 0, rsize - csize); in hid_report_raw_event()
2000 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) in hid_report_raw_event()
2001 hid->hiddev_report_event(hid, report); in hid_report_raw_event()
2002 if (hid->claimed & HID_CLAIMED_HIDRAW) { in hid_report_raw_event()
2008 if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) { in hid_report_raw_event()
2010 hdrv = hid->driver; in hid_report_raw_event()
2011 if (hdrv && hdrv->report) in hid_report_raw_event()
2012 hdrv->report(hid, report); in hid_report_raw_event()
2015 if (hid->claimed & HID_CLAIMED_INPUT) in hid_report_raw_event()
2023 * hid_input_report - report data from lower layer (usb, bt...)
2042 return -ENODEV; in hid_input_report()
2044 if (down_trylock(&hid->driver_input_lock)) in hid_input_report()
2045 return -EBUSY; in hid_input_report()
2047 if (!hid->driver) { in hid_input_report()
2048 ret = -ENODEV; in hid_input_report()
2051 report_enum = hid->report_enum + type; in hid_input_report()
2052 hdrv = hid->driver; in hid_input_report()
2062 ret = -1; in hid_input_report()
2067 if (!list_empty(&hid->debug_list)) in hid_input_report()
2073 ret = -1; in hid_input_report()
2077 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) { in hid_input_report()
2078 ret = hdrv->raw_event(hid, report, data, size); in hid_input_report()
2086 up(&hid->driver_input_lock); in hid_input_report()
2094 return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) && in hid_match_one_id()
2095 (id->group == HID_GROUP_ANY || id->group == hdev->group) && in hid_match_one_id()
2096 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) && in hid_match_one_id()
2097 (id->product == HID_ANY_ID || id->product == hdev->product); in hid_match_one_id()
2103 for (; id->bus; id++) in hid_match_id()
2131 if (off >= hdev->rsize) in read_report_descriptor()
2134 if (off + count > hdev->rsize) in read_report_descriptor()
2135 count = hdev->rsize - off; in read_report_descriptor()
2137 memcpy(buf, hdev->rdesc + off, count); in read_report_descriptor()
2148 return sprintf(buf, "%02x\n", hdev->country & 0xff); in show_country()
2166 "Multi-Axis Controller" in hid_connect()
2178 if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE) in hid_connect()
2180 if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE) in hid_connect()
2182 if (hdev->bus != BUS_USB) in hid_connect()
2189 hdev->claimed |= HID_CLAIMED_INPUT; in hid_connect()
2191 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect && in hid_connect()
2192 !hdev->hiddev_connect(hdev, in hid_connect()
2194 hdev->claimed |= HID_CLAIMED_HIDDEV; in hid_connect()
2196 hdev->claimed |= HID_CLAIMED_HIDRAW; in hid_connect()
2199 hdev->claimed |= HID_CLAIMED_DRIVER; in hid_connect()
2201 /* Drivers with the ->raw_event callback set are not required to connect in hid_connect()
2203 if (!hdev->claimed && !hdev->driver->raw_event) { in hid_connect()
2205 return -ENODEV; in hid_connect()
2210 if ((hdev->claimed & HID_CLAIMED_INPUT) && in hid_connect()
2211 (connect_mask & HID_CONNECT_FF) && hdev->ff_init) in hid_connect()
2212 hdev->ff_init(hdev); in hid_connect()
2215 if (hdev->claimed & HID_CLAIMED_INPUT) in hid_connect()
2217 if (hdev->claimed & HID_CLAIMED_HIDDEV) in hid_connect()
2219 ((struct hiddev *)hdev->hiddev)->minor); in hid_connect()
2220 if (hdev->claimed & HID_CLAIMED_HIDRAW) in hid_connect()
2222 ((struct hidraw *)hdev->hidraw)->minor); in hid_connect()
2225 for (i = 0; i < hdev->maxcollection; i++) { in hid_connect()
2226 struct hid_collection *col = &hdev->collection[i]; in hid_connect()
2227 if (col->type == HID_COLLECTION_APPLICATION && in hid_connect()
2228 (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK && in hid_connect()
2229 (col->usage & 0xffff) < ARRAY_SIZE(types)) { in hid_connect()
2230 type = types[col->usage & 0xffff]; in hid_connect()
2235 switch (hdev->bus) { in hid_connect()
2256 ret = device_create_file(&hdev->dev, &dev_attr_country); in hid_connect()
2262 buf, bus, hdev->version >> 8, hdev->version & 0xff, in hid_connect()
2263 type, hdev->name, hdev->phys); in hid_connect()
2271 device_remove_file(&hdev->dev, &dev_attr_country); in hid_disconnect()
2272 if (hdev->claimed & HID_CLAIMED_INPUT) in hid_disconnect()
2274 if (hdev->claimed & HID_CLAIMED_HIDDEV) in hid_disconnect()
2275 hdev->hiddev_disconnect(hdev); in hid_disconnect()
2276 if (hdev->claimed & HID_CLAIMED_HIDRAW) in hid_disconnect()
2278 hdev->claimed = 0; in hid_disconnect()
2285 * hid_hw_start - start underlying HW
2290 * buffers and start the device (if not defeirred to device open).
2297 error = hdev->ll_driver->start(hdev); in hid_hw_start()
2304 hdev->ll_driver->stop(hdev); in hid_hw_start()
2314 * hid_hw_stop - stop underlying HW
2323 hdev->ll_driver->stop(hdev); in hid_hw_stop()
2328 * hid_hw_open - signal underlying HW to start delivering events
2331 * Tell underlying HW to start delivering events from the device.
2339 ret = mutex_lock_killable(&hdev->ll_open_lock); in hid_hw_open()
2343 if (!hdev->ll_open_count++) { in hid_hw_open()
2344 ret = hdev->ll_driver->open(hdev); in hid_hw_open()
2346 hdev->ll_open_count--; in hid_hw_open()
2349 mutex_unlock(&hdev->ll_open_lock); in hid_hw_open()
2355 * hid_hw_close - signal underlaying HW to stop delivering events
2365 mutex_lock(&hdev->ll_open_lock); in hid_hw_close()
2366 if (!--hdev->ll_open_count) in hid_hw_close()
2367 hdev->ll_driver->close(hdev); in hid_hw_close()
2368 mutex_unlock(&hdev->ll_open_lock); in hid_hw_close()
2373 * hid_hw_request - send report request to device
2382 if (hdev->ll_driver->request) in hid_hw_request()
2383 return hdev->ll_driver->request(hdev, report, reqtype); in hid_hw_request()
2390 * hid_hw_raw_request - send report request to device
2409 if (hdev->ll_driver->max_buffer_size) in hid_hw_raw_request()
2410 max_buffer_size = hdev->ll_driver->max_buffer_size; in hid_hw_raw_request()
2413 return -EINVAL; in hid_hw_raw_request()
2415 return hdev->ll_driver->raw_request(hdev, reportnum, buf, len, in hid_hw_raw_request()
2421 * hid_hw_output_report - send output report to device
2433 if (hdev->ll_driver->max_buffer_size) in hid_hw_output_report()
2434 max_buffer_size = hdev->ll_driver->max_buffer_size; in hid_hw_output_report()
2437 return -EINVAL; in hid_hw_output_report()
2439 if (hdev->ll_driver->output_report) in hid_hw_output_report()
2440 return hdev->ll_driver->output_report(hdev, buf, len); in hid_hw_output_report()
2442 return -ENOSYS; in hid_hw_output_report()
2449 if (hdev->driver && hdev->driver->suspend) in hid_driver_suspend()
2450 return hdev->driver->suspend(hdev, state); in hid_driver_suspend()
2458 if (hdev->driver && hdev->driver->reset_resume) in hid_driver_reset_resume()
2459 return hdev->driver->reset_resume(hdev); in hid_driver_reset_resume()
2467 if (hdev->driver && hdev->driver->resume) in hid_driver_resume()
2468 return hdev->driver->resume(hdev); in hid_driver_resume()
2481 * new_id_store - add a new HID device ID to this driver and re-probe devices
2501 return -EINVAL; in new_id_store()
2505 return -ENOMEM; in new_id_store()
2507 dynid->id.bus = bus; in new_id_store()
2508 dynid->id.group = HID_GROUP_ANY; in new_id_store()
2509 dynid->id.vendor = vendor; in new_id_store()
2510 dynid->id.product = product; in new_id_store()
2511 dynid->id.driver_data = driver_data; in new_id_store()
2513 spin_lock(&hdrv->dyn_lock); in new_id_store()
2514 list_add_tail(&dynid->list, &hdrv->dyn_list); in new_id_store()
2515 spin_unlock(&hdrv->dyn_lock); in new_id_store()
2517 ret = driver_attach(&hdrv->driver); in new_id_store()
2533 spin_lock(&hdrv->dyn_lock); in hid_free_dynids()
2534 list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) { in hid_free_dynids()
2535 list_del(&dynid->list); in hid_free_dynids()
2538 spin_unlock(&hdrv->dyn_lock); in hid_free_dynids()
2546 spin_lock(&hdrv->dyn_lock); in hid_match_device()
2547 list_for_each_entry(dynid, &hdrv->dyn_list, list) { in hid_match_device()
2548 if (hid_match_one_id(hdev, &dynid->id)) { in hid_match_device()
2549 spin_unlock(&hdrv->dyn_lock); in hid_match_device()
2550 return &dynid->id; in hid_match_device()
2553 spin_unlock(&hdrv->dyn_lock); in hid_match_device()
2555 return hid_match_id(hdev, hdrv->id_table); in hid_match_device()
2568 * hid_compare_device_paths - check if both devices share the same path
2574 * the separator char. Both paths must exist (i.e., zero-length paths
2580 int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys; in hid_compare_device_paths()
2581 int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys; in hid_compare_device_paths()
2586 return !strncmp(hdev_a->phys, hdev_b->phys, n1); in hid_compare_device_paths()
2598 if (hdrv->match) in hid_check_device_match()
2599 return hdrv->match(hdev, hid_ignore_special_drivers); in hid_check_device_match()
2602 * hid-generic implements .match(), so we must be dealing with a in hid_check_device_match()
2615 return -ENODEV; in __hid_device_probe()
2617 hdev->devres_group_id = devres_open_group(&hdev->dev, NULL, GFP_KERNEL); in __hid_device_probe()
2618 if (!hdev->devres_group_id) in __hid_device_probe()
2619 return -ENOMEM; in __hid_device_probe()
2622 hdev->quirks = hid_lookup_quirk(hdev); in __hid_device_probe()
2623 hdev->driver = hdrv; in __hid_device_probe()
2625 if (hdrv->probe) { in __hid_device_probe()
2626 ret = hdrv->probe(hdev, id); in __hid_device_probe()
2642 devres_release_group(&hdev->dev, hdev->devres_group_id); in __hid_device_probe()
2644 hdev->driver = NULL; in __hid_device_probe()
2653 struct hid_driver *hdrv = to_hid_driver(dev->driver); in hid_device_probe()
2656 if (down_interruptible(&hdev->driver_input_lock)) in hid_device_probe()
2657 return -EINTR; in hid_device_probe()
2659 hdev->io_started = false; in hid_device_probe()
2660 clear_bit(ffs(HID_STAT_REPROBED), &hdev->status); in hid_device_probe()
2662 if (!hdev->driver) in hid_device_probe()
2665 if (!hdev->io_started) in hid_device_probe()
2666 up(&hdev->driver_input_lock); in hid_device_probe()
2676 down(&hdev->driver_input_lock); in hid_device_remove()
2677 hdev->io_started = false; in hid_device_remove()
2679 hdrv = hdev->driver; in hid_device_remove()
2681 if (hdrv->remove) in hid_device_remove()
2682 hdrv->remove(hdev); in hid_device_remove()
2687 devres_release_group(&hdev->dev, hdev->devres_group_id); in hid_device_remove()
2690 hdev->driver = NULL; in hid_device_remove()
2693 if (!hdev->io_started) in hid_device_remove()
2694 up(&hdev->driver_input_lock); in hid_device_remove()
2703 hdev->bus, hdev->group, hdev->vendor, hdev->product); in modalias_show()
2726 hdev->bus, hdev->vendor, hdev->product)) in hid_uevent()
2727 return -ENOMEM; in hid_uevent()
2729 if (add_uevent_var(env, "HID_NAME=%s", hdev->name)) in hid_uevent()
2730 return -ENOMEM; in hid_uevent()
2732 if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys)) in hid_uevent()
2733 return -ENOMEM; in hid_uevent()
2735 if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq)) in hid_uevent()
2736 return -ENOMEM; in hid_uevent()
2739 hdev->bus, hdev->group, hdev->vendor, hdev->product)) in hid_uevent()
2740 return -ENOMEM; in hid_uevent()
2761 if (WARN_ON(hdev->status & HID_STAT_ADDED)) in hid_add_device()
2762 return -EBUSY; in hid_add_device()
2764 hdev->quirks = hid_lookup_quirk(hdev); in hid_add_device()
2769 return -ENODEV; in hid_add_device()
2774 if (!hdev->ll_driver->raw_request) { in hid_add_device()
2776 return -EINVAL; in hid_add_device()
2781 * for the driver-specific modifications. in hid_add_device()
2783 ret = hdev->ll_driver->parse(hdev); in hid_add_device()
2786 if (!hdev->dev_rdesc) in hid_add_device()
2787 return -ENODEV; in hid_add_device()
2793 hdev->group = HID_GROUP_GENERIC; in hid_add_device()
2794 } else if (!hdev->group && in hid_add_device()
2795 !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) { in hid_add_device()
2801 hdev->id = atomic_inc_return(&id); in hid_add_device()
2805 dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus, in hid_add_device()
2806 hdev->vendor, hdev->product, hdev->id); in hid_add_device()
2808 hid_debug_register(hdev, dev_name(&hdev->dev)); in hid_add_device()
2809 ret = device_add(&hdev->dev); in hid_add_device()
2811 hdev->status |= HID_STAT_ADDED; in hid_add_device()
2820 * hid_allocate_device - allocate new hid device descriptor
2826 * error value.
2831 int ret = -ENOMEM; in hid_allocate_device()
2837 device_initialize(&hdev->dev); in hid_allocate_device()
2838 hdev->dev.release = hid_device_release; in hid_allocate_device()
2839 hdev->dev.bus = &hid_bus_type; in hid_allocate_device()
2840 device_enable_async_suspend(&hdev->dev); in hid_allocate_device()
2844 init_waitqueue_head(&hdev->debug_wait); in hid_allocate_device()
2845 INIT_LIST_HEAD(&hdev->debug_list); in hid_allocate_device()
2846 spin_lock_init(&hdev->debug_list_lock); in hid_allocate_device()
2847 sema_init(&hdev->driver_input_lock, 1); in hid_allocate_device()
2848 mutex_init(&hdev->ll_open_lock); in hid_allocate_device()
2858 if (hdev->status & HID_STAT_ADDED) { in hid_remove_device()
2859 device_del(&hdev->dev); in hid_remove_device()
2861 hdev->status &= ~HID_STAT_ADDED; in hid_remove_device()
2863 kfree(hdev->dev_rdesc); in hid_remove_device()
2864 hdev->dev_rdesc = NULL; in hid_remove_device()
2865 hdev->dev_rsize = 0; in hid_remove_device()
2869 * hid_destroy_device - free previously allocated device
2880 put_device(&hdev->dev); in hid_destroy_device()
2890 if (hdev->driver == hdrv && in __hid_bus_reprobe_drivers()
2891 !hdrv->match(hdev, hid_ignore_special_drivers) && in __hid_bus_reprobe_drivers()
2892 !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status)) in __hid_bus_reprobe_drivers()
2902 if (hdrv->match) { in __hid_bus_driver_added()
2920 hdrv->driver.name = hdrv->name; in __hid_register_driver()
2921 hdrv->driver.bus = &hid_bus_type; in __hid_register_driver()
2922 hdrv->driver.owner = owner; in __hid_register_driver()
2923 hdrv->driver.mod_name = mod_name; in __hid_register_driver()
2925 INIT_LIST_HEAD(&hdrv->dyn_list); in __hid_register_driver()
2926 spin_lock_init(&hdrv->dyn_lock); in __hid_register_driver()
2928 ret = driver_register(&hdrv->driver); in __hid_register_driver()
2940 driver_unregister(&hdrv->driver); in hid_unregister_driver()
2952 if (!(hid->claimed & HID_CLAIMED_INPUT)) in hid_check_keys_pressed()
2955 list_for_each_entry(hidinput, &hid->inputs, list) { in hid_check_keys_pressed()
2957 if (hidinput->input->key[i]) in hid_check_keys_pressed()