xref: /linux/drivers/hid/hid-core.c (revision 442bc81bd344dc52c37d8f80b854cc6da062b2d0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  HID support for Linux
4  *
5  *  Copyright (c) 1999 Andreas Gal
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
9  */
10 
11 /*
12  */
13 
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/kernel.h>
20 #include <linux/list.h>
21 #include <linux/mm.h>
22 #include <linux/spinlock.h>
23 #include <linux/unaligned.h>
24 #include <asm/byteorder.h>
25 #include <linux/input.h>
26 #include <linux/wait.h>
27 #include <linux/vmalloc.h>
28 #include <linux/sched.h>
29 #include <linux/semaphore.h>
30 
31 #include <linux/hid.h>
32 #include <linux/hiddev.h>
33 #include <linux/hid-debug.h>
34 #include <linux/hidraw.h>
35 
36 #include "hid-ids.h"
37 
38 /*
39  * Version Information
40  */
41 
42 #define DRIVER_DESC "HID core driver"
43 
44 static int hid_ignore_special_drivers = 0;
45 module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
46 MODULE_PARM_DESC(ignore_special_drivers, "Ignore any special drivers and handle all devices by generic driver");
47 
48 /*
49  * Convert a signed n-bit integer to signed 32-bit integer.
50  */
51 
snto32(__u32 value,unsigned int n)52 static s32 snto32(__u32 value, unsigned int n)
53 {
54 	if (!value || !n)
55 		return 0;
56 
57 	if (n > 32)
58 		n = 32;
59 
60 	return sign_extend32(value, n - 1);
61 }
62 
63 /*
64  * Convert a signed 32-bit integer to a signed n-bit integer.
65  */
66 
s32ton(__s32 value,unsigned int n)67 static u32 s32ton(__s32 value, unsigned int n)
68 {
69 	s32 a = value >> (n - 1);
70 
71 	if (a && a != -1)
72 		return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
73 	return value & ((1 << n) - 1);
74 }
75 
76 /*
77  * Register a new report for a device.
78  */
79 
hid_register_report(struct hid_device * device,enum hid_report_type type,unsigned int id,unsigned int application)80 struct hid_report *hid_register_report(struct hid_device *device,
81 				       enum hid_report_type type, unsigned int id,
82 				       unsigned int application)
83 {
84 	struct hid_report_enum *report_enum = device->report_enum + type;
85 	struct hid_report *report;
86 
87 	if (id >= HID_MAX_IDS)
88 		return NULL;
89 	if (report_enum->report_id_hash[id])
90 		return report_enum->report_id_hash[id];
91 
92 	report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
93 	if (!report)
94 		return NULL;
95 
96 	if (id != 0)
97 		report_enum->numbered = 1;
98 
99 	report->id = id;
100 	report->type = type;
101 	report->size = 0;
102 	report->device = device;
103 	report->application = application;
104 	report_enum->report_id_hash[id] = report;
105 
106 	list_add_tail(&report->list, &report_enum->report_list);
107 	INIT_LIST_HEAD(&report->field_entry_list);
108 
109 	return report;
110 }
111 EXPORT_SYMBOL_GPL(hid_register_report);
112 
113 /*
114  * Register a new field for this report.
115  */
116 
hid_register_field(struct hid_report * report,unsigned usages)117 static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages)
118 {
119 	struct hid_field *field;
120 
121 	if (report->maxfield == HID_MAX_FIELDS) {
122 		hid_err(report->device, "too many fields in report\n");
123 		return NULL;
124 	}
125 
126 	field = kvzalloc((sizeof(struct hid_field) +
127 			  usages * sizeof(struct hid_usage) +
128 			  3 * usages * sizeof(unsigned int)), GFP_KERNEL);
129 	if (!field)
130 		return NULL;
131 
132 	field->index = report->maxfield++;
133 	report->field[field->index] = field;
134 	field->usage = (struct hid_usage *)(field + 1);
135 	field->value = (s32 *)(field->usage + usages);
136 	field->new_value = (s32 *)(field->value + usages);
137 	field->usages_priorities = (s32 *)(field->new_value + usages);
138 	field->report = report;
139 
140 	return field;
141 }
142 
143 /*
144  * Open a collection. The type/usage is pushed on the stack.
145  */
146 
open_collection(struct hid_parser * parser,unsigned type)147 static int open_collection(struct hid_parser *parser, unsigned type)
148 {
149 	struct hid_collection *collection;
150 	unsigned usage;
151 	int collection_index;
152 
153 	usage = parser->local.usage[0];
154 
155 	if (parser->collection_stack_ptr == parser->collection_stack_size) {
156 		unsigned int *collection_stack;
157 		unsigned int new_size = parser->collection_stack_size +
158 					HID_COLLECTION_STACK_SIZE;
159 
160 		collection_stack = krealloc(parser->collection_stack,
161 					    new_size * sizeof(unsigned int),
162 					    GFP_KERNEL);
163 		if (!collection_stack)
164 			return -ENOMEM;
165 
166 		parser->collection_stack = collection_stack;
167 		parser->collection_stack_size = new_size;
168 	}
169 
170 	if (parser->device->maxcollection == parser->device->collection_size) {
171 		collection = kmalloc(
172 				array3_size(sizeof(struct hid_collection),
173 					    parser->device->collection_size,
174 					    2),
175 				GFP_KERNEL);
176 		if (collection == NULL) {
177 			hid_err(parser->device, "failed to reallocate collection array\n");
178 			return -ENOMEM;
179 		}
180 		memcpy(collection, parser->device->collection,
181 			sizeof(struct hid_collection) *
182 			parser->device->collection_size);
183 		memset(collection + parser->device->collection_size, 0,
184 			sizeof(struct hid_collection) *
185 			parser->device->collection_size);
186 		kfree(parser->device->collection);
187 		parser->device->collection = collection;
188 		parser->device->collection_size *= 2;
189 	}
190 
191 	parser->collection_stack[parser->collection_stack_ptr++] =
192 		parser->device->maxcollection;
193 
194 	collection_index = parser->device->maxcollection++;
195 	collection = parser->device->collection + collection_index;
196 	collection->type = type;
197 	collection->usage = usage;
198 	collection->level = parser->collection_stack_ptr - 1;
199 	collection->parent_idx = (collection->level == 0) ? -1 :
200 		parser->collection_stack[collection->level - 1];
201 
202 	if (type == HID_COLLECTION_APPLICATION)
203 		parser->device->maxapplication++;
204 
205 	return 0;
206 }
207 
208 /*
209  * Close a collection.
210  */
211 
close_collection(struct hid_parser * parser)212 static int close_collection(struct hid_parser *parser)
213 {
214 	if (!parser->collection_stack_ptr) {
215 		hid_err(parser->device, "collection stack underflow\n");
216 		return -EINVAL;
217 	}
218 	parser->collection_stack_ptr--;
219 	return 0;
220 }
221 
222 /*
223  * Climb up the stack, search for the specified collection type
224  * and return the usage.
225  */
226 
hid_lookup_collection(struct hid_parser * parser,unsigned type)227 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
228 {
229 	struct hid_collection *collection = parser->device->collection;
230 	int n;
231 
232 	for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
233 		unsigned index = parser->collection_stack[n];
234 		if (collection[index].type == type)
235 			return collection[index].usage;
236 	}
237 	return 0; /* we know nothing about this usage type */
238 }
239 
240 /*
241  * Concatenate usage which defines 16 bits or less with the
242  * currently defined usage page to form a 32 bit usage
243  */
244 
complete_usage(struct hid_parser * parser,unsigned int index)245 static void complete_usage(struct hid_parser *parser, unsigned int index)
246 {
247 	parser->local.usage[index] &= 0xFFFF;
248 	parser->local.usage[index] |=
249 		(parser->global.usage_page & 0xFFFF) << 16;
250 }
251 
252 /*
253  * Add a usage to the temporary parser table.
254  */
255 
hid_add_usage(struct hid_parser * parser,unsigned usage,u8 size)256 static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
257 {
258 	if (parser->local.usage_index >= HID_MAX_USAGES) {
259 		hid_err(parser->device, "usage index exceeded\n");
260 		return -1;
261 	}
262 	parser->local.usage[parser->local.usage_index] = usage;
263 
264 	/*
265 	 * If Usage item only includes usage id, concatenate it with
266 	 * currently defined usage page
267 	 */
268 	if (size <= 2)
269 		complete_usage(parser, parser->local.usage_index);
270 
271 	parser->local.usage_size[parser->local.usage_index] = size;
272 	parser->local.collection_index[parser->local.usage_index] =
273 		parser->collection_stack_ptr ?
274 		parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
275 	parser->local.usage_index++;
276 	return 0;
277 }
278 
279 /*
280  * Register a new field for this report.
281  */
282 
hid_add_field(struct hid_parser * parser,unsigned report_type,unsigned flags)283 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
284 {
285 	struct hid_report *report;
286 	struct hid_field *field;
287 	unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;
288 	unsigned int usages;
289 	unsigned int offset;
290 	unsigned int i;
291 	unsigned int application;
292 
293 	application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
294 
295 	report = hid_register_report(parser->device, report_type,
296 				     parser->global.report_id, application);
297 	if (!report) {
298 		hid_err(parser->device, "hid_register_report failed\n");
299 		return -1;
300 	}
301 
302 	/* Handle both signed and unsigned cases properly */
303 	if ((parser->global.logical_minimum < 0 &&
304 		parser->global.logical_maximum <
305 		parser->global.logical_minimum) ||
306 		(parser->global.logical_minimum >= 0 &&
307 		(__u32)parser->global.logical_maximum <
308 		(__u32)parser->global.logical_minimum)) {
309 		dbg_hid("logical range invalid 0x%x 0x%x\n",
310 			parser->global.logical_minimum,
311 			parser->global.logical_maximum);
312 		return -1;
313 	}
314 
315 	offset = report->size;
316 	report->size += parser->global.report_size * parser->global.report_count;
317 
318 	if (parser->device->ll_driver->max_buffer_size)
319 		max_buffer_size = parser->device->ll_driver->max_buffer_size;
320 
321 	/* Total size check: Allow for possible report index byte */
322 	if (report->size > (max_buffer_size - 1) << 3) {
323 		hid_err(parser->device, "report is too long\n");
324 		return -1;
325 	}
326 
327 	if (!parser->local.usage_index) /* Ignore padding fields */
328 		return 0;
329 
330 	usages = max_t(unsigned, parser->local.usage_index,
331 				 parser->global.report_count);
332 
333 	field = hid_register_field(report, usages);
334 	if (!field)
335 		return 0;
336 
337 	field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
338 	field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
339 	field->application = application;
340 
341 	for (i = 0; i < usages; i++) {
342 		unsigned j = i;
343 		/* Duplicate the last usage we parsed if we have excess values */
344 		if (i >= parser->local.usage_index)
345 			j = parser->local.usage_index - 1;
346 		field->usage[i].hid = parser->local.usage[j];
347 		field->usage[i].collection_index =
348 			parser->local.collection_index[j];
349 		field->usage[i].usage_index = i;
350 		field->usage[i].resolution_multiplier = 1;
351 	}
352 
353 	field->maxusage = usages;
354 	field->flags = flags;
355 	field->report_offset = offset;
356 	field->report_type = report_type;
357 	field->report_size = parser->global.report_size;
358 	field->report_count = parser->global.report_count;
359 	field->logical_minimum = parser->global.logical_minimum;
360 	field->logical_maximum = parser->global.logical_maximum;
361 	field->physical_minimum = parser->global.physical_minimum;
362 	field->physical_maximum = parser->global.physical_maximum;
363 	field->unit_exponent = parser->global.unit_exponent;
364 	field->unit = parser->global.unit;
365 
366 	return 0;
367 }
368 
369 /*
370  * Read data value from item.
371  */
372 
item_udata(struct hid_item * item)373 static u32 item_udata(struct hid_item *item)
374 {
375 	switch (item->size) {
376 	case 1: return item->data.u8;
377 	case 2: return item->data.u16;
378 	case 4: return item->data.u32;
379 	}
380 	return 0;
381 }
382 
item_sdata(struct hid_item * item)383 static s32 item_sdata(struct hid_item *item)
384 {
385 	switch (item->size) {
386 	case 1: return item->data.s8;
387 	case 2: return item->data.s16;
388 	case 4: return item->data.s32;
389 	}
390 	return 0;
391 }
392 
393 /*
394  * Process a global item.
395  */
396 
hid_parser_global(struct hid_parser * parser,struct hid_item * item)397 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
398 {
399 	__s32 raw_value;
400 	switch (item->tag) {
401 	case HID_GLOBAL_ITEM_TAG_PUSH:
402 
403 		if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
404 			hid_err(parser->device, "global environment stack overflow\n");
405 			return -1;
406 		}
407 
408 		memcpy(parser->global_stack + parser->global_stack_ptr++,
409 			&parser->global, sizeof(struct hid_global));
410 		return 0;
411 
412 	case HID_GLOBAL_ITEM_TAG_POP:
413 
414 		if (!parser->global_stack_ptr) {
415 			hid_err(parser->device, "global environment stack underflow\n");
416 			return -1;
417 		}
418 
419 		memcpy(&parser->global, parser->global_stack +
420 			--parser->global_stack_ptr, sizeof(struct hid_global));
421 		return 0;
422 
423 	case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
424 		parser->global.usage_page = item_udata(item);
425 		return 0;
426 
427 	case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
428 		parser->global.logical_minimum = item_sdata(item);
429 		return 0;
430 
431 	case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
432 		if (parser->global.logical_minimum < 0)
433 			parser->global.logical_maximum = item_sdata(item);
434 		else
435 			parser->global.logical_maximum = item_udata(item);
436 		return 0;
437 
438 	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
439 		parser->global.physical_minimum = item_sdata(item);
440 		return 0;
441 
442 	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
443 		if (parser->global.physical_minimum < 0)
444 			parser->global.physical_maximum = item_sdata(item);
445 		else
446 			parser->global.physical_maximum = item_udata(item);
447 		return 0;
448 
449 	case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
450 		/* Many devices provide unit exponent as a two's complement
451 		 * nibble due to the common misunderstanding of HID
452 		 * specification 1.11, 6.2.2.7 Global Items. Attempt to handle
453 		 * both this and the standard encoding. */
454 		raw_value = item_sdata(item);
455 		if (!(raw_value & 0xfffffff0))
456 			parser->global.unit_exponent = snto32(raw_value, 4);
457 		else
458 			parser->global.unit_exponent = raw_value;
459 		return 0;
460 
461 	case HID_GLOBAL_ITEM_TAG_UNIT:
462 		parser->global.unit = item_udata(item);
463 		return 0;
464 
465 	case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
466 		parser->global.report_size = item_udata(item);
467 		if (parser->global.report_size > 256) {
468 			hid_err(parser->device, "invalid report_size %d\n",
469 					parser->global.report_size);
470 			return -1;
471 		}
472 		return 0;
473 
474 	case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
475 		parser->global.report_count = item_udata(item);
476 		if (parser->global.report_count > HID_MAX_USAGES) {
477 			hid_err(parser->device, "invalid report_count %d\n",
478 					parser->global.report_count);
479 			return -1;
480 		}
481 		return 0;
482 
483 	case HID_GLOBAL_ITEM_TAG_REPORT_ID:
484 		parser->global.report_id = item_udata(item);
485 		if (parser->global.report_id == 0 ||
486 		    parser->global.report_id >= HID_MAX_IDS) {
487 			hid_err(parser->device, "report_id %u is invalid\n",
488 				parser->global.report_id);
489 			return -1;
490 		}
491 		return 0;
492 
493 	default:
494 		hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
495 		return -1;
496 	}
497 }
498 
499 /*
500  * Process a local item.
501  */
502 
hid_parser_local(struct hid_parser * parser,struct hid_item * item)503 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
504 {
505 	__u32 data;
506 	unsigned n;
507 	__u32 count;
508 
509 	data = item_udata(item);
510 
511 	switch (item->tag) {
512 	case HID_LOCAL_ITEM_TAG_DELIMITER:
513 
514 		if (data) {
515 			/*
516 			 * We treat items before the first delimiter
517 			 * as global to all usage sets (branch 0).
518 			 * In the moment we process only these global
519 			 * items and the first delimiter set.
520 			 */
521 			if (parser->local.delimiter_depth != 0) {
522 				hid_err(parser->device, "nested delimiters\n");
523 				return -1;
524 			}
525 			parser->local.delimiter_depth++;
526 			parser->local.delimiter_branch++;
527 		} else {
528 			if (parser->local.delimiter_depth < 1) {
529 				hid_err(parser->device, "bogus close delimiter\n");
530 				return -1;
531 			}
532 			parser->local.delimiter_depth--;
533 		}
534 		return 0;
535 
536 	case HID_LOCAL_ITEM_TAG_USAGE:
537 
538 		if (parser->local.delimiter_branch > 1) {
539 			dbg_hid("alternative usage ignored\n");
540 			return 0;
541 		}
542 
543 		return hid_add_usage(parser, data, item->size);
544 
545 	case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
546 
547 		if (parser->local.delimiter_branch > 1) {
548 			dbg_hid("alternative usage ignored\n");
549 			return 0;
550 		}
551 
552 		parser->local.usage_minimum = data;
553 		return 0;
554 
555 	case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
556 
557 		if (parser->local.delimiter_branch > 1) {
558 			dbg_hid("alternative usage ignored\n");
559 			return 0;
560 		}
561 
562 		count = data - parser->local.usage_minimum;
563 		if (count + parser->local.usage_index >= HID_MAX_USAGES) {
564 			/*
565 			 * We do not warn if the name is not set, we are
566 			 * actually pre-scanning the device.
567 			 */
568 			if (dev_name(&parser->device->dev))
569 				hid_warn(parser->device,
570 					 "ignoring exceeding usage max\n");
571 			data = HID_MAX_USAGES - parser->local.usage_index +
572 				parser->local.usage_minimum - 1;
573 			if (data <= 0) {
574 				hid_err(parser->device,
575 					"no more usage index available\n");
576 				return -1;
577 			}
578 		}
579 
580 		for (n = parser->local.usage_minimum; n <= data; n++)
581 			if (hid_add_usage(parser, n, item->size)) {
582 				dbg_hid("hid_add_usage failed\n");
583 				return -1;
584 			}
585 		return 0;
586 
587 	default:
588 
589 		dbg_hid("unknown local item tag 0x%x\n", item->tag);
590 		return 0;
591 	}
592 	return 0;
593 }
594 
595 /*
596  * Concatenate Usage Pages into Usages where relevant:
597  * As per specification, 6.2.2.8: "When the parser encounters a main item it
598  * concatenates the last declared Usage Page with a Usage to form a complete
599  * usage value."
600  */
601 
hid_concatenate_last_usage_page(struct hid_parser * parser)602 static void hid_concatenate_last_usage_page(struct hid_parser *parser)
603 {
604 	int i;
605 	unsigned int usage_page;
606 	unsigned int current_page;
607 
608 	if (!parser->local.usage_index)
609 		return;
610 
611 	usage_page = parser->global.usage_page;
612 
613 	/*
614 	 * Concatenate usage page again only if last declared Usage Page
615 	 * has not been already used in previous usages concatenation
616 	 */
617 	for (i = parser->local.usage_index - 1; i >= 0; i--) {
618 		if (parser->local.usage_size[i] > 2)
619 			/* Ignore extended usages */
620 			continue;
621 
622 		current_page = parser->local.usage[i] >> 16;
623 		if (current_page == usage_page)
624 			break;
625 
626 		complete_usage(parser, i);
627 	}
628 }
629 
630 /*
631  * Process a main item.
632  */
633 
hid_parser_main(struct hid_parser * parser,struct hid_item * item)634 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
635 {
636 	__u32 data;
637 	int ret;
638 
639 	hid_concatenate_last_usage_page(parser);
640 
641 	data = item_udata(item);
642 
643 	switch (item->tag) {
644 	case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
645 		ret = open_collection(parser, data & 0xff);
646 		break;
647 	case HID_MAIN_ITEM_TAG_END_COLLECTION:
648 		ret = close_collection(parser);
649 		break;
650 	case HID_MAIN_ITEM_TAG_INPUT:
651 		ret = hid_add_field(parser, HID_INPUT_REPORT, data);
652 		break;
653 	case HID_MAIN_ITEM_TAG_OUTPUT:
654 		ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
655 		break;
656 	case HID_MAIN_ITEM_TAG_FEATURE:
657 		ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
658 		break;
659 	default:
660 		hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag);
661 		ret = 0;
662 	}
663 
664 	memset(&parser->local, 0, sizeof(parser->local));	/* Reset the local parser environment */
665 
666 	return ret;
667 }
668 
669 /*
670  * Process a reserved item.
671  */
672 
hid_parser_reserved(struct hid_parser * parser,struct hid_item * item)673 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
674 {
675 	dbg_hid("reserved item type, tag 0x%x\n", item->tag);
676 	return 0;
677 }
678 
679 /*
680  * Free a report and all registered fields. The field->usage and
681  * field->value table's are allocated behind the field, so we need
682  * only to free(field) itself.
683  */
684 
hid_free_report(struct hid_report * report)685 static void hid_free_report(struct hid_report *report)
686 {
687 	unsigned n;
688 
689 	kfree(report->field_entries);
690 
691 	for (n = 0; n < report->maxfield; n++)
692 		kvfree(report->field[n]);
693 	kfree(report);
694 }
695 
696 /*
697  * Close report. This function returns the device
698  * state to the point prior to hid_open_report().
699  */
hid_close_report(struct hid_device * device)700 static void hid_close_report(struct hid_device *device)
701 {
702 	unsigned i, j;
703 
704 	for (i = 0; i < HID_REPORT_TYPES; i++) {
705 		struct hid_report_enum *report_enum = device->report_enum + i;
706 
707 		for (j = 0; j < HID_MAX_IDS; j++) {
708 			struct hid_report *report = report_enum->report_id_hash[j];
709 			if (report)
710 				hid_free_report(report);
711 		}
712 		memset(report_enum, 0, sizeof(*report_enum));
713 		INIT_LIST_HEAD(&report_enum->report_list);
714 	}
715 
716 	/*
717 	 * If the HID driver had a rdesc_fixup() callback, dev->rdesc
718 	 * will be allocated by hid-core and needs to be freed.
719 	 * Otherwise, it is either equal to dev_rdesc or bpf_rdesc, in
720 	 * which cases it'll be freed later on device removal or destroy.
721 	 */
722 	if (device->rdesc != device->dev_rdesc && device->rdesc != device->bpf_rdesc)
723 		kfree(device->rdesc);
724 	device->rdesc = NULL;
725 	device->rsize = 0;
726 
727 	kfree(device->collection);
728 	device->collection = NULL;
729 	device->collection_size = 0;
730 	device->maxcollection = 0;
731 	device->maxapplication = 0;
732 
733 	device->status &= ~HID_STAT_PARSED;
734 }
735 
hid_free_bpf_rdesc(struct hid_device * hdev)736 static inline void hid_free_bpf_rdesc(struct hid_device *hdev)
737 {
738 	/* bpf_rdesc is either equal to dev_rdesc or allocated by call_hid_bpf_rdesc_fixup() */
739 	if (hdev->bpf_rdesc != hdev->dev_rdesc)
740 		kfree(hdev->bpf_rdesc);
741 	hdev->bpf_rdesc = NULL;
742 }
743 
744 /*
745  * Free a device structure, all reports, and all fields.
746  */
747 
hiddev_free(struct kref * ref)748 void hiddev_free(struct kref *ref)
749 {
750 	struct hid_device *hid = container_of(ref, struct hid_device, ref);
751 
752 	hid_close_report(hid);
753 	hid_free_bpf_rdesc(hid);
754 	kfree(hid->dev_rdesc);
755 	kfree(hid);
756 }
757 
hid_device_release(struct device * dev)758 static void hid_device_release(struct device *dev)
759 {
760 	struct hid_device *hid = to_hid_device(dev);
761 
762 	kref_put(&hid->ref, hiddev_free);
763 }
764 
765 /*
766  * Fetch a report description item from the data stream. We support long
767  * items, though they are not used yet.
768  */
769 
fetch_item(const __u8 * start,const __u8 * end,struct hid_item * item)770 static const u8 *fetch_item(const __u8 *start, const __u8 *end, struct hid_item *item)
771 {
772 	u8 b;
773 
774 	if ((end - start) <= 0)
775 		return NULL;
776 
777 	b = *start++;
778 
779 	item->type = (b >> 2) & 3;
780 	item->tag  = (b >> 4) & 15;
781 
782 	if (item->tag == HID_ITEM_TAG_LONG) {
783 
784 		item->format = HID_ITEM_FORMAT_LONG;
785 
786 		if ((end - start) < 2)
787 			return NULL;
788 
789 		item->size = *start++;
790 		item->tag  = *start++;
791 
792 		if ((end - start) < item->size)
793 			return NULL;
794 
795 		item->data.longdata = start;
796 		start += item->size;
797 		return start;
798 	}
799 
800 	item->format = HID_ITEM_FORMAT_SHORT;
801 	item->size = BIT(b & 3) >> 1; /* 0, 1, 2, 3 -> 0, 1, 2, 4 */
802 
803 	if (end - start < item->size)
804 		return NULL;
805 
806 	switch (item->size) {
807 	case 0:
808 		break;
809 
810 	case 1:
811 		item->data.u8 = *start;
812 		break;
813 
814 	case 2:
815 		item->data.u16 = get_unaligned_le16(start);
816 		break;
817 
818 	case 4:
819 		item->data.u32 = get_unaligned_le32(start);
820 		break;
821 	}
822 
823 	return start + item->size;
824 }
825 
hid_scan_input_usage(struct hid_parser * parser,u32 usage)826 static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
827 {
828 	struct hid_device *hid = parser->device;
829 
830 	if (usage == HID_DG_CONTACTID)
831 		hid->group = HID_GROUP_MULTITOUCH;
832 }
833 
hid_scan_feature_usage(struct hid_parser * parser,u32 usage)834 static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
835 {
836 	if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
837 	    parser->global.report_size == 8)
838 		parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
839 
840 	if (usage == 0xff0000c6 && parser->global.report_count == 1 &&
841 	    parser->global.report_size == 8)
842 		parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
843 }
844 
hid_scan_collection(struct hid_parser * parser,unsigned type)845 static void hid_scan_collection(struct hid_parser *parser, unsigned type)
846 {
847 	struct hid_device *hid = parser->device;
848 	int i;
849 
850 	if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
851 	    (type == HID_COLLECTION_PHYSICAL ||
852 	     type == HID_COLLECTION_APPLICATION))
853 		hid->group = HID_GROUP_SENSOR_HUB;
854 
855 	if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
856 	    hid->product == USB_DEVICE_ID_MS_POWER_COVER &&
857 	    hid->group == HID_GROUP_MULTITOUCH)
858 		hid->group = HID_GROUP_GENERIC;
859 
860 	if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
861 		for (i = 0; i < parser->local.usage_index; i++)
862 			if (parser->local.usage[i] == HID_GD_POINTER)
863 				parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
864 
865 	if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
866 		parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
867 
868 	if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR)
869 		for (i = 0; i < parser->local.usage_index; i++)
870 			if (parser->local.usage[i] ==
871 					(HID_UP_GOOGLEVENDOR | 0x0001))
872 				parser->device->group =
873 					HID_GROUP_VIVALDI;
874 }
875 
hid_scan_main(struct hid_parser * parser,struct hid_item * item)876 static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
877 {
878 	__u32 data;
879 	int i;
880 
881 	hid_concatenate_last_usage_page(parser);
882 
883 	data = item_udata(item);
884 
885 	switch (item->tag) {
886 	case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
887 		hid_scan_collection(parser, data & 0xff);
888 		break;
889 	case HID_MAIN_ITEM_TAG_END_COLLECTION:
890 		break;
891 	case HID_MAIN_ITEM_TAG_INPUT:
892 		/* ignore constant inputs, they will be ignored by hid-input */
893 		if (data & HID_MAIN_ITEM_CONSTANT)
894 			break;
895 		for (i = 0; i < parser->local.usage_index; i++)
896 			hid_scan_input_usage(parser, parser->local.usage[i]);
897 		break;
898 	case HID_MAIN_ITEM_TAG_OUTPUT:
899 		break;
900 	case HID_MAIN_ITEM_TAG_FEATURE:
901 		for (i = 0; i < parser->local.usage_index; i++)
902 			hid_scan_feature_usage(parser, parser->local.usage[i]);
903 		break;
904 	}
905 
906 	/* Reset the local parser environment */
907 	memset(&parser->local, 0, sizeof(parser->local));
908 
909 	return 0;
910 }
911 
912 /*
913  * Scan a report descriptor before the device is added to the bus.
914  * Sets device groups and other properties that determine what driver
915  * to load.
916  */
hid_scan_report(struct hid_device * hid)917 static int hid_scan_report(struct hid_device *hid)
918 {
919 	struct hid_parser *parser;
920 	struct hid_item item;
921 	const __u8 *start = hid->dev_rdesc;
922 	const __u8 *end = start + hid->dev_rsize;
923 	static int (*dispatch_type[])(struct hid_parser *parser,
924 				      struct hid_item *item) = {
925 		hid_scan_main,
926 		hid_parser_global,
927 		hid_parser_local,
928 		hid_parser_reserved
929 	};
930 
931 	parser = vzalloc(sizeof(struct hid_parser));
932 	if (!parser)
933 		return -ENOMEM;
934 
935 	parser->device = hid;
936 	hid->group = HID_GROUP_GENERIC;
937 
938 	/*
939 	 * The parsing is simpler than the one in hid_open_report() as we should
940 	 * be robust against hid errors. Those errors will be raised by
941 	 * hid_open_report() anyway.
942 	 */
943 	while ((start = fetch_item(start, end, &item)) != NULL)
944 		dispatch_type[item.type](parser, &item);
945 
946 	/*
947 	 * Handle special flags set during scanning.
948 	 */
949 	if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
950 	    (hid->group == HID_GROUP_MULTITOUCH))
951 		hid->group = HID_GROUP_MULTITOUCH_WIN_8;
952 
953 	/*
954 	 * Vendor specific handlings
955 	 */
956 	switch (hid->vendor) {
957 	case USB_VENDOR_ID_WACOM:
958 		hid->group = HID_GROUP_WACOM;
959 		break;
960 	case USB_VENDOR_ID_SYNAPTICS:
961 		if (hid->group == HID_GROUP_GENERIC)
962 			if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
963 			    && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
964 				/*
965 				 * hid-rmi should take care of them,
966 				 * not hid-generic
967 				 */
968 				hid->group = HID_GROUP_RMI;
969 		break;
970 	}
971 
972 	kfree(parser->collection_stack);
973 	vfree(parser);
974 	return 0;
975 }
976 
977 /**
978  * hid_parse_report - parse device report
979  *
980  * @hid: hid device
981  * @start: report start
982  * @size: report size
983  *
984  * Allocate the device report as read by the bus driver. This function should
985  * only be called from parse() in ll drivers.
986  */
hid_parse_report(struct hid_device * hid,const __u8 * start,unsigned size)987 int hid_parse_report(struct hid_device *hid, const __u8 *start, unsigned size)
988 {
989 	hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
990 	if (!hid->dev_rdesc)
991 		return -ENOMEM;
992 	hid->dev_rsize = size;
993 	return 0;
994 }
995 EXPORT_SYMBOL_GPL(hid_parse_report);
996 
997 static const char * const hid_report_names[] = {
998 	"HID_INPUT_REPORT",
999 	"HID_OUTPUT_REPORT",
1000 	"HID_FEATURE_REPORT",
1001 };
1002 /**
1003  * hid_validate_values - validate existing device report's value indexes
1004  *
1005  * @hid: hid device
1006  * @type: which report type to examine
1007  * @id: which report ID to examine (0 for first)
1008  * @field_index: which report field to examine
1009  * @report_counts: expected number of values
1010  *
1011  * Validate the number of values in a given field of a given report, after
1012  * parsing.
1013  */
hid_validate_values(struct hid_device * hid,enum hid_report_type type,unsigned int id,unsigned int field_index,unsigned int report_counts)1014 struct hid_report *hid_validate_values(struct hid_device *hid,
1015 				       enum hid_report_type type, unsigned int id,
1016 				       unsigned int field_index,
1017 				       unsigned int report_counts)
1018 {
1019 	struct hid_report *report;
1020 
1021 	if (type > HID_FEATURE_REPORT) {
1022 		hid_err(hid, "invalid HID report type %u\n", type);
1023 		return NULL;
1024 	}
1025 
1026 	if (id >= HID_MAX_IDS) {
1027 		hid_err(hid, "invalid HID report id %u\n", id);
1028 		return NULL;
1029 	}
1030 
1031 	/*
1032 	 * Explicitly not using hid_get_report() here since it depends on
1033 	 * ->numbered being checked, which may not always be the case when
1034 	 * drivers go to access report values.
1035 	 */
1036 	if (id == 0) {
1037 		/*
1038 		 * Validating on id 0 means we should examine the first
1039 		 * report in the list.
1040 		 */
1041 		report = list_first_entry_or_null(
1042 				&hid->report_enum[type].report_list,
1043 				struct hid_report, list);
1044 	} else {
1045 		report = hid->report_enum[type].report_id_hash[id];
1046 	}
1047 	if (!report) {
1048 		hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
1049 		return NULL;
1050 	}
1051 	if (report->maxfield <= field_index) {
1052 		hid_err(hid, "not enough fields in %s %u\n",
1053 			hid_report_names[type], id);
1054 		return NULL;
1055 	}
1056 	if (report->field[field_index]->report_count < report_counts) {
1057 		hid_err(hid, "not enough values in %s %u field %u\n",
1058 			hid_report_names[type], id, field_index);
1059 		return NULL;
1060 	}
1061 	return report;
1062 }
1063 EXPORT_SYMBOL_GPL(hid_validate_values);
1064 
hid_calculate_multiplier(struct hid_device * hid,struct hid_field * multiplier)1065 static int hid_calculate_multiplier(struct hid_device *hid,
1066 				     struct hid_field *multiplier)
1067 {
1068 	int m;
1069 	__s32 v = *multiplier->value;
1070 	__s32 lmin = multiplier->logical_minimum;
1071 	__s32 lmax = multiplier->logical_maximum;
1072 	__s32 pmin = multiplier->physical_minimum;
1073 	__s32 pmax = multiplier->physical_maximum;
1074 
1075 	/*
1076 	 * "Because OS implementations will generally divide the control's
1077 	 * reported count by the Effective Resolution Multiplier, designers
1078 	 * should take care not to establish a potential Effective
1079 	 * Resolution Multiplier of zero."
1080 	 * HID Usage Table, v1.12, Section 4.3.1, p31
1081 	 */
1082 	if (lmax - lmin == 0)
1083 		return 1;
1084 	/*
1085 	 * Handling the unit exponent is left as an exercise to whoever
1086 	 * finds a device where that exponent is not 0.
1087 	 */
1088 	m = ((v - lmin)/(lmax - lmin) * (pmax - pmin) + pmin);
1089 	if (unlikely(multiplier->unit_exponent != 0)) {
1090 		hid_warn(hid,
1091 			 "unsupported Resolution Multiplier unit exponent %d\n",
1092 			 multiplier->unit_exponent);
1093 	}
1094 
1095 	/* There are no devices with an effective multiplier > 255 */
1096 	if (unlikely(m == 0 || m > 255 || m < -255)) {
1097 		hid_warn(hid, "unsupported Resolution Multiplier %d\n", m);
1098 		m = 1;
1099 	}
1100 
1101 	return m;
1102 }
1103 
hid_apply_multiplier_to_field(struct hid_device * hid,struct hid_field * field,struct hid_collection * multiplier_collection,int effective_multiplier)1104 static void hid_apply_multiplier_to_field(struct hid_device *hid,
1105 					  struct hid_field *field,
1106 					  struct hid_collection *multiplier_collection,
1107 					  int effective_multiplier)
1108 {
1109 	struct hid_collection *collection;
1110 	struct hid_usage *usage;
1111 	int i;
1112 
1113 	/*
1114 	 * If multiplier_collection is NULL, the multiplier applies
1115 	 * to all fields in the report.
1116 	 * Otherwise, it is the Logical Collection the multiplier applies to
1117 	 * but our field may be in a subcollection of that collection.
1118 	 */
1119 	for (i = 0; i < field->maxusage; i++) {
1120 		usage = &field->usage[i];
1121 
1122 		collection = &hid->collection[usage->collection_index];
1123 		while (collection->parent_idx != -1 &&
1124 		       collection != multiplier_collection)
1125 			collection = &hid->collection[collection->parent_idx];
1126 
1127 		if (collection->parent_idx != -1 ||
1128 		    multiplier_collection == NULL)
1129 			usage->resolution_multiplier = effective_multiplier;
1130 
1131 	}
1132 }
1133 
hid_apply_multiplier(struct hid_device * hid,struct hid_field * multiplier)1134 static void hid_apply_multiplier(struct hid_device *hid,
1135 				 struct hid_field *multiplier)
1136 {
1137 	struct hid_report_enum *rep_enum;
1138 	struct hid_report *rep;
1139 	struct hid_field *field;
1140 	struct hid_collection *multiplier_collection;
1141 	int effective_multiplier;
1142 	int i;
1143 
1144 	/*
1145 	 * "The Resolution Multiplier control must be contained in the same
1146 	 * Logical Collection as the control(s) to which it is to be applied.
1147 	 * If no Resolution Multiplier is defined, then the Resolution
1148 	 * Multiplier defaults to 1.  If more than one control exists in a
1149 	 * Logical Collection, the Resolution Multiplier is associated with
1150 	 * all controls in the collection. If no Logical Collection is
1151 	 * defined, the Resolution Multiplier is associated with all
1152 	 * controls in the report."
1153 	 * HID Usage Table, v1.12, Section 4.3.1, p30
1154 	 *
1155 	 * Thus, search from the current collection upwards until we find a
1156 	 * logical collection. Then search all fields for that same parent
1157 	 * collection. Those are the fields the multiplier applies to.
1158 	 *
1159 	 * If we have more than one multiplier, it will overwrite the
1160 	 * applicable fields later.
1161 	 */
1162 	multiplier_collection = &hid->collection[multiplier->usage->collection_index];
1163 	while (multiplier_collection->parent_idx != -1 &&
1164 	       multiplier_collection->type != HID_COLLECTION_LOGICAL)
1165 		multiplier_collection = &hid->collection[multiplier_collection->parent_idx];
1166 	if (multiplier_collection->type != HID_COLLECTION_LOGICAL)
1167 		multiplier_collection = NULL;
1168 
1169 	effective_multiplier = hid_calculate_multiplier(hid, multiplier);
1170 
1171 	rep_enum = &hid->report_enum[HID_INPUT_REPORT];
1172 	list_for_each_entry(rep, &rep_enum->report_list, list) {
1173 		for (i = 0; i < rep->maxfield; i++) {
1174 			field = rep->field[i];
1175 			hid_apply_multiplier_to_field(hid, field,
1176 						      multiplier_collection,
1177 						      effective_multiplier);
1178 		}
1179 	}
1180 }
1181 
1182 /*
1183  * hid_setup_resolution_multiplier - set up all resolution multipliers
1184  *
1185  * @device: hid device
1186  *
1187  * Search for all Resolution Multiplier Feature Reports and apply their
1188  * value to all matching Input items. This only updates the internal struct
1189  * fields.
1190  *
1191  * The Resolution Multiplier is applied by the hardware. If the multiplier
1192  * is anything other than 1, the hardware will send pre-multiplied events
1193  * so that the same physical interaction generates an accumulated
1194  *	accumulated_value = value * * multiplier
1195  * This may be achieved by sending
1196  * - "value * multiplier" for each event, or
1197  * - "value" but "multiplier" times as frequently, or
1198  * - a combination of the above
1199  * The only guarantee is that the same physical interaction always generates
1200  * an accumulated 'value * multiplier'.
1201  *
1202  * This function must be called before any event processing and after
1203  * any SetRequest to the Resolution Multiplier.
1204  */
hid_setup_resolution_multiplier(struct hid_device * hid)1205 void hid_setup_resolution_multiplier(struct hid_device *hid)
1206 {
1207 	struct hid_report_enum *rep_enum;
1208 	struct hid_report *rep;
1209 	struct hid_usage *usage;
1210 	int i, j;
1211 
1212 	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1213 	list_for_each_entry(rep, &rep_enum->report_list, list) {
1214 		for (i = 0; i < rep->maxfield; i++) {
1215 			/* Ignore if report count is out of bounds. */
1216 			if (rep->field[i]->report_count < 1)
1217 				continue;
1218 
1219 			for (j = 0; j < rep->field[i]->maxusage; j++) {
1220 				usage = &rep->field[i]->usage[j];
1221 				if (usage->hid == HID_GD_RESOLUTION_MULTIPLIER)
1222 					hid_apply_multiplier(hid,
1223 							     rep->field[i]);
1224 			}
1225 		}
1226 	}
1227 }
1228 EXPORT_SYMBOL_GPL(hid_setup_resolution_multiplier);
1229 
1230 /**
1231  * hid_open_report - open a driver-specific device report
1232  *
1233  * @device: hid device
1234  *
1235  * Parse a report description into a hid_device structure. Reports are
1236  * enumerated, fields are attached to these reports.
1237  * 0 returned on success, otherwise nonzero error value.
1238  *
1239  * This function (or the equivalent hid_parse() macro) should only be
1240  * called from probe() in drivers, before starting the device.
1241  */
hid_open_report(struct hid_device * device)1242 int hid_open_report(struct hid_device *device)
1243 {
1244 	struct hid_parser *parser;
1245 	struct hid_item item;
1246 	unsigned int size;
1247 	const __u8 *start;
1248 	const __u8 *end;
1249 	const __u8 *next;
1250 	int ret;
1251 	int i;
1252 	static int (*dispatch_type[])(struct hid_parser *parser,
1253 				      struct hid_item *item) = {
1254 		hid_parser_main,
1255 		hid_parser_global,
1256 		hid_parser_local,
1257 		hid_parser_reserved
1258 	};
1259 
1260 	if (WARN_ON(device->status & HID_STAT_PARSED))
1261 		return -EBUSY;
1262 
1263 	start = device->bpf_rdesc;
1264 	if (WARN_ON(!start))
1265 		return -ENODEV;
1266 	size = device->bpf_rsize;
1267 
1268 	if (device->driver->report_fixup) {
1269 		/*
1270 		 * device->driver->report_fixup() needs to work
1271 		 * on a copy of our report descriptor so it can
1272 		 * change it.
1273 		 */
1274 		__u8 *buf = kmemdup(start, size, GFP_KERNEL);
1275 
1276 		if (buf == NULL)
1277 			return -ENOMEM;
1278 
1279 		start = device->driver->report_fixup(device, buf, &size);
1280 
1281 		/*
1282 		 * The second kmemdup is required in case report_fixup() returns
1283 		 * a static read-only memory, but we have no idea if that memory
1284 		 * needs to be cleaned up or not at the end.
1285 		 */
1286 		start = kmemdup(start, size, GFP_KERNEL);
1287 		kfree(buf);
1288 		if (start == NULL)
1289 			return -ENOMEM;
1290 	}
1291 
1292 	device->rdesc = start;
1293 	device->rsize = size;
1294 
1295 	parser = vzalloc(sizeof(struct hid_parser));
1296 	if (!parser) {
1297 		ret = -ENOMEM;
1298 		goto alloc_err;
1299 	}
1300 
1301 	parser->device = device;
1302 
1303 	end = start + size;
1304 
1305 	device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
1306 				     sizeof(struct hid_collection), GFP_KERNEL);
1307 	if (!device->collection) {
1308 		ret = -ENOMEM;
1309 		goto err;
1310 	}
1311 	device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
1312 	for (i = 0; i < HID_DEFAULT_NUM_COLLECTIONS; i++)
1313 		device->collection[i].parent_idx = -1;
1314 
1315 	ret = -EINVAL;
1316 	while ((next = fetch_item(start, end, &item)) != NULL) {
1317 		start = next;
1318 
1319 		if (item.format != HID_ITEM_FORMAT_SHORT) {
1320 			hid_err(device, "unexpected long global item\n");
1321 			goto err;
1322 		}
1323 
1324 		if (dispatch_type[item.type](parser, &item)) {
1325 			hid_err(device, "item %u %u %u %u parsing failed\n",
1326 				item.format, (unsigned)item.size,
1327 				(unsigned)item.type, (unsigned)item.tag);
1328 			goto err;
1329 		}
1330 
1331 		if (start == end) {
1332 			if (parser->collection_stack_ptr) {
1333 				hid_err(device, "unbalanced collection at end of report description\n");
1334 				goto err;
1335 			}
1336 			if (parser->local.delimiter_depth) {
1337 				hid_err(device, "unbalanced delimiter at end of report description\n");
1338 				goto err;
1339 			}
1340 
1341 			/*
1342 			 * fetch initial values in case the device's
1343 			 * default multiplier isn't the recommended 1
1344 			 */
1345 			hid_setup_resolution_multiplier(device);
1346 
1347 			kfree(parser->collection_stack);
1348 			vfree(parser);
1349 			device->status |= HID_STAT_PARSED;
1350 
1351 			return 0;
1352 		}
1353 	}
1354 
1355 	hid_err(device, "item fetching failed at offset %u/%u\n",
1356 		size - (unsigned int)(end - start), size);
1357 err:
1358 	kfree(parser->collection_stack);
1359 alloc_err:
1360 	vfree(parser);
1361 	hid_close_report(device);
1362 	return ret;
1363 }
1364 EXPORT_SYMBOL_GPL(hid_open_report);
1365 
1366 /*
1367  * Extract/implement a data field from/to a little endian report (bit array).
1368  *
1369  * Code sort-of follows HID spec:
1370  *     http://www.usb.org/developers/hidpage/HID1_11.pdf
1371  *
1372  * While the USB HID spec allows unlimited length bit fields in "report
1373  * descriptors", most devices never use more than 16 bits.
1374  * One model of UPS is claimed to report "LINEV" as a 32-bit field.
1375  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1376  */
1377 
__extract(u8 * report,unsigned offset,int n)1378 static u32 __extract(u8 *report, unsigned offset, int n)
1379 {
1380 	unsigned int idx = offset / 8;
1381 	unsigned int bit_nr = 0;
1382 	unsigned int bit_shift = offset % 8;
1383 	int bits_to_copy = 8 - bit_shift;
1384 	u32 value = 0;
1385 	u32 mask = n < 32 ? (1U << n) - 1 : ~0U;
1386 
1387 	while (n > 0) {
1388 		value |= ((u32)report[idx] >> bit_shift) << bit_nr;
1389 		n -= bits_to_copy;
1390 		bit_nr += bits_to_copy;
1391 		bits_to_copy = 8;
1392 		bit_shift = 0;
1393 		idx++;
1394 	}
1395 
1396 	return value & mask;
1397 }
1398 
hid_field_extract(const struct hid_device * hid,u8 * report,unsigned offset,unsigned n)1399 u32 hid_field_extract(const struct hid_device *hid, u8 *report,
1400 			unsigned offset, unsigned n)
1401 {
1402 	if (n > 32) {
1403 		hid_warn_once(hid, "%s() called with n (%d) > 32! (%s)\n",
1404 			      __func__, n, current->comm);
1405 		n = 32;
1406 	}
1407 
1408 	return __extract(report, offset, n);
1409 }
1410 EXPORT_SYMBOL_GPL(hid_field_extract);
1411 
1412 /*
1413  * "implement" : set bits in a little endian bit stream.
1414  * Same concepts as "extract" (see comments above).
1415  * The data mangled in the bit stream remains in little endian
1416  * order the whole time. It make more sense to talk about
1417  * endianness of register values by considering a register
1418  * a "cached" copy of the little endian bit stream.
1419  */
1420 
__implement(u8 * report,unsigned offset,int n,u32 value)1421 static void __implement(u8 *report, unsigned offset, int n, u32 value)
1422 {
1423 	unsigned int idx = offset / 8;
1424 	unsigned int bit_shift = offset % 8;
1425 	int bits_to_set = 8 - bit_shift;
1426 
1427 	while (n - bits_to_set >= 0) {
1428 		report[idx] &= ~(0xff << bit_shift);
1429 		report[idx] |= value << bit_shift;
1430 		value >>= bits_to_set;
1431 		n -= bits_to_set;
1432 		bits_to_set = 8;
1433 		bit_shift = 0;
1434 		idx++;
1435 	}
1436 
1437 	/* last nibble */
1438 	if (n) {
1439 		u8 bit_mask = ((1U << n) - 1);
1440 		report[idx] &= ~(bit_mask << bit_shift);
1441 		report[idx] |= value << bit_shift;
1442 	}
1443 }
1444 
implement(const struct hid_device * hid,u8 * report,unsigned offset,unsigned n,u32 value)1445 static void implement(const struct hid_device *hid, u8 *report,
1446 		      unsigned offset, unsigned n, u32 value)
1447 {
1448 	if (unlikely(n > 32)) {
1449 		hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
1450 			 __func__, n, current->comm);
1451 		n = 32;
1452 	} else if (n < 32) {
1453 		u32 m = (1U << n) - 1;
1454 
1455 		if (unlikely(value > m)) {
1456 			hid_warn(hid,
1457 				 "%s() called with too large value %d (n: %d)! (%s)\n",
1458 				 __func__, value, n, current->comm);
1459 			value &= m;
1460 		}
1461 	}
1462 
1463 	__implement(report, offset, n, value);
1464 }
1465 
1466 /*
1467  * Search an array for a value.
1468  */
1469 
search(__s32 * array,__s32 value,unsigned n)1470 static int search(__s32 *array, __s32 value, unsigned n)
1471 {
1472 	while (n--) {
1473 		if (*array++ == value)
1474 			return 0;
1475 	}
1476 	return -1;
1477 }
1478 
1479 /**
1480  * hid_match_report - check if driver's raw_event should be called
1481  *
1482  * @hid: hid device
1483  * @report: hid report to match against
1484  *
1485  * compare hid->driver->report_table->report_type to report->type
1486  */
hid_match_report(struct hid_device * hid,struct hid_report * report)1487 static int hid_match_report(struct hid_device *hid, struct hid_report *report)
1488 {
1489 	const struct hid_report_id *id = hid->driver->report_table;
1490 
1491 	if (!id) /* NULL means all */
1492 		return 1;
1493 
1494 	for (; id->report_type != HID_TERMINATOR; id++)
1495 		if (id->report_type == HID_ANY_ID ||
1496 				id->report_type == report->type)
1497 			return 1;
1498 	return 0;
1499 }
1500 
1501 /**
1502  * hid_match_usage - check if driver's event should be called
1503  *
1504  * @hid: hid device
1505  * @usage: usage to match against
1506  *
1507  * compare hid->driver->usage_table->usage_{type,code} to
1508  * usage->usage_{type,code}
1509  */
hid_match_usage(struct hid_device * hid,struct hid_usage * usage)1510 static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
1511 {
1512 	const struct hid_usage_id *id = hid->driver->usage_table;
1513 
1514 	if (!id) /* NULL means all */
1515 		return 1;
1516 
1517 	for (; id->usage_type != HID_ANY_ID - 1; id++)
1518 		if ((id->usage_hid == HID_ANY_ID ||
1519 				id->usage_hid == usage->hid) &&
1520 				(id->usage_type == HID_ANY_ID ||
1521 				id->usage_type == usage->type) &&
1522 				(id->usage_code == HID_ANY_ID ||
1523 				 id->usage_code == usage->code))
1524 			return 1;
1525 	return 0;
1526 }
1527 
hid_process_event(struct hid_device * hid,struct hid_field * field,struct hid_usage * usage,__s32 value,int interrupt)1528 static void hid_process_event(struct hid_device *hid, struct hid_field *field,
1529 		struct hid_usage *usage, __s32 value, int interrupt)
1530 {
1531 	struct hid_driver *hdrv = hid->driver;
1532 	int ret;
1533 
1534 	if (!list_empty(&hid->debug_list))
1535 		hid_dump_input(hid, usage, value);
1536 
1537 	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
1538 		ret = hdrv->event(hid, field, usage, value);
1539 		if (ret != 0) {
1540 			if (ret < 0)
1541 				hid_err(hid, "%s's event failed with %d\n",
1542 						hdrv->name, ret);
1543 			return;
1544 		}
1545 	}
1546 
1547 	if (hid->claimed & HID_CLAIMED_INPUT)
1548 		hidinput_hid_event(hid, field, usage, value);
1549 	if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
1550 		hid->hiddev_hid_event(hid, field, usage, value);
1551 }
1552 
1553 /*
1554  * Checks if the given value is valid within this field
1555  */
hid_array_value_is_valid(struct hid_field * field,__s32 value)1556 static inline int hid_array_value_is_valid(struct hid_field *field,
1557 					   __s32 value)
1558 {
1559 	__s32 min = field->logical_minimum;
1560 
1561 	/*
1562 	 * Value needs to be between logical min and max, and
1563 	 * (value - min) is used as an index in the usage array.
1564 	 * This array is of size field->maxusage
1565 	 */
1566 	return value >= min &&
1567 	       value <= field->logical_maximum &&
1568 	       value - min < field->maxusage;
1569 }
1570 
1571 /*
1572  * Fetch the field from the data. The field content is stored for next
1573  * report processing (we do differential reporting to the layer).
1574  */
hid_input_fetch_field(struct hid_device * hid,struct hid_field * field,__u8 * data)1575 static void hid_input_fetch_field(struct hid_device *hid,
1576 				  struct hid_field *field,
1577 				  __u8 *data)
1578 {
1579 	unsigned n;
1580 	unsigned count = field->report_count;
1581 	unsigned offset = field->report_offset;
1582 	unsigned size = field->report_size;
1583 	__s32 min = field->logical_minimum;
1584 	__s32 *value;
1585 
1586 	value = field->new_value;
1587 	memset(value, 0, count * sizeof(__s32));
1588 	field->ignored = false;
1589 
1590 	for (n = 0; n < count; n++) {
1591 
1592 		value[n] = min < 0 ?
1593 			snto32(hid_field_extract(hid, data, offset + n * size,
1594 			       size), size) :
1595 			hid_field_extract(hid, data, offset + n * size, size);
1596 
1597 		/* Ignore report if ErrorRollOver */
1598 		if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
1599 		    hid_array_value_is_valid(field, value[n]) &&
1600 		    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) {
1601 			field->ignored = true;
1602 			return;
1603 		}
1604 	}
1605 }
1606 
1607 /*
1608  * Process a received variable field.
1609  */
1610 
hid_input_var_field(struct hid_device * hid,struct hid_field * field,int interrupt)1611 static void hid_input_var_field(struct hid_device *hid,
1612 				struct hid_field *field,
1613 				int interrupt)
1614 {
1615 	unsigned int count = field->report_count;
1616 	__s32 *value = field->new_value;
1617 	unsigned int n;
1618 
1619 	for (n = 0; n < count; n++)
1620 		hid_process_event(hid,
1621 				  field,
1622 				  &field->usage[n],
1623 				  value[n],
1624 				  interrupt);
1625 
1626 	memcpy(field->value, value, count * sizeof(__s32));
1627 }
1628 
1629 /*
1630  * Process a received array field. The field content is stored for
1631  * next report processing (we do differential reporting to the layer).
1632  */
1633 
hid_input_array_field(struct hid_device * hid,struct hid_field * field,int interrupt)1634 static void hid_input_array_field(struct hid_device *hid,
1635 				  struct hid_field *field,
1636 				  int interrupt)
1637 {
1638 	unsigned int n;
1639 	unsigned int count = field->report_count;
1640 	__s32 min = field->logical_minimum;
1641 	__s32 *value;
1642 
1643 	value = field->new_value;
1644 
1645 	/* ErrorRollOver */
1646 	if (field->ignored)
1647 		return;
1648 
1649 	for (n = 0; n < count; n++) {
1650 		if (hid_array_value_is_valid(field, field->value[n]) &&
1651 		    search(value, field->value[n], count))
1652 			hid_process_event(hid,
1653 					  field,
1654 					  &field->usage[field->value[n] - min],
1655 					  0,
1656 					  interrupt);
1657 
1658 		if (hid_array_value_is_valid(field, value[n]) &&
1659 		    search(field->value, value[n], count))
1660 			hid_process_event(hid,
1661 					  field,
1662 					  &field->usage[value[n] - min],
1663 					  1,
1664 					  interrupt);
1665 	}
1666 
1667 	memcpy(field->value, value, count * sizeof(__s32));
1668 }
1669 
1670 /*
1671  * Analyse a received report, and fetch the data from it. The field
1672  * content is stored for next report processing (we do differential
1673  * reporting to the layer).
1674  */
hid_process_report(struct hid_device * hid,struct hid_report * report,__u8 * data,int interrupt)1675 static void hid_process_report(struct hid_device *hid,
1676 			       struct hid_report *report,
1677 			       __u8 *data,
1678 			       int interrupt)
1679 {
1680 	unsigned int a;
1681 	struct hid_field_entry *entry;
1682 	struct hid_field *field;
1683 
1684 	/* first retrieve all incoming values in data */
1685 	for (a = 0; a < report->maxfield; a++)
1686 		hid_input_fetch_field(hid, report->field[a], data);
1687 
1688 	if (!list_empty(&report->field_entry_list)) {
1689 		/* INPUT_REPORT, we have a priority list of fields */
1690 		list_for_each_entry(entry,
1691 				    &report->field_entry_list,
1692 				    list) {
1693 			field = entry->field;
1694 
1695 			if (field->flags & HID_MAIN_ITEM_VARIABLE)
1696 				hid_process_event(hid,
1697 						  field,
1698 						  &field->usage[entry->index],
1699 						  field->new_value[entry->index],
1700 						  interrupt);
1701 			else
1702 				hid_input_array_field(hid, field, interrupt);
1703 		}
1704 
1705 		/* we need to do the memcpy at the end for var items */
1706 		for (a = 0; a < report->maxfield; a++) {
1707 			field = report->field[a];
1708 
1709 			if (field->flags & HID_MAIN_ITEM_VARIABLE)
1710 				memcpy(field->value, field->new_value,
1711 				       field->report_count * sizeof(__s32));
1712 		}
1713 	} else {
1714 		/* FEATURE_REPORT, regular processing */
1715 		for (a = 0; a < report->maxfield; a++) {
1716 			field = report->field[a];
1717 
1718 			if (field->flags & HID_MAIN_ITEM_VARIABLE)
1719 				hid_input_var_field(hid, field, interrupt);
1720 			else
1721 				hid_input_array_field(hid, field, interrupt);
1722 		}
1723 	}
1724 }
1725 
1726 /*
1727  * Insert a given usage_index in a field in the list
1728  * of processed usages in the report.
1729  *
1730  * The elements of lower priority score are processed
1731  * first.
1732  */
__hid_insert_field_entry(struct hid_device * hid,struct hid_report * report,struct hid_field_entry * entry,struct hid_field * field,unsigned int usage_index)1733 static void __hid_insert_field_entry(struct hid_device *hid,
1734 				     struct hid_report *report,
1735 				     struct hid_field_entry *entry,
1736 				     struct hid_field *field,
1737 				     unsigned int usage_index)
1738 {
1739 	struct hid_field_entry *next;
1740 
1741 	entry->field = field;
1742 	entry->index = usage_index;
1743 	entry->priority = field->usages_priorities[usage_index];
1744 
1745 	/* insert the element at the correct position */
1746 	list_for_each_entry(next,
1747 			    &report->field_entry_list,
1748 			    list) {
1749 		/*
1750 		 * the priority of our element is strictly higher
1751 		 * than the next one, insert it before
1752 		 */
1753 		if (entry->priority > next->priority) {
1754 			list_add_tail(&entry->list, &next->list);
1755 			return;
1756 		}
1757 	}
1758 
1759 	/* lowest priority score: insert at the end */
1760 	list_add_tail(&entry->list, &report->field_entry_list);
1761 }
1762 
hid_report_process_ordering(struct hid_device * hid,struct hid_report * report)1763 static void hid_report_process_ordering(struct hid_device *hid,
1764 					struct hid_report *report)
1765 {
1766 	struct hid_field *field;
1767 	struct hid_field_entry *entries;
1768 	unsigned int a, u, usages;
1769 	unsigned int count = 0;
1770 
1771 	/* count the number of individual fields in the report */
1772 	for (a = 0; a < report->maxfield; a++) {
1773 		field = report->field[a];
1774 
1775 		if (field->flags & HID_MAIN_ITEM_VARIABLE)
1776 			count += field->report_count;
1777 		else
1778 			count++;
1779 	}
1780 
1781 	/* allocate the memory to process the fields */
1782 	entries = kcalloc(count, sizeof(*entries), GFP_KERNEL);
1783 	if (!entries)
1784 		return;
1785 
1786 	report->field_entries = entries;
1787 
1788 	/*
1789 	 * walk through all fields in the report and
1790 	 * store them by priority order in report->field_entry_list
1791 	 *
1792 	 * - Var elements are individualized (field + usage_index)
1793 	 * - Arrays are taken as one, we can not chose an order for them
1794 	 */
1795 	usages = 0;
1796 	for (a = 0; a < report->maxfield; a++) {
1797 		field = report->field[a];
1798 
1799 		if (field->flags & HID_MAIN_ITEM_VARIABLE) {
1800 			for (u = 0; u < field->report_count; u++) {
1801 				__hid_insert_field_entry(hid, report,
1802 							 &entries[usages],
1803 							 field, u);
1804 				usages++;
1805 			}
1806 		} else {
1807 			__hid_insert_field_entry(hid, report, &entries[usages],
1808 						 field, 0);
1809 			usages++;
1810 		}
1811 	}
1812 }
1813 
hid_process_ordering(struct hid_device * hid)1814 static void hid_process_ordering(struct hid_device *hid)
1815 {
1816 	struct hid_report *report;
1817 	struct hid_report_enum *report_enum = &hid->report_enum[HID_INPUT_REPORT];
1818 
1819 	list_for_each_entry(report, &report_enum->report_list, list)
1820 		hid_report_process_ordering(hid, report);
1821 }
1822 
1823 /*
1824  * Output the field into the report.
1825  */
1826 
hid_output_field(const struct hid_device * hid,struct hid_field * field,__u8 * data)1827 static void hid_output_field(const struct hid_device *hid,
1828 			     struct hid_field *field, __u8 *data)
1829 {
1830 	unsigned count = field->report_count;
1831 	unsigned offset = field->report_offset;
1832 	unsigned size = field->report_size;
1833 	unsigned n;
1834 
1835 	for (n = 0; n < count; n++) {
1836 		if (field->logical_minimum < 0)	/* signed values */
1837 			implement(hid, data, offset + n * size, size,
1838 				  s32ton(field->value[n], size));
1839 		else				/* unsigned values */
1840 			implement(hid, data, offset + n * size, size,
1841 				  field->value[n]);
1842 	}
1843 }
1844 
1845 /*
1846  * Compute the size of a report.
1847  */
hid_compute_report_size(struct hid_report * report)1848 static size_t hid_compute_report_size(struct hid_report *report)
1849 {
1850 	if (report->size)
1851 		return ((report->size - 1) >> 3) + 1;
1852 
1853 	return 0;
1854 }
1855 
1856 /*
1857  * Create a report. 'data' has to be allocated using
1858  * hid_alloc_report_buf() so that it has proper size.
1859  */
1860 
hid_output_report(struct hid_report * report,__u8 * data)1861 void hid_output_report(struct hid_report *report, __u8 *data)
1862 {
1863 	unsigned n;
1864 
1865 	if (report->id > 0)
1866 		*data++ = report->id;
1867 
1868 	memset(data, 0, hid_compute_report_size(report));
1869 	for (n = 0; n < report->maxfield; n++)
1870 		hid_output_field(report->device, report->field[n], data);
1871 }
1872 EXPORT_SYMBOL_GPL(hid_output_report);
1873 
1874 /*
1875  * Allocator for buffer that is going to be passed to hid_output_report()
1876  */
hid_alloc_report_buf(struct hid_report * report,gfp_t flags)1877 u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
1878 {
1879 	/*
1880 	 * 7 extra bytes are necessary to achieve proper functionality
1881 	 * of implement() working on 8 byte chunks
1882 	 */
1883 
1884 	u32 len = hid_report_len(report) + 7;
1885 
1886 	return kzalloc(len, flags);
1887 }
1888 EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
1889 
1890 /*
1891  * Set a field value. The report this field belongs to has to be
1892  * created and transferred to the device, to set this value in the
1893  * device.
1894  */
1895 
hid_set_field(struct hid_field * field,unsigned offset,__s32 value)1896 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
1897 {
1898 	unsigned size;
1899 
1900 	if (!field)
1901 		return -1;
1902 
1903 	size = field->report_size;
1904 
1905 	hid_dump_input(field->report->device, field->usage + offset, value);
1906 
1907 	if (offset >= field->report_count) {
1908 		hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
1909 				offset, field->report_count);
1910 		return -1;
1911 	}
1912 	if (field->logical_minimum < 0) {
1913 		if (value != snto32(s32ton(value, size), size)) {
1914 			hid_err(field->report->device, "value %d is out of range\n", value);
1915 			return -1;
1916 		}
1917 	}
1918 	field->value[offset] = value;
1919 	return 0;
1920 }
1921 EXPORT_SYMBOL_GPL(hid_set_field);
1922 
hid_find_field(struct hid_device * hdev,unsigned int report_type,unsigned int application,unsigned int usage)1923 struct hid_field *hid_find_field(struct hid_device *hdev, unsigned int report_type,
1924 				 unsigned int application, unsigned int usage)
1925 {
1926 	struct list_head *report_list = &hdev->report_enum[report_type].report_list;
1927 	struct hid_report *report;
1928 	int i, j;
1929 
1930 	list_for_each_entry(report, report_list, list) {
1931 		if (report->application != application)
1932 			continue;
1933 
1934 		for (i = 0; i < report->maxfield; i++) {
1935 			struct hid_field *field = report->field[i];
1936 
1937 			for (j = 0; j < field->maxusage; j++) {
1938 				if (field->usage[j].hid == usage)
1939 					return field;
1940 			}
1941 		}
1942 	}
1943 
1944 	return NULL;
1945 }
1946 EXPORT_SYMBOL_GPL(hid_find_field);
1947 
hid_get_report(struct hid_report_enum * report_enum,const u8 * data)1948 static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
1949 		const u8 *data)
1950 {
1951 	struct hid_report *report;
1952 	unsigned int n = 0;	/* Normally report number is 0 */
1953 
1954 	/* Device uses numbered reports, data[0] is report number */
1955 	if (report_enum->numbered)
1956 		n = *data;
1957 
1958 	report = report_enum->report_id_hash[n];
1959 	if (report == NULL)
1960 		dbg_hid("undefined report_id %u received\n", n);
1961 
1962 	return report;
1963 }
1964 
1965 /*
1966  * Implement a generic .request() callback, using .raw_request()
1967  * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
1968  */
__hid_request(struct hid_device * hid,struct hid_report * report,enum hid_class_request reqtype)1969 int __hid_request(struct hid_device *hid, struct hid_report *report,
1970 		enum hid_class_request reqtype)
1971 {
1972 	char *buf;
1973 	int ret;
1974 	u32 len;
1975 
1976 	buf = hid_alloc_report_buf(report, GFP_KERNEL);
1977 	if (!buf)
1978 		return -ENOMEM;
1979 
1980 	len = hid_report_len(report);
1981 
1982 	if (reqtype == HID_REQ_SET_REPORT)
1983 		hid_output_report(report, buf);
1984 
1985 	ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
1986 					  report->type, reqtype);
1987 	if (ret < 0) {
1988 		dbg_hid("unable to complete request: %d\n", ret);
1989 		goto out;
1990 	}
1991 
1992 	if (reqtype == HID_REQ_GET_REPORT)
1993 		hid_input_report(hid, report->type, buf, ret, 0);
1994 
1995 	ret = 0;
1996 
1997 out:
1998 	kfree(buf);
1999 	return ret;
2000 }
2001 EXPORT_SYMBOL_GPL(__hid_request);
2002 
hid_report_raw_event(struct hid_device * hid,enum hid_report_type type,u8 * data,u32 size,int interrupt)2003 int hid_report_raw_event(struct hid_device *hid, enum hid_report_type type, u8 *data, u32 size,
2004 			 int interrupt)
2005 {
2006 	struct hid_report_enum *report_enum = hid->report_enum + type;
2007 	struct hid_report *report;
2008 	struct hid_driver *hdrv;
2009 	int max_buffer_size = HID_MAX_BUFFER_SIZE;
2010 	u32 rsize, csize = size;
2011 	u8 *cdata = data;
2012 	int ret = 0;
2013 
2014 	report = hid_get_report(report_enum, data);
2015 	if (!report)
2016 		goto out;
2017 
2018 	if (report_enum->numbered) {
2019 		cdata++;
2020 		csize--;
2021 	}
2022 
2023 	rsize = hid_compute_report_size(report);
2024 
2025 	if (hid->ll_driver->max_buffer_size)
2026 		max_buffer_size = hid->ll_driver->max_buffer_size;
2027 
2028 	if (report_enum->numbered && rsize >= max_buffer_size)
2029 		rsize = max_buffer_size - 1;
2030 	else if (rsize > max_buffer_size)
2031 		rsize = max_buffer_size;
2032 
2033 	if (csize < rsize) {
2034 		dbg_hid("report %d is too short, (%d < %d)\n", report->id,
2035 				csize, rsize);
2036 		memset(cdata + csize, 0, rsize - csize);
2037 	}
2038 
2039 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
2040 		hid->hiddev_report_event(hid, report);
2041 	if (hid->claimed & HID_CLAIMED_HIDRAW) {
2042 		ret = hidraw_report_event(hid, data, size);
2043 		if (ret)
2044 			goto out;
2045 	}
2046 
2047 	if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
2048 		hid_process_report(hid, report, cdata, interrupt);
2049 		hdrv = hid->driver;
2050 		if (hdrv && hdrv->report)
2051 			hdrv->report(hid, report);
2052 	}
2053 
2054 	if (hid->claimed & HID_CLAIMED_INPUT)
2055 		hidinput_report_event(hid, report);
2056 out:
2057 	return ret;
2058 }
2059 EXPORT_SYMBOL_GPL(hid_report_raw_event);
2060 
2061 
__hid_input_report(struct hid_device * hid,enum hid_report_type type,u8 * data,u32 size,int interrupt,u64 source,bool from_bpf,bool lock_already_taken)2062 static int __hid_input_report(struct hid_device *hid, enum hid_report_type type,
2063 			      u8 *data, u32 size, int interrupt, u64 source, bool from_bpf,
2064 			      bool lock_already_taken)
2065 {
2066 	struct hid_report_enum *report_enum;
2067 	struct hid_driver *hdrv;
2068 	struct hid_report *report;
2069 	int ret = 0;
2070 
2071 	if (!hid)
2072 		return -ENODEV;
2073 
2074 	ret = down_trylock(&hid->driver_input_lock);
2075 	if (lock_already_taken && !ret) {
2076 		up(&hid->driver_input_lock);
2077 		return -EINVAL;
2078 	} else if (!lock_already_taken && ret) {
2079 		return -EBUSY;
2080 	}
2081 
2082 	if (!hid->driver) {
2083 		ret = -ENODEV;
2084 		goto unlock;
2085 	}
2086 	report_enum = hid->report_enum + type;
2087 	hdrv = hid->driver;
2088 
2089 	data = dispatch_hid_bpf_device_event(hid, type, data, &size, interrupt, source, from_bpf);
2090 	if (IS_ERR(data)) {
2091 		ret = PTR_ERR(data);
2092 		goto unlock;
2093 	}
2094 
2095 	if (!size) {
2096 		dbg_hid("empty report\n");
2097 		ret = -1;
2098 		goto unlock;
2099 	}
2100 
2101 	/* Avoid unnecessary overhead if debugfs is disabled */
2102 	if (!list_empty(&hid->debug_list))
2103 		hid_dump_report(hid, type, data, size);
2104 
2105 	report = hid_get_report(report_enum, data);
2106 
2107 	if (!report) {
2108 		ret = -1;
2109 		goto unlock;
2110 	}
2111 
2112 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
2113 		ret = hdrv->raw_event(hid, report, data, size);
2114 		if (ret < 0)
2115 			goto unlock;
2116 	}
2117 
2118 	ret = hid_report_raw_event(hid, type, data, size, interrupt);
2119 
2120 unlock:
2121 	if (!lock_already_taken)
2122 		up(&hid->driver_input_lock);
2123 	return ret;
2124 }
2125 
2126 /**
2127  * hid_input_report - report data from lower layer (usb, bt...)
2128  *
2129  * @hid: hid device
2130  * @type: HID report type (HID_*_REPORT)
2131  * @data: report contents
2132  * @size: size of data parameter
2133  * @interrupt: distinguish between interrupt and control transfers
2134  *
2135  * This is data entry for lower layers.
2136  */
hid_input_report(struct hid_device * hid,enum hid_report_type type,u8 * data,u32 size,int interrupt)2137 int hid_input_report(struct hid_device *hid, enum hid_report_type type, u8 *data, u32 size,
2138 		     int interrupt)
2139 {
2140 	return __hid_input_report(hid, type, data, size, interrupt, 0,
2141 				  false, /* from_bpf */
2142 				  false /* lock_already_taken */);
2143 }
2144 EXPORT_SYMBOL_GPL(hid_input_report);
2145 
hid_match_one_id(const struct hid_device * hdev,const struct hid_device_id * id)2146 bool hid_match_one_id(const struct hid_device *hdev,
2147 		      const struct hid_device_id *id)
2148 {
2149 	return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
2150 		(id->group == HID_GROUP_ANY || id->group == hdev->group) &&
2151 		(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
2152 		(id->product == HID_ANY_ID || id->product == hdev->product);
2153 }
2154 
hid_match_id(const struct hid_device * hdev,const struct hid_device_id * id)2155 const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
2156 		const struct hid_device_id *id)
2157 {
2158 	for (; id->bus; id++)
2159 		if (hid_match_one_id(hdev, id))
2160 			return id;
2161 
2162 	return NULL;
2163 }
2164 EXPORT_SYMBOL_GPL(hid_match_id);
2165 
2166 static const struct hid_device_id hid_hiddev_list[] = {
2167 	{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
2168 	{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
2169 	{ }
2170 };
2171 
hid_hiddev(struct hid_device * hdev)2172 static bool hid_hiddev(struct hid_device *hdev)
2173 {
2174 	return !!hid_match_id(hdev, hid_hiddev_list);
2175 }
2176 
2177 
2178 static ssize_t
report_descriptor_read(struct file * filp,struct kobject * kobj,const struct bin_attribute * attr,char * buf,loff_t off,size_t count)2179 report_descriptor_read(struct file *filp, struct kobject *kobj,
2180 		       const struct bin_attribute *attr,
2181 		       char *buf, loff_t off, size_t count)
2182 {
2183 	struct device *dev = kobj_to_dev(kobj);
2184 	struct hid_device *hdev = to_hid_device(dev);
2185 
2186 	if (off >= hdev->rsize)
2187 		return 0;
2188 
2189 	if (off + count > hdev->rsize)
2190 		count = hdev->rsize - off;
2191 
2192 	memcpy(buf, hdev->rdesc + off, count);
2193 
2194 	return count;
2195 }
2196 
2197 static ssize_t
country_show(struct device * dev,struct device_attribute * attr,char * buf)2198 country_show(struct device *dev, struct device_attribute *attr,
2199 	     char *buf)
2200 {
2201 	struct hid_device *hdev = to_hid_device(dev);
2202 
2203 	return sprintf(buf, "%02x\n", hdev->country & 0xff);
2204 }
2205 
2206 static const BIN_ATTR_RO(report_descriptor, HID_MAX_DESCRIPTOR_SIZE);
2207 
2208 static const DEVICE_ATTR_RO(country);
2209 
hid_connect(struct hid_device * hdev,unsigned int connect_mask)2210 int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
2211 {
2212 	static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
2213 		"Joystick", "Gamepad", "Keyboard", "Keypad",
2214 		"Multi-Axis Controller"
2215 	};
2216 	const char *type, *bus;
2217 	char buf[64] = "";
2218 	unsigned int i;
2219 	int len;
2220 	int ret;
2221 
2222 	ret = hid_bpf_connect_device(hdev);
2223 	if (ret)
2224 		return ret;
2225 
2226 	if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
2227 		connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
2228 	if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
2229 		connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
2230 	if (hdev->bus != BUS_USB)
2231 		connect_mask &= ~HID_CONNECT_HIDDEV;
2232 	if (hid_hiddev(hdev))
2233 		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2234 
2235 	if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
2236 				connect_mask & HID_CONNECT_HIDINPUT_FORCE))
2237 		hdev->claimed |= HID_CLAIMED_INPUT;
2238 
2239 	if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
2240 			!hdev->hiddev_connect(hdev,
2241 				connect_mask & HID_CONNECT_HIDDEV_FORCE))
2242 		hdev->claimed |= HID_CLAIMED_HIDDEV;
2243 	if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
2244 		hdev->claimed |= HID_CLAIMED_HIDRAW;
2245 
2246 	if (connect_mask & HID_CONNECT_DRIVER)
2247 		hdev->claimed |= HID_CLAIMED_DRIVER;
2248 
2249 	/* Drivers with the ->raw_event callback set are not required to connect
2250 	 * to any other listener. */
2251 	if (!hdev->claimed && !hdev->driver->raw_event) {
2252 		hid_err(hdev, "device has no listeners, quitting\n");
2253 		return -ENODEV;
2254 	}
2255 
2256 	hid_process_ordering(hdev);
2257 
2258 	if ((hdev->claimed & HID_CLAIMED_INPUT) &&
2259 			(connect_mask & HID_CONNECT_FF) && hdev->ff_init)
2260 		hdev->ff_init(hdev);
2261 
2262 	len = 0;
2263 	if (hdev->claimed & HID_CLAIMED_INPUT)
2264 		len += sprintf(buf + len, "input");
2265 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
2266 		len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
2267 				((struct hiddev *)hdev->hiddev)->minor);
2268 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
2269 		len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
2270 				((struct hidraw *)hdev->hidraw)->minor);
2271 
2272 	type = "Device";
2273 	for (i = 0; i < hdev->maxcollection; i++) {
2274 		struct hid_collection *col = &hdev->collection[i];
2275 		if (col->type == HID_COLLECTION_APPLICATION &&
2276 		   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
2277 		   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
2278 			type = types[col->usage & 0xffff];
2279 			break;
2280 		}
2281 	}
2282 
2283 	switch (hdev->bus) {
2284 	case BUS_USB:
2285 		bus = "USB";
2286 		break;
2287 	case BUS_BLUETOOTH:
2288 		bus = "BLUETOOTH";
2289 		break;
2290 	case BUS_I2C:
2291 		bus = "I2C";
2292 		break;
2293 	case BUS_VIRTUAL:
2294 		bus = "VIRTUAL";
2295 		break;
2296 	case BUS_INTEL_ISHTP:
2297 	case BUS_AMD_SFH:
2298 		bus = "SENSOR HUB";
2299 		break;
2300 	default:
2301 		bus = "<UNKNOWN>";
2302 	}
2303 
2304 	ret = device_create_file(&hdev->dev, &dev_attr_country);
2305 	if (ret)
2306 		hid_warn(hdev,
2307 			 "can't create sysfs country code attribute err: %d\n", ret);
2308 
2309 	hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
2310 		 buf, bus, hdev->version >> 8, hdev->version & 0xff,
2311 		 type, hdev->name, hdev->phys);
2312 
2313 	return 0;
2314 }
2315 EXPORT_SYMBOL_GPL(hid_connect);
2316 
hid_disconnect(struct hid_device * hdev)2317 void hid_disconnect(struct hid_device *hdev)
2318 {
2319 	device_remove_file(&hdev->dev, &dev_attr_country);
2320 	if (hdev->claimed & HID_CLAIMED_INPUT)
2321 		hidinput_disconnect(hdev);
2322 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
2323 		hdev->hiddev_disconnect(hdev);
2324 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
2325 		hidraw_disconnect(hdev);
2326 	hdev->claimed = 0;
2327 
2328 	hid_bpf_disconnect_device(hdev);
2329 }
2330 EXPORT_SYMBOL_GPL(hid_disconnect);
2331 
2332 /**
2333  * hid_hw_start - start underlying HW
2334  * @hdev: hid device
2335  * @connect_mask: which outputs to connect, see HID_CONNECT_*
2336  *
2337  * Call this in probe function *after* hid_parse. This will setup HW
2338  * buffers and start the device (if not defeirred to device open).
2339  * hid_hw_stop must be called if this was successful.
2340  */
hid_hw_start(struct hid_device * hdev,unsigned int connect_mask)2341 int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
2342 {
2343 	int error;
2344 
2345 	error = hdev->ll_driver->start(hdev);
2346 	if (error)
2347 		return error;
2348 
2349 	if (connect_mask) {
2350 		error = hid_connect(hdev, connect_mask);
2351 		if (error) {
2352 			hdev->ll_driver->stop(hdev);
2353 			return error;
2354 		}
2355 	}
2356 
2357 	return 0;
2358 }
2359 EXPORT_SYMBOL_GPL(hid_hw_start);
2360 
2361 /**
2362  * hid_hw_stop - stop underlying HW
2363  * @hdev: hid device
2364  *
2365  * This is usually called from remove function or from probe when something
2366  * failed and hid_hw_start was called already.
2367  */
hid_hw_stop(struct hid_device * hdev)2368 void hid_hw_stop(struct hid_device *hdev)
2369 {
2370 	hid_disconnect(hdev);
2371 	hdev->ll_driver->stop(hdev);
2372 }
2373 EXPORT_SYMBOL_GPL(hid_hw_stop);
2374 
2375 /**
2376  * hid_hw_open - signal underlying HW to start delivering events
2377  * @hdev: hid device
2378  *
2379  * Tell underlying HW to start delivering events from the device.
2380  * This function should be called sometime after successful call
2381  * to hid_hw_start().
2382  */
hid_hw_open(struct hid_device * hdev)2383 int hid_hw_open(struct hid_device *hdev)
2384 {
2385 	int ret;
2386 
2387 	ret = mutex_lock_killable(&hdev->ll_open_lock);
2388 	if (ret)
2389 		return ret;
2390 
2391 	if (!hdev->ll_open_count++) {
2392 		ret = hdev->ll_driver->open(hdev);
2393 		if (ret)
2394 			hdev->ll_open_count--;
2395 	}
2396 
2397 	mutex_unlock(&hdev->ll_open_lock);
2398 	return ret;
2399 }
2400 EXPORT_SYMBOL_GPL(hid_hw_open);
2401 
2402 /**
2403  * hid_hw_close - signal underlaying HW to stop delivering events
2404  *
2405  * @hdev: hid device
2406  *
2407  * This function indicates that we are not interested in the events
2408  * from this device anymore. Delivery of events may or may not stop,
2409  * depending on the number of users still outstanding.
2410  */
hid_hw_close(struct hid_device * hdev)2411 void hid_hw_close(struct hid_device *hdev)
2412 {
2413 	mutex_lock(&hdev->ll_open_lock);
2414 	if (!--hdev->ll_open_count)
2415 		hdev->ll_driver->close(hdev);
2416 	mutex_unlock(&hdev->ll_open_lock);
2417 }
2418 EXPORT_SYMBOL_GPL(hid_hw_close);
2419 
2420 /**
2421  * hid_hw_request - send report request to device
2422  *
2423  * @hdev: hid device
2424  * @report: report to send
2425  * @reqtype: hid request type
2426  */
hid_hw_request(struct hid_device * hdev,struct hid_report * report,enum hid_class_request reqtype)2427 void hid_hw_request(struct hid_device *hdev,
2428 		    struct hid_report *report, enum hid_class_request reqtype)
2429 {
2430 	if (hdev->ll_driver->request)
2431 		return hdev->ll_driver->request(hdev, report, reqtype);
2432 
2433 	__hid_request(hdev, report, reqtype);
2434 }
2435 EXPORT_SYMBOL_GPL(hid_hw_request);
2436 
__hid_hw_raw_request(struct hid_device * hdev,unsigned char reportnum,__u8 * buf,size_t len,enum hid_report_type rtype,enum hid_class_request reqtype,u64 source,bool from_bpf)2437 int __hid_hw_raw_request(struct hid_device *hdev,
2438 			 unsigned char reportnum, __u8 *buf,
2439 			 size_t len, enum hid_report_type rtype,
2440 			 enum hid_class_request reqtype,
2441 			 u64 source, bool from_bpf)
2442 {
2443 	unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;
2444 	int ret;
2445 
2446 	if (hdev->ll_driver->max_buffer_size)
2447 		max_buffer_size = hdev->ll_driver->max_buffer_size;
2448 
2449 	if (len < 1 || len > max_buffer_size || !buf)
2450 		return -EINVAL;
2451 
2452 	ret = dispatch_hid_bpf_raw_requests(hdev, reportnum, buf, len, rtype,
2453 					    reqtype, source, from_bpf);
2454 	if (ret)
2455 		return ret;
2456 
2457 	return hdev->ll_driver->raw_request(hdev, reportnum, buf, len,
2458 					    rtype, reqtype);
2459 }
2460 
2461 /**
2462  * hid_hw_raw_request - send report request to device
2463  *
2464  * @hdev: hid device
2465  * @reportnum: report ID
2466  * @buf: in/out data to transfer
2467  * @len: length of buf
2468  * @rtype: HID report type
2469  * @reqtype: HID_REQ_GET_REPORT or HID_REQ_SET_REPORT
2470  *
2471  * Return: count of data transferred, negative if error
2472  *
2473  * Same behavior as hid_hw_request, but with raw buffers instead.
2474  */
hid_hw_raw_request(struct hid_device * hdev,unsigned char reportnum,__u8 * buf,size_t len,enum hid_report_type rtype,enum hid_class_request reqtype)2475 int hid_hw_raw_request(struct hid_device *hdev,
2476 		       unsigned char reportnum, __u8 *buf,
2477 		       size_t len, enum hid_report_type rtype, enum hid_class_request reqtype)
2478 {
2479 	return __hid_hw_raw_request(hdev, reportnum, buf, len, rtype, reqtype, 0, false);
2480 }
2481 EXPORT_SYMBOL_GPL(hid_hw_raw_request);
2482 
__hid_hw_output_report(struct hid_device * hdev,__u8 * buf,size_t len,u64 source,bool from_bpf)2483 int __hid_hw_output_report(struct hid_device *hdev, __u8 *buf, size_t len, u64 source,
2484 			   bool from_bpf)
2485 {
2486 	unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;
2487 	int ret;
2488 
2489 	if (hdev->ll_driver->max_buffer_size)
2490 		max_buffer_size = hdev->ll_driver->max_buffer_size;
2491 
2492 	if (len < 1 || len > max_buffer_size || !buf)
2493 		return -EINVAL;
2494 
2495 	ret = dispatch_hid_bpf_output_report(hdev, buf, len, source, from_bpf);
2496 	if (ret)
2497 		return ret;
2498 
2499 	if (hdev->ll_driver->output_report)
2500 		return hdev->ll_driver->output_report(hdev, buf, len);
2501 
2502 	return -ENOSYS;
2503 }
2504 
2505 /**
2506  * hid_hw_output_report - send output report to device
2507  *
2508  * @hdev: hid device
2509  * @buf: raw data to transfer
2510  * @len: length of buf
2511  *
2512  * Return: count of data transferred, negative if error
2513  */
hid_hw_output_report(struct hid_device * hdev,__u8 * buf,size_t len)2514 int hid_hw_output_report(struct hid_device *hdev, __u8 *buf, size_t len)
2515 {
2516 	return __hid_hw_output_report(hdev, buf, len, 0, false);
2517 }
2518 EXPORT_SYMBOL_GPL(hid_hw_output_report);
2519 
2520 #ifdef CONFIG_PM
hid_driver_suspend(struct hid_device * hdev,pm_message_t state)2521 int hid_driver_suspend(struct hid_device *hdev, pm_message_t state)
2522 {
2523 	if (hdev->driver && hdev->driver->suspend)
2524 		return hdev->driver->suspend(hdev, state);
2525 
2526 	return 0;
2527 }
2528 EXPORT_SYMBOL_GPL(hid_driver_suspend);
2529 
hid_driver_reset_resume(struct hid_device * hdev)2530 int hid_driver_reset_resume(struct hid_device *hdev)
2531 {
2532 	if (hdev->driver && hdev->driver->reset_resume)
2533 		return hdev->driver->reset_resume(hdev);
2534 
2535 	return 0;
2536 }
2537 EXPORT_SYMBOL_GPL(hid_driver_reset_resume);
2538 
hid_driver_resume(struct hid_device * hdev)2539 int hid_driver_resume(struct hid_device *hdev)
2540 {
2541 	if (hdev->driver && hdev->driver->resume)
2542 		return hdev->driver->resume(hdev);
2543 
2544 	return 0;
2545 }
2546 EXPORT_SYMBOL_GPL(hid_driver_resume);
2547 #endif /* CONFIG_PM */
2548 
2549 struct hid_dynid {
2550 	struct list_head list;
2551 	struct hid_device_id id;
2552 };
2553 
2554 /**
2555  * new_id_store - add a new HID device ID to this driver and re-probe devices
2556  * @drv: target device driver
2557  * @buf: buffer for scanning device ID data
2558  * @count: input size
2559  *
2560  * Adds a new dynamic hid device ID to this driver,
2561  * and causes the driver to probe for all devices again.
2562  */
new_id_store(struct device_driver * drv,const char * buf,size_t count)2563 static ssize_t new_id_store(struct device_driver *drv, const char *buf,
2564 		size_t count)
2565 {
2566 	struct hid_driver *hdrv = to_hid_driver(drv);
2567 	struct hid_dynid *dynid;
2568 	__u32 bus, vendor, product;
2569 	unsigned long driver_data = 0;
2570 	int ret;
2571 
2572 	ret = sscanf(buf, "%x %x %x %lx",
2573 			&bus, &vendor, &product, &driver_data);
2574 	if (ret < 3)
2575 		return -EINVAL;
2576 
2577 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
2578 	if (!dynid)
2579 		return -ENOMEM;
2580 
2581 	dynid->id.bus = bus;
2582 	dynid->id.group = HID_GROUP_ANY;
2583 	dynid->id.vendor = vendor;
2584 	dynid->id.product = product;
2585 	dynid->id.driver_data = driver_data;
2586 
2587 	spin_lock(&hdrv->dyn_lock);
2588 	list_add_tail(&dynid->list, &hdrv->dyn_list);
2589 	spin_unlock(&hdrv->dyn_lock);
2590 
2591 	ret = driver_attach(&hdrv->driver);
2592 
2593 	return ret ? : count;
2594 }
2595 static DRIVER_ATTR_WO(new_id);
2596 
2597 static struct attribute *hid_drv_attrs[] = {
2598 	&driver_attr_new_id.attr,
2599 	NULL,
2600 };
2601 ATTRIBUTE_GROUPS(hid_drv);
2602 
hid_free_dynids(struct hid_driver * hdrv)2603 static void hid_free_dynids(struct hid_driver *hdrv)
2604 {
2605 	struct hid_dynid *dynid, *n;
2606 
2607 	spin_lock(&hdrv->dyn_lock);
2608 	list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
2609 		list_del(&dynid->list);
2610 		kfree(dynid);
2611 	}
2612 	spin_unlock(&hdrv->dyn_lock);
2613 }
2614 
hid_match_device(struct hid_device * hdev,struct hid_driver * hdrv)2615 const struct hid_device_id *hid_match_device(struct hid_device *hdev,
2616 					     struct hid_driver *hdrv)
2617 {
2618 	struct hid_dynid *dynid;
2619 
2620 	spin_lock(&hdrv->dyn_lock);
2621 	list_for_each_entry(dynid, &hdrv->dyn_list, list) {
2622 		if (hid_match_one_id(hdev, &dynid->id)) {
2623 			spin_unlock(&hdrv->dyn_lock);
2624 			return &dynid->id;
2625 		}
2626 	}
2627 	spin_unlock(&hdrv->dyn_lock);
2628 
2629 	return hid_match_id(hdev, hdrv->id_table);
2630 }
2631 EXPORT_SYMBOL_GPL(hid_match_device);
2632 
hid_bus_match(struct device * dev,const struct device_driver * drv)2633 static int hid_bus_match(struct device *dev, const struct device_driver *drv)
2634 {
2635 	struct hid_driver *hdrv = to_hid_driver(drv);
2636 	struct hid_device *hdev = to_hid_device(dev);
2637 
2638 	return hid_match_device(hdev, hdrv) != NULL;
2639 }
2640 
2641 /**
2642  * hid_compare_device_paths - check if both devices share the same path
2643  * @hdev_a: hid device
2644  * @hdev_b: hid device
2645  * @separator: char to use as separator
2646  *
2647  * Check if two devices share the same path up to the last occurrence of
2648  * the separator char. Both paths must exist (i.e., zero-length paths
2649  * don't match).
2650  */
hid_compare_device_paths(struct hid_device * hdev_a,struct hid_device * hdev_b,char separator)2651 bool hid_compare_device_paths(struct hid_device *hdev_a,
2652 			      struct hid_device *hdev_b, char separator)
2653 {
2654 	int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys;
2655 	int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys;
2656 
2657 	if (n1 != n2 || n1 <= 0 || n2 <= 0)
2658 		return false;
2659 
2660 	return !strncmp(hdev_a->phys, hdev_b->phys, n1);
2661 }
2662 EXPORT_SYMBOL_GPL(hid_compare_device_paths);
2663 
hid_check_device_match(struct hid_device * hdev,struct hid_driver * hdrv,const struct hid_device_id ** id)2664 static bool hid_check_device_match(struct hid_device *hdev,
2665 				   struct hid_driver *hdrv,
2666 				   const struct hid_device_id **id)
2667 {
2668 	*id = hid_match_device(hdev, hdrv);
2669 	if (!*id)
2670 		return false;
2671 
2672 	if (hdrv->match)
2673 		return hdrv->match(hdev, hid_ignore_special_drivers);
2674 
2675 	/*
2676 	 * hid-generic implements .match(), so we must be dealing with a
2677 	 * different HID driver here, and can simply check if
2678 	 * hid_ignore_special_drivers or HID_QUIRK_IGNORE_SPECIAL_DRIVER
2679 	 * are set or not.
2680 	 */
2681 	return !hid_ignore_special_drivers && !(hdev->quirks & HID_QUIRK_IGNORE_SPECIAL_DRIVER);
2682 }
2683 
__hid_device_probe(struct hid_device * hdev,struct hid_driver * hdrv)2684 static int __hid_device_probe(struct hid_device *hdev, struct hid_driver *hdrv)
2685 {
2686 	const struct hid_device_id *id;
2687 	int ret;
2688 
2689 	if (!hdev->bpf_rsize) {
2690 		/* in case a bpf program gets detached, we need to free the old one */
2691 		hid_free_bpf_rdesc(hdev);
2692 
2693 		/* keep this around so we know we called it once */
2694 		hdev->bpf_rsize = hdev->dev_rsize;
2695 
2696 		/* call_hid_bpf_rdesc_fixup will always return a valid pointer */
2697 		hdev->bpf_rdesc = call_hid_bpf_rdesc_fixup(hdev, hdev->dev_rdesc,
2698 							   &hdev->bpf_rsize);
2699 	}
2700 
2701 	if (!hid_check_device_match(hdev, hdrv, &id))
2702 		return -ENODEV;
2703 
2704 	hdev->devres_group_id = devres_open_group(&hdev->dev, NULL, GFP_KERNEL);
2705 	if (!hdev->devres_group_id)
2706 		return -ENOMEM;
2707 
2708 	/* reset the quirks that has been previously set */
2709 	hdev->quirks = hid_lookup_quirk(hdev);
2710 	hdev->driver = hdrv;
2711 
2712 	if (hdrv->probe) {
2713 		ret = hdrv->probe(hdev, id);
2714 	} else { /* default probe */
2715 		ret = hid_open_report(hdev);
2716 		if (!ret)
2717 			ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2718 	}
2719 
2720 	/*
2721 	 * Note that we are not closing the devres group opened above so
2722 	 * even resources that were attached to the device after probe is
2723 	 * run are released when hid_device_remove() is executed. This is
2724 	 * needed as some drivers would allocate additional resources,
2725 	 * for example when updating firmware.
2726 	 */
2727 
2728 	if (ret) {
2729 		devres_release_group(&hdev->dev, hdev->devres_group_id);
2730 		hid_close_report(hdev);
2731 		hdev->driver = NULL;
2732 	}
2733 
2734 	return ret;
2735 }
2736 
hid_device_probe(struct device * dev)2737 static int hid_device_probe(struct device *dev)
2738 {
2739 	struct hid_device *hdev = to_hid_device(dev);
2740 	struct hid_driver *hdrv = to_hid_driver(dev->driver);
2741 	int ret = 0;
2742 
2743 	if (down_interruptible(&hdev->driver_input_lock))
2744 		return -EINTR;
2745 
2746 	hdev->io_started = false;
2747 	clear_bit(ffs(HID_STAT_REPROBED), &hdev->status);
2748 
2749 	if (!hdev->driver)
2750 		ret = __hid_device_probe(hdev, hdrv);
2751 
2752 	if (!hdev->io_started)
2753 		up(&hdev->driver_input_lock);
2754 
2755 	return ret;
2756 }
2757 
hid_device_remove(struct device * dev)2758 static void hid_device_remove(struct device *dev)
2759 {
2760 	struct hid_device *hdev = to_hid_device(dev);
2761 	struct hid_driver *hdrv;
2762 
2763 	down(&hdev->driver_input_lock);
2764 	hdev->io_started = false;
2765 
2766 	hdrv = hdev->driver;
2767 	if (hdrv) {
2768 		if (hdrv->remove)
2769 			hdrv->remove(hdev);
2770 		else /* default remove */
2771 			hid_hw_stop(hdev);
2772 
2773 		/* Release all devres resources allocated by the driver */
2774 		devres_release_group(&hdev->dev, hdev->devres_group_id);
2775 
2776 		hid_close_report(hdev);
2777 		hdev->driver = NULL;
2778 	}
2779 
2780 	if (!hdev->io_started)
2781 		up(&hdev->driver_input_lock);
2782 }
2783 
modalias_show(struct device * dev,struct device_attribute * a,char * buf)2784 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
2785 			     char *buf)
2786 {
2787 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
2788 
2789 	return scnprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
2790 			 hdev->bus, hdev->group, hdev->vendor, hdev->product);
2791 }
2792 static DEVICE_ATTR_RO(modalias);
2793 
2794 static struct attribute *hid_dev_attrs[] = {
2795 	&dev_attr_modalias.attr,
2796 	NULL,
2797 };
2798 static const struct bin_attribute *hid_dev_bin_attrs[] = {
2799 	&bin_attr_report_descriptor,
2800 	NULL
2801 };
2802 static const struct attribute_group hid_dev_group = {
2803 	.attrs = hid_dev_attrs,
2804 	.bin_attrs_new = hid_dev_bin_attrs,
2805 };
2806 __ATTRIBUTE_GROUPS(hid_dev);
2807 
hid_uevent(const struct device * dev,struct kobj_uevent_env * env)2808 static int hid_uevent(const struct device *dev, struct kobj_uevent_env *env)
2809 {
2810 	const struct hid_device *hdev = to_hid_device(dev);
2811 
2812 	if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
2813 			hdev->bus, hdev->vendor, hdev->product))
2814 		return -ENOMEM;
2815 
2816 	if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
2817 		return -ENOMEM;
2818 
2819 	if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
2820 		return -ENOMEM;
2821 
2822 	if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
2823 		return -ENOMEM;
2824 
2825 	if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X",
2826 			   hdev->bus, hdev->group, hdev->vendor, hdev->product))
2827 		return -ENOMEM;
2828 
2829 	return 0;
2830 }
2831 
2832 const struct bus_type hid_bus_type = {
2833 	.name		= "hid",
2834 	.dev_groups	= hid_dev_groups,
2835 	.drv_groups	= hid_drv_groups,
2836 	.match		= hid_bus_match,
2837 	.probe		= hid_device_probe,
2838 	.remove		= hid_device_remove,
2839 	.uevent		= hid_uevent,
2840 };
2841 EXPORT_SYMBOL(hid_bus_type);
2842 
hid_add_device(struct hid_device * hdev)2843 int hid_add_device(struct hid_device *hdev)
2844 {
2845 	static atomic_t id = ATOMIC_INIT(0);
2846 	int ret;
2847 
2848 	if (WARN_ON(hdev->status & HID_STAT_ADDED))
2849 		return -EBUSY;
2850 
2851 	hdev->quirks = hid_lookup_quirk(hdev);
2852 
2853 	/* we need to kill them here, otherwise they will stay allocated to
2854 	 * wait for coming driver */
2855 	if (hid_ignore(hdev))
2856 		return -ENODEV;
2857 
2858 	/*
2859 	 * Check for the mandatory transport channel.
2860 	 */
2861 	 if (!hdev->ll_driver->raw_request) {
2862 		hid_err(hdev, "transport driver missing .raw_request()\n");
2863 		return -EINVAL;
2864 	 }
2865 
2866 	/*
2867 	 * Read the device report descriptor once and use as template
2868 	 * for the driver-specific modifications.
2869 	 */
2870 	ret = hdev->ll_driver->parse(hdev);
2871 	if (ret)
2872 		return ret;
2873 	if (!hdev->dev_rdesc)
2874 		return -ENODEV;
2875 
2876 	/*
2877 	 * Scan generic devices for group information
2878 	 */
2879 	if (hid_ignore_special_drivers) {
2880 		hdev->group = HID_GROUP_GENERIC;
2881 	} else if (!hdev->group &&
2882 		   !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) {
2883 		ret = hid_scan_report(hdev);
2884 		if (ret)
2885 			hid_warn(hdev, "bad device descriptor (%d)\n", ret);
2886 	}
2887 
2888 	hdev->id = atomic_inc_return(&id);
2889 
2890 	/* XXX hack, any other cleaner solution after the driver core
2891 	 * is converted to allow more than 20 bytes as the device name? */
2892 	dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
2893 		     hdev->vendor, hdev->product, hdev->id);
2894 
2895 	hid_debug_register(hdev, dev_name(&hdev->dev));
2896 	ret = device_add(&hdev->dev);
2897 	if (!ret)
2898 		hdev->status |= HID_STAT_ADDED;
2899 	else
2900 		hid_debug_unregister(hdev);
2901 
2902 	return ret;
2903 }
2904 EXPORT_SYMBOL_GPL(hid_add_device);
2905 
2906 /**
2907  * hid_allocate_device - allocate new hid device descriptor
2908  *
2909  * Allocate and initialize hid device, so that hid_destroy_device might be
2910  * used to free it.
2911  *
2912  * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
2913  * error value.
2914  */
hid_allocate_device(void)2915 struct hid_device *hid_allocate_device(void)
2916 {
2917 	struct hid_device *hdev;
2918 	int ret = -ENOMEM;
2919 
2920 	hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
2921 	if (hdev == NULL)
2922 		return ERR_PTR(ret);
2923 
2924 	device_initialize(&hdev->dev);
2925 	hdev->dev.release = hid_device_release;
2926 	hdev->dev.bus = &hid_bus_type;
2927 	device_enable_async_suspend(&hdev->dev);
2928 
2929 	hid_close_report(hdev);
2930 
2931 	init_waitqueue_head(&hdev->debug_wait);
2932 	INIT_LIST_HEAD(&hdev->debug_list);
2933 	spin_lock_init(&hdev->debug_list_lock);
2934 	sema_init(&hdev->driver_input_lock, 1);
2935 	mutex_init(&hdev->ll_open_lock);
2936 	kref_init(&hdev->ref);
2937 
2938 	ret = hid_bpf_device_init(hdev);
2939 	if (ret)
2940 		goto out_err;
2941 
2942 	return hdev;
2943 
2944 out_err:
2945 	hid_destroy_device(hdev);
2946 	return ERR_PTR(ret);
2947 }
2948 EXPORT_SYMBOL_GPL(hid_allocate_device);
2949 
hid_remove_device(struct hid_device * hdev)2950 static void hid_remove_device(struct hid_device *hdev)
2951 {
2952 	if (hdev->status & HID_STAT_ADDED) {
2953 		device_del(&hdev->dev);
2954 		hid_debug_unregister(hdev);
2955 		hdev->status &= ~HID_STAT_ADDED;
2956 	}
2957 	hid_free_bpf_rdesc(hdev);
2958 	kfree(hdev->dev_rdesc);
2959 	hdev->dev_rdesc = NULL;
2960 	hdev->dev_rsize = 0;
2961 	hdev->bpf_rsize = 0;
2962 }
2963 
2964 /**
2965  * hid_destroy_device - free previously allocated device
2966  *
2967  * @hdev: hid device
2968  *
2969  * If you allocate hid_device through hid_allocate_device, you should ever
2970  * free by this function.
2971  */
hid_destroy_device(struct hid_device * hdev)2972 void hid_destroy_device(struct hid_device *hdev)
2973 {
2974 	hid_bpf_destroy_device(hdev);
2975 	hid_remove_device(hdev);
2976 	put_device(&hdev->dev);
2977 }
2978 EXPORT_SYMBOL_GPL(hid_destroy_device);
2979 
2980 
__hid_bus_reprobe_drivers(struct device * dev,void * data)2981 static int __hid_bus_reprobe_drivers(struct device *dev, void *data)
2982 {
2983 	struct hid_driver *hdrv = data;
2984 	struct hid_device *hdev = to_hid_device(dev);
2985 
2986 	if (hdev->driver == hdrv &&
2987 	    !hdrv->match(hdev, hid_ignore_special_drivers) &&
2988 	    !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status))
2989 		return device_reprobe(dev);
2990 
2991 	return 0;
2992 }
2993 
__hid_bus_driver_added(struct device_driver * drv,void * data)2994 static int __hid_bus_driver_added(struct device_driver *drv, void *data)
2995 {
2996 	struct hid_driver *hdrv = to_hid_driver(drv);
2997 
2998 	if (hdrv->match) {
2999 		bus_for_each_dev(&hid_bus_type, NULL, hdrv,
3000 				 __hid_bus_reprobe_drivers);
3001 	}
3002 
3003 	return 0;
3004 }
3005 
__bus_removed_driver(struct device_driver * drv,void * data)3006 static int __bus_removed_driver(struct device_driver *drv, void *data)
3007 {
3008 	return bus_rescan_devices(&hid_bus_type);
3009 }
3010 
__hid_register_driver(struct hid_driver * hdrv,struct module * owner,const char * mod_name)3011 int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
3012 		const char *mod_name)
3013 {
3014 	int ret;
3015 
3016 	hdrv->driver.name = hdrv->name;
3017 	hdrv->driver.bus = &hid_bus_type;
3018 	hdrv->driver.owner = owner;
3019 	hdrv->driver.mod_name = mod_name;
3020 
3021 	INIT_LIST_HEAD(&hdrv->dyn_list);
3022 	spin_lock_init(&hdrv->dyn_lock);
3023 
3024 	ret = driver_register(&hdrv->driver);
3025 
3026 	if (ret == 0)
3027 		bus_for_each_drv(&hid_bus_type, NULL, NULL,
3028 				 __hid_bus_driver_added);
3029 
3030 	return ret;
3031 }
3032 EXPORT_SYMBOL_GPL(__hid_register_driver);
3033 
hid_unregister_driver(struct hid_driver * hdrv)3034 void hid_unregister_driver(struct hid_driver *hdrv)
3035 {
3036 	driver_unregister(&hdrv->driver);
3037 	hid_free_dynids(hdrv);
3038 
3039 	bus_for_each_drv(&hid_bus_type, NULL, hdrv, __bus_removed_driver);
3040 }
3041 EXPORT_SYMBOL_GPL(hid_unregister_driver);
3042 
hid_check_keys_pressed(struct hid_device * hid)3043 int hid_check_keys_pressed(struct hid_device *hid)
3044 {
3045 	struct hid_input *hidinput;
3046 	int i;
3047 
3048 	if (!(hid->claimed & HID_CLAIMED_INPUT))
3049 		return 0;
3050 
3051 	list_for_each_entry(hidinput, &hid->inputs, list) {
3052 		for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
3053 			if (hidinput->input->key[i])
3054 				return 1;
3055 	}
3056 
3057 	return 0;
3058 }
3059 EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
3060 
3061 #ifdef CONFIG_HID_BPF
3062 static const struct hid_ops __hid_ops = {
3063 	.hid_get_report = hid_get_report,
3064 	.hid_hw_raw_request = __hid_hw_raw_request,
3065 	.hid_hw_output_report = __hid_hw_output_report,
3066 	.hid_input_report = __hid_input_report,
3067 	.owner = THIS_MODULE,
3068 	.bus_type = &hid_bus_type,
3069 };
3070 #endif
3071 
hid_init(void)3072 static int __init hid_init(void)
3073 {
3074 	int ret;
3075 
3076 	ret = bus_register(&hid_bus_type);
3077 	if (ret) {
3078 		pr_err("can't register hid bus\n");
3079 		goto err;
3080 	}
3081 
3082 #ifdef CONFIG_HID_BPF
3083 	hid_ops = &__hid_ops;
3084 #endif
3085 
3086 	ret = hidraw_init();
3087 	if (ret)
3088 		goto err_bus;
3089 
3090 	hid_debug_init();
3091 
3092 	return 0;
3093 err_bus:
3094 	bus_unregister(&hid_bus_type);
3095 err:
3096 	return ret;
3097 }
3098 
hid_exit(void)3099 static void __exit hid_exit(void)
3100 {
3101 #ifdef CONFIG_HID_BPF
3102 	hid_ops = NULL;
3103 #endif
3104 	hid_debug_exit();
3105 	hidraw_exit();
3106 	bus_unregister(&hid_bus_type);
3107 	hid_quirks_exit(HID_BUS_ANY);
3108 }
3109 
3110 module_init(hid_init);
3111 module_exit(hid_exit);
3112 
3113 MODULE_AUTHOR("Andreas Gal");
3114 MODULE_AUTHOR("Vojtech Pavlik");
3115 MODULE_AUTHOR("Jiri Kosina");
3116 MODULE_DESCRIPTION("HID support for Linux");
3117 MODULE_LICENSE("GPL");
3118