hid-core.c 57.3 KB
Newer Older
1
/*
Jiri Kosina's avatar
Jiri Kosina committed
2
 *  HID support for Linux
3
4
5
6
 *
 *  Copyright (c) 1999 Andreas Gal
 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7
 *  Copyright (c) 2006-2007 Jiri Kosina
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <asm/unaligned.h>
#include <asm/byteorder.h>
#include <linux/input.h>
#include <linux/wait.h>
28
#include <linux/vmalloc.h>
29
#include <linux/sched.h>
30
31
32

#include <linux/hid.h>
#include <linux/hiddev.h>
33
#include <linux/hid-debug.h>
Jiri Kosina's avatar
Jiri Kosina committed
34
#include <linux/hidraw.h>
35

Jiri Slaby's avatar
Jiri Slaby committed
36
37
#include "hid-ids.h"

38
39
40
41
42
/*
 * Version Information
 */

#define DRIVER_VERSION "v2.6"
43
#define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik, Jiri Kosina"
Jiri Kosina's avatar
Jiri Kosina committed
44
#define DRIVER_DESC "HID core driver"
45
46
#define DRIVER_LICENSE "GPL"

47
48
#ifdef CONFIG_HID_DEBUG
int hid_debug = 0;
49
50
module_param_named(debug, hid_debug, int, 0600);
MODULE_PARM_DESC(debug, "HID debugging (0=off, 1=probing info, 2=continuous data dumping)");
51
52
53
EXPORT_SYMBOL_GPL(hid_debug);
#endif

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*
 * Register a new report for a device.
 */

static struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
{
	struct hid_report_enum *report_enum = device->report_enum + type;
	struct hid_report *report;

	if (report_enum->report_id_hash[id])
		return report_enum->report_id_hash[id];

	if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
		return NULL;

	if (id != 0)
		report_enum->numbered = 1;

	report->id = id;
	report->type = type;
	report->size = 0;
	report->device = device;
	report_enum->report_id_hash[id] = report;

	list_add_tail(&report->list, &report_enum->report_list);

	return report;
}

/*
 * Register a new field for this report.
 */

static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
{
	struct hid_field *field;

	if (report->maxfield == HID_MAX_FIELDS) {
92
		dbg_hid("too many fields in report\n");
93
94
95
96
97
98
99
100
101
		return NULL;
	}

	if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
		+ values * sizeof(unsigned), GFP_KERNEL))) return NULL;

	field->index = report->maxfield++;
	report->field[field->index] = field;
	field->usage = (struct hid_usage *)(field + 1);
Jiri Slaby's avatar
Jiri Slaby committed
102
	field->value = (s32 *)(field->usage + usages);
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
	field->report = report;

	return field;
}

/*
 * Open a collection. The type/usage is pushed on the stack.
 */

static int open_collection(struct hid_parser *parser, unsigned type)
{
	struct hid_collection *collection;
	unsigned usage;

	usage = parser->local.usage[0];

	if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
120
		dbg_hid("collection stack overflow\n");
121
122
123
124
125
126
127
		return -1;
	}

	if (parser->device->maxcollection == parser->device->collection_size) {
		collection = kmalloc(sizeof(struct hid_collection) *
				parser->device->collection_size * 2, GFP_KERNEL);
		if (collection == NULL) {
128
			dbg_hid("failed to reallocate collection array\n");
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
			return -1;
		}
		memcpy(collection, parser->device->collection,
			sizeof(struct hid_collection) *
			parser->device->collection_size);
		memset(collection + parser->device->collection_size, 0,
			sizeof(struct hid_collection) *
			parser->device->collection_size);
		kfree(parser->device->collection);
		parser->device->collection = collection;
		parser->device->collection_size *= 2;
	}

	parser->collection_stack[parser->collection_stack_ptr++] =
		parser->device->maxcollection;

	collection = parser->device->collection +
		parser->device->maxcollection++;
	collection->type = type;
	collection->usage = usage;
	collection->level = parser->collection_stack_ptr - 1;

	if (type == HID_COLLECTION_APPLICATION)
		parser->device->maxapplication++;

	return 0;
}

/*
 * Close a collection.
 */

static int close_collection(struct hid_parser *parser)
{
	if (!parser->collection_stack_ptr) {
164
		dbg_hid("collection stack underflow\n");
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
		return -1;
	}
	parser->collection_stack_ptr--;
	return 0;
}

/*
 * Climb up the stack, search for the specified collection type
 * and return the usage.
 */

static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
{
	int n;
	for (n = parser->collection_stack_ptr - 1; n >= 0; n--)
		if (parser->device->collection[parser->collection_stack[n]].type == type)
			return parser->device->collection[parser->collection_stack[n]].usage;
	return 0; /* we know nothing about this usage type */
}

/*
 * Add a usage to the temporary parser table.
 */

static int hid_add_usage(struct hid_parser *parser, unsigned usage)
{
	if (parser->local.usage_index >= HID_MAX_USAGES) {
192
		dbg_hid("usage index exceeded\n");
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
		return -1;
	}
	parser->local.usage[parser->local.usage_index] = usage;
	parser->local.collection_index[parser->local.usage_index] =
		parser->collection_stack_ptr ?
		parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
	parser->local.usage_index++;
	return 0;
}

/*
 * Register a new field for this report.
 */

static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
{
	struct hid_report *report;
	struct hid_field *field;
	int usages;
	unsigned offset;
	int i;

	if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
216
		dbg_hid("hid_register_report failed\n");
217
218
219
220
		return -1;
	}

	if (parser->global.logical_maximum < parser->global.logical_minimum) {
221
		dbg_hid("logical range invalid %d %d\n", parser->global.logical_minimum, parser->global.logical_maximum);
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
		return -1;
	}

	offset = report->size;
	report->size += parser->global.report_size * parser->global.report_count;

	if (!parser->local.usage_index) /* Ignore padding fields */
		return 0;

	usages = max_t(int, parser->local.usage_index, parser->global.report_count);

	if ((field = hid_register_field(report, usages, parser->global.report_count)) == NULL)
		return 0;

	field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
	field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
	field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);

	for (i = 0; i < usages; i++) {
		int j = i;
		/* Duplicate the last usage we parsed if we have excess values */
		if (i >= parser->local.usage_index)
			j = parser->local.usage_index - 1;
		field->usage[i].hid = parser->local.usage[j];
		field->usage[i].collection_index =
			parser->local.collection_index[j];
	}

	field->maxusage = usages;
	field->flags = flags;
	field->report_offset = offset;
	field->report_type = report_type;
	field->report_size = parser->global.report_size;
	field->report_count = parser->global.report_count;
	field->logical_minimum = parser->global.logical_minimum;
	field->logical_maximum = parser->global.logical_maximum;
	field->physical_minimum = parser->global.physical_minimum;
	field->physical_maximum = parser->global.physical_maximum;
	field->unit_exponent = parser->global.unit_exponent;
	field->unit = parser->global.unit;

	return 0;
}

/*
 * Read data value from item.
 */

static u32 item_udata(struct hid_item *item)
{
	switch (item->size) {
Jiri Slaby's avatar
Jiri Slaby committed
273
274
275
	case 1: return item->data.u8;
	case 2: return item->data.u16;
	case 4: return item->data.u32;
276
277
278
279
280
281
282
	}
	return 0;
}

static s32 item_sdata(struct hid_item *item)
{
	switch (item->size) {
Jiri Slaby's avatar
Jiri Slaby committed
283
284
285
	case 1: return item->data.s8;
	case 2: return item->data.s16;
	case 4: return item->data.s32;
286
287
288
289
290
291
292
293
294
295
296
	}
	return 0;
}

/*
 * Process a global item.
 */

static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
{
	switch (item->tag) {
Jiri Slaby's avatar
Jiri Slaby committed
297
	case HID_GLOBAL_ITEM_TAG_PUSH:
298

Jiri Slaby's avatar
Jiri Slaby committed
299
300
301
302
		if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
			dbg_hid("global enviroment stack overflow\n");
			return -1;
		}
303

Jiri Slaby's avatar
Jiri Slaby committed
304
305
306
		memcpy(parser->global_stack + parser->global_stack_ptr++,
			&parser->global, sizeof(struct hid_global));
		return 0;
307

Jiri Slaby's avatar
Jiri Slaby committed
308
	case HID_GLOBAL_ITEM_TAG_POP:
309

Jiri Slaby's avatar
Jiri Slaby committed
310
311
312
313
		if (!parser->global_stack_ptr) {
			dbg_hid("global enviroment stack underflow\n");
			return -1;
		}
314

Jiri Slaby's avatar
Jiri Slaby committed
315
316
317
		memcpy(&parser->global, parser->global_stack +
			--parser->global_stack_ptr, sizeof(struct hid_global));
		return 0;
318

Jiri Slaby's avatar
Jiri Slaby committed
319
320
321
	case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
		parser->global.usage_page = item_udata(item);
		return 0;
322

Jiri Slaby's avatar
Jiri Slaby committed
323
324
325
	case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
		parser->global.logical_minimum = item_sdata(item);
		return 0;
326

Jiri Slaby's avatar
Jiri Slaby committed
327
328
329
330
331
332
	case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
		if (parser->global.logical_minimum < 0)
			parser->global.logical_maximum = item_sdata(item);
		else
			parser->global.logical_maximum = item_udata(item);
		return 0;
333

Jiri Slaby's avatar
Jiri Slaby committed
334
335
336
	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
		parser->global.physical_minimum = item_sdata(item);
		return 0;
337

Jiri Slaby's avatar
Jiri Slaby committed
338
339
340
341
342
343
	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
		if (parser->global.physical_minimum < 0)
			parser->global.physical_maximum = item_sdata(item);
		else
			parser->global.physical_maximum = item_udata(item);
		return 0;
344

Jiri Slaby's avatar
Jiri Slaby committed
345
346
347
	case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
		parser->global.unit_exponent = item_sdata(item);
		return 0;
348

Jiri Slaby's avatar
Jiri Slaby committed
349
350
351
	case HID_GLOBAL_ITEM_TAG_UNIT:
		parser->global.unit = item_udata(item);
		return 0;
352

Jiri Slaby's avatar
Jiri Slaby committed
353
354
355
356
357
358
359
360
	case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
		parser->global.report_size = item_udata(item);
		if (parser->global.report_size > 32) {
			dbg_hid("invalid report_size %d\n",
					parser->global.report_size);
			return -1;
		}
		return 0;
361

Jiri Slaby's avatar
Jiri Slaby committed
362
363
364
365
366
367
368
369
	case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
		parser->global.report_count = item_udata(item);
		if (parser->global.report_count > HID_MAX_USAGES) {
			dbg_hid("invalid report_count %d\n",
					parser->global.report_count);
			return -1;
		}
		return 0;
370

Jiri Slaby's avatar
Jiri Slaby committed
371
372
373
374
	case HID_GLOBAL_ITEM_TAG_REPORT_ID:
		parser->global.report_id = item_udata(item);
		if (parser->global.report_id == 0) {
			dbg_hid("report_id 0 is invalid\n");
375
			return -1;
Jiri Slaby's avatar
Jiri Slaby committed
376
377
378
379
380
381
		}
		return 0;

	default:
		dbg_hid("unknown global tag 0x%x\n", item->tag);
		return -1;
382
383
384
385
386
387
388
389
390
391
392
393
394
	}
}

/*
 * Process a local item.
 */

static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
{
	__u32 data;
	unsigned n;

	if (item->size == 0) {
395
		dbg_hid("item data expected for local item\n");
396
397
398
399
400
401
		return -1;
	}

	data = item_udata(item);

	switch (item->tag) {
Jiri Slaby's avatar
Jiri Slaby committed
402
403
404
405
406
407
408
409
410
411
412
413
	case HID_LOCAL_ITEM_TAG_DELIMITER:

		if (data) {
			/*
			 * We treat items before the first delimiter
			 * as global to all usage sets (branch 0).
			 * In the moment we process only these global
			 * items and the first delimiter set.
			 */
			if (parser->local.delimiter_depth != 0) {
				dbg_hid("nested delimiters\n");
				return -1;
414
			}
Jiri Slaby's avatar
Jiri Slaby committed
415
416
417
418
419
420
			parser->local.delimiter_depth++;
			parser->local.delimiter_branch++;
		} else {
			if (parser->local.delimiter_depth < 1) {
				dbg_hid("bogus close delimiter\n");
				return -1;
421
			}
Jiri Slaby's avatar
Jiri Slaby committed
422
423
424
			parser->local.delimiter_depth--;
		}
		return 1;
425

Jiri Slaby's avatar
Jiri Slaby committed
426
	case HID_LOCAL_ITEM_TAG_USAGE:
427

Jiri Slaby's avatar
Jiri Slaby committed
428
429
430
431
		if (parser->local.delimiter_branch > 1) {
			dbg_hid("alternative usage ignored\n");
			return 0;
		}
432

Jiri Slaby's avatar
Jiri Slaby committed
433
434
		if (item->size <= 2)
			data = (parser->global.usage_page << 16) + data;
435

Jiri Slaby's avatar
Jiri Slaby committed
436
		return hid_add_usage(parser, data);
437

Jiri Slaby's avatar
Jiri Slaby committed
438
	case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
439

Jiri Slaby's avatar
Jiri Slaby committed
440
441
		if (parser->local.delimiter_branch > 1) {
			dbg_hid("alternative usage ignored\n");
442
			return 0;
Jiri Slaby's avatar
Jiri Slaby committed
443
		}
444

Jiri Slaby's avatar
Jiri Slaby committed
445
446
		if (item->size <= 2)
			data = (parser->global.usage_page << 16) + data;
447

Jiri Slaby's avatar
Jiri Slaby committed
448
449
		parser->local.usage_minimum = data;
		return 0;
450

Jiri Slaby's avatar
Jiri Slaby committed
451
	case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
452

Jiri Slaby's avatar
Jiri Slaby committed
453
454
		if (parser->local.delimiter_branch > 1) {
			dbg_hid("alternative usage ignored\n");
455
			return 0;
Jiri Slaby's avatar
Jiri Slaby committed
456
		}
457

Jiri Slaby's avatar
Jiri Slaby committed
458
459
		if (item->size <= 2)
			data = (parser->global.usage_page << 16) + data;
460

Jiri Slaby's avatar
Jiri Slaby committed
461
462
463
464
465
466
467
468
469
470
471
		for (n = parser->local.usage_minimum; n <= data; n++)
			if (hid_add_usage(parser, n)) {
				dbg_hid("hid_add_usage failed\n");
				return -1;
			}
		return 0;

	default:

		dbg_hid("unknown local item tag 0x%x\n", item->tag);
		return 0;
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
	}
	return 0;
}

/*
 * Process a main item.
 */

static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
{
	__u32 data;
	int ret;

	data = item_udata(item);

	switch (item->tag) {
Jiri Slaby's avatar
Jiri Slaby committed
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
	case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
		ret = open_collection(parser, data & 0xff);
		break;
	case HID_MAIN_ITEM_TAG_END_COLLECTION:
		ret = close_collection(parser);
		break;
	case HID_MAIN_ITEM_TAG_INPUT:
		ret = hid_add_field(parser, HID_INPUT_REPORT, data);
		break;
	case HID_MAIN_ITEM_TAG_OUTPUT:
		ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
		break;
	case HID_MAIN_ITEM_TAG_FEATURE:
		ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
		break;
	default:
		dbg_hid("unknown main item tag 0x%x\n", item->tag);
		ret = 0;
506
507
508
509
510
511
512
513
514
515
516
517
518
	}

	memset(&parser->local, 0, sizeof(parser->local));	/* Reset the local parser environment */

	return ret;
}

/*
 * Process a reserved item.
 */

static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
{
519
	dbg_hid("reserved item type, tag 0x%x\n", item->tag);
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
	return 0;
}

/*
 * Free a report and all registered fields. The field->usage and
 * field->value table's are allocated behind the field, so we need
 * only to free(field) itself.
 */

static void hid_free_report(struct hid_report *report)
{
	unsigned n;

	for (n = 0; n < report->maxfield; n++)
		kfree(report->field[n]);
	kfree(report);
}

/*
 * Free a device structure, all reports, and all fields.
 */

Jiri Slaby's avatar
Jiri Slaby committed
542
static void hid_device_release(struct device *dev)
543
{
Jiri Slaby's avatar
Jiri Slaby committed
544
545
	struct hid_device *device = container_of(dev, struct hid_device, dev);
	unsigned i, j;
546
547
548
549
550
551
552
553
554
555
556
557

	for (i = 0; i < HID_REPORT_TYPES; i++) {
		struct hid_report_enum *report_enum = device->report_enum + i;

		for (j = 0; j < 256; j++) {
			struct hid_report *report = report_enum->report_id_hash[j];
			if (report)
				hid_free_report(report);
		}
	}

	kfree(device->rdesc);
558
	kfree(device->collection);
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
	kfree(device);
}

/*
 * Fetch a report description item from the data stream. We support long
 * items, though they are not used yet.
 */

static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
{
	u8 b;

	if ((end - start) <= 0)
		return NULL;

	b = *start++;

	item->type = (b >> 2) & 3;
	item->tag  = (b >> 4) & 15;

	if (item->tag == HID_ITEM_TAG_LONG) {

		item->format = HID_ITEM_FORMAT_LONG;

		if ((end - start) < 2)
			return NULL;

		item->size = *start++;
		item->tag  = *start++;

		if ((end - start) < item->size)
			return NULL;

		item->data.longdata = start;
		start += item->size;
		return start;
	}

	item->format = HID_ITEM_FORMAT_SHORT;
	item->size = b & 3;

	switch (item->size) {
Jiri Slaby's avatar
Jiri Slaby committed
601
602
	case 0:
		return start;
603

Jiri Slaby's avatar
Jiri Slaby committed
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
	case 1:
		if ((end - start) < 1)
			return NULL;
		item->data.u8 = *start++;
		return start;

	case 2:
		if ((end - start) < 2)
			return NULL;
		item->data.u16 = get_unaligned_le16(start);
		start = (__u8 *)((__le16 *)start + 1);
		return start;

	case 3:
		item->size++;
		if ((end - start) < 4)
			return NULL;
		item->data.u32 = get_unaligned_le32(start);
		start = (__u8 *)((__le32 *)start + 1);
		return start;
624
625
626
627
628
	}

	return NULL;
}

Jiri Slaby's avatar
Jiri Slaby committed
629
630
631
632
633
634
635
/**
 * hid_parse_report - parse device report
 *
 * @device: hid device
 * @start: report start
 * @size: report size
 *
636
637
 * Parse a report description into a hid_device structure. Reports are
 * enumerated, fields are attached to these reports.
Jiri Slaby's avatar
Jiri Slaby committed
638
 * 0 returned on success, otherwise nonzero error value.
639
 */
Jiri Slaby's avatar
Jiri Slaby committed
640
641
int hid_parse_report(struct hid_device *device, __u8 *start,
		unsigned size)
642
643
644
645
{
	struct hid_parser *parser;
	struct hid_item item;
	__u8 *end;
Jiri Slaby's avatar
Jiri Slaby committed
646
	int ret;
647
648
649
650
651
652
653
654
	static int (*dispatch_type[])(struct hid_parser *parser,
				      struct hid_item *item) = {
		hid_parser_main,
		hid_parser_global,
		hid_parser_local,
		hid_parser_reserved
	};

655
656
657
	if (device->driver->report_fixup)
		device->driver->report_fixup(device, start, size);

Jiri Slaby's avatar
Jiri Slaby committed
658
659
660
	device->rdesc = kmalloc(size, GFP_KERNEL);
	if (device->rdesc == NULL)
		return -ENOMEM;
661
662
663
	memcpy(device->rdesc, start, size);
	device->rsize = size;

Jiri Slaby's avatar
Jiri Slaby committed
664
665
666
667
	parser = vmalloc(sizeof(struct hid_parser));
	if (!parser) {
		ret = -ENOMEM;
		goto err;
668
	}
Jiri Slaby's avatar
Jiri Slaby committed
669

670
	memset(parser, 0, sizeof(struct hid_parser));
671
672
673
	parser->device = device;

	end = start + size;
Jiri Slaby's avatar
Jiri Slaby committed
674
	ret = -EINVAL;
675
676
677
	while ((start = fetch_item(start, end, &item)) != NULL) {

		if (item.format != HID_ITEM_FORMAT_SHORT) {
678
			dbg_hid("unexpected long global item\n");
Jiri Slaby's avatar
Jiri Slaby committed
679
			goto err;
680
681
682
		}

		if (dispatch_type[item.type](parser, &item)) {
683
			dbg_hid("item %u %u %u %u parsing failed\n",
684
				item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
Jiri Slaby's avatar
Jiri Slaby committed
685
			goto err;
686
687
688
689
		}

		if (start == end) {
			if (parser->collection_stack_ptr) {
690
				dbg_hid("unbalanced collection at end of report description\n");
Jiri Slaby's avatar
Jiri Slaby committed
691
				goto err;
692
693
			}
			if (parser->local.delimiter_depth) {
694
				dbg_hid("unbalanced delimiter at end of report description\n");
Jiri Slaby's avatar
Jiri Slaby committed
695
				goto err;
696
			}
697
			vfree(parser);
Jiri Slaby's avatar
Jiri Slaby committed
698
			return 0;
699
700
701
		}
	}

702
	dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
Jiri Slaby's avatar
Jiri Slaby committed
703
err:
704
	vfree(parser);
Jiri Slaby's avatar
Jiri Slaby committed
705
	return ret;
706
}
Jiri Kosina's avatar
Jiri Kosina committed
707
EXPORT_SYMBOL_GPL(hid_parse_report);
708
709
710
711
712
713
714
715
716
717

/*
 * Convert a signed n-bit integer to signed 32-bit integer. Common
 * cases are done through the compiler, the screwed things has to be
 * done by hand.
 */

static s32 snto32(__u32 value, unsigned n)
{
	switch (n) {
Jiri Slaby's avatar
Jiri Slaby committed
718
719
720
	case 8:  return ((__s8)value);
	case 16: return ((__s16)value);
	case 32: return ((__s32)value);
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
	}
	return value & (1 << (n - 1)) ? value | (-1 << n) : value;
}

/*
 * Convert a signed 32-bit integer to a signed n-bit integer.
 */

static u32 s32ton(__s32 value, unsigned n)
{
	s32 a = value >> (n - 1);
	if (a && a != -1)
		return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
	return value & ((1 << n) - 1);
}

/*
 * Extract/implement a data field from/to a little endian report (bit array).
 *
 * Code sort-of follows HID spec:
 *     http://www.usb.org/developers/devclass_docs/HID1_11.pdf
 *
 * While the USB HID spec allows unlimited length bit fields in "report
 * descriptors", most devices never use more than 16 bits.
 * One model of UPS is claimed to report "LINEV" as a 32-bit field.
 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
 */

static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
{
	u64 x;

753
754
755
	if (n > 32)
		printk(KERN_WARNING "HID: extract() called with n (%d) > 32! (%s)\n",
				n, current->comm);
756
757

	report += offset >> 3;  /* adjust byte index */
Jiri Kosina's avatar
Jiri Kosina committed
758
	offset &= 7;            /* now only need bit offset into one byte */
759
	x = get_unaligned_le64(report);
Jiri Kosina's avatar
Jiri Kosina committed
760
	x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
761
762
763
764
765
766
767
768
769
770
771
772
773
	return (u32) x;
}

/*
 * "implement" : set bits in a little endian bit stream.
 * Same concepts as "extract" (see comments above).
 * The data mangled in the bit stream remains in little endian
 * order the whole time. It make more sense to talk about
 * endianness of register values by considering a register
 * a "cached" copy of the little endiad bit stream.
 */
static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u32 value)
{
774
	u64 x;
775
776
	u64 m = (1ULL << n) - 1;

777
778
779
	if (n > 32)
		printk(KERN_WARNING "HID: implement() called with n (%d) > 32! (%s)\n",
				n, current->comm);
780

781
782
783
	if (value > m)
		printk(KERN_WARNING "HID: implement() called with too large value %d! (%s)\n",
				value, current->comm);
784
785
786
787
788
789
	WARN_ON(value > m);
	value &= m;

	report += offset >> 3;
	offset &= 7;

790
791
792
793
	x = get_unaligned_le64(report);
	x &= ~(m << offset);
	x |= ((u64)value) << offset;
	put_unaligned_le64(x, report);
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
}

/*
 * Search an array for a value.
 */

static __inline__ int search(__s32 *array, __s32 value, unsigned n)
{
	while (n--) {
		if (*array++ == value)
			return 0;
	}
	return -1;
}

Jiri Slaby's avatar
Jiri Slaby committed
809
810
811
812
813
814
815
816
817
/**
 * hid_match_report - check if driver's raw_event should be called
 *
 * @hid: hid device
 * @report_type: type to match against
 *
 * compare hid->driver->report_table->report_type to report->type
 */
static int hid_match_report(struct hid_device *hid, struct hid_report *report)
818
{
Jiri Slaby's avatar
Jiri Slaby committed
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
	const struct hid_report_id *id = hid->driver->report_table;

	if (!id) /* NULL means all */
		return 1;

	for (; id->report_type != HID_TERMINATOR; id++)
		if (id->report_type == HID_ANY_ID ||
				id->report_type == report->type)
			return 1;
	return 0;
}

/**
 * hid_match_usage - check if driver's event should be called
 *
 * @hid: hid device
 * @usage: usage to match against
 *
 * compare hid->driver->usage_table->usage_{type,code} to
 * usage->usage_{type,code}
 */
static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
{
	const struct hid_usage_id *id = hid->driver->usage_table;

	if (!id) /* NULL means all */
		return 1;

	for (; id->usage_type != HID_ANY_ID - 1; id++)
		if ((id->usage_hid == HID_ANY_ID ||
				id->usage_hid == usage->hid) &&
				(id->usage_type == HID_ANY_ID ||
				id->usage_type == usage->type) &&
				(id->usage_code == HID_ANY_ID ||
				 id->usage_code == usage->code))
			return 1;
	return 0;
}

static void hid_process_event(struct hid_device *hid, struct hid_field *field,
		struct hid_usage *usage, __s32 value, int interrupt)
{
	struct hid_driver *hdrv = hid->driver;
	int ret;

864
	hid_dump_input(usage, value);
Jiri Slaby's avatar
Jiri Slaby committed
865
866
867
868
869
870
871
872
873
874
875

	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
		ret = hdrv->event(hid, field, usage, value);
		if (ret != 0) {
			if (ret < 0)
				dbg_hid("%s's event failed with %d\n",
						hdrv->name, ret);
			return;
		}
	}

876
877
	if (hid->claimed & HID_CLAIMED_INPUT)
		hidinput_hid_event(hid, field, usage, value);
878
879
	if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
		hid->hiddev_hid_event(hid, field, usage, value);
880
881
882
883
884
885
886
887
}

/*
 * Analyse a received field, and fetch the data from it. The field
 * content is stored for next report processing (we do differential
 * reporting to the layer).
 */

888
889
static void hid_input_field(struct hid_device *hid, struct hid_field *field,
			    __u8 *data, int interrupt)
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
{
	unsigned n;
	unsigned count = field->report_count;
	unsigned offset = field->report_offset;
	unsigned size = field->report_size;
	__s32 min = field->logical_minimum;
	__s32 max = field->logical_maximum;
	__s32 *value;

	if (!(value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC)))
		return;

	for (n = 0; n < count; n++) {

			value[n] = min < 0 ? snto32(extract(data, offset + n * size, size), size) :
						    extract(data, offset + n * size, size);

			if (!(field->flags & HID_MAIN_ITEM_VARIABLE) /* Ignore report if ErrorRollOver */
			    && value[n] >= min && value[n] <= max
			    && field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
				goto exit;
	}

	for (n = 0; n < count; n++) {

		if (HID_MAIN_ITEM_VARIABLE & field->flags) {
			hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
			continue;
		}

		if (field->value[n] >= min && field->value[n] <= max
			&& field->usage[field->value[n] - min].hid
			&& search(value, field->value[n], count))
				hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);

		if (value[n] >= min && value[n] <= max
			&& field->usage[value[n] - min].hid
			&& search(field->value, value[n], count))
				hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
	}

	memcpy(field->value, value, count * sizeof(__s32));
exit:
	kfree(value);
}

/*
 * Output the field into the report.
 */

static void hid_output_field(struct hid_field *field, __u8 *data)
{
	unsigned count = field->report_count;
	unsigned offset = field->report_offset;
	unsigned size = field->report_size;
945
	unsigned bitsused = offset + count * size;
946
947
	unsigned n;

948
949
950
951
	/* make sure the unused bits in the last byte are zeros */
	if (count > 0 && size > 0 && (bitsused % 8) != 0)
		data[(bitsused-1)/8] &= (1 << (bitsused % 8)) - 1;

952
953
954
955
956
957
958
959
960
961
962
963
	for (n = 0; n < count; n++) {
		if (field->logical_minimum < 0)	/* signed values */
			implement(data, offset + n * size, size, s32ton(field->value[n], size));
		else				/* unsigned values */
			implement(data, offset + n * size, size, field->value[n]);
	}
}

/*
 * Create a report.
 */

Jiri Kosina's avatar
Jiri Kosina committed
964
void hid_output_report(struct hid_report *report, __u8 *data)
965
966
967
968
969
970
971
972
973
{
	unsigned n;

	if (report->id > 0)
		*data++ = report->id;

	for (n = 0; n < report->maxfield; n++)
		hid_output_field(report->field[n], data);
}
Jiri Kosina's avatar
Jiri Kosina committed
974
EXPORT_SYMBOL_GPL(hid_output_report);
975
976
977
978
979
980
981
982
983
984
985
986
987
988

/*
 * Set a field value. The report this field belongs to has to be
 * created and transferred to the device, to set this value in the
 * device.
 */

int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
{
	unsigned size = field->report_size;

	hid_dump_input(field->usage + offset, value);

	if (offset >= field->report_count) {
989
		dbg_hid("offset (%d) exceeds report_count (%d)\n", offset, field->report_count);
990
991
992
993
994
		hid_dump_field(field, 8);
		return -1;
	}
	if (field->logical_minimum < 0) {
		if (value != snto32(s32ton(value, size), size)) {
995
			dbg_hid("value %d is out of range\n", value);
996
997
998
999
1000
			return -1;
		}
	}
	field->value[offset] = value;
	return 0;