Lines Matching refs:parser
121 static int open_collection(struct hid_parser *parser, unsigned type)
127 usage = parser->local.usage[0];
129 if (parser->collection_stack_ptr == parser->collection_stack_size) {
131 unsigned int new_size = parser->collection_stack_size +
134 collection_stack = krealloc(parser->collection_stack,
140 parser->collection_stack = collection_stack;
141 parser->collection_stack_size = new_size;
144 if (parser->device->maxcollection == parser->device->collection_size) {
147 parser->device->collection_size,
151 hid_err(parser->device, "failed to reallocate collection array\n");
154 memcpy(collection, parser->device->collection,
156 parser->device->collection_size);
157 memset(collection + parser->device->collection_size, 0,
159 parser->device->collection_size);
160 kfree(parser->device->collection);
161 parser->device->collection = collection;
162 parser->device->collection_size *= 2;
165 parser->collection_stack[parser->collection_stack_ptr++] =
166 parser->device->maxcollection;
168 collection_index = parser->device->maxcollection++;
169 collection = parser->device->collection + collection_index;
172 collection->level = parser->collection_stack_ptr - 1;
174 parser->collection_stack[collection->level - 1];
177 parser->device->maxapplication++;
186 static int close_collection(struct hid_parser *parser)
188 if (!parser->collection_stack_ptr) {
189 hid_err(parser->device, "collection stack underflow\n");
192 parser->collection_stack_ptr--;
201 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
203 struct hid_collection *collection = parser->device->collection;
206 for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
207 unsigned index = parser->collection_stack[n];
219 static void complete_usage(struct hid_parser *parser, unsigned int index)
221 parser->local.usage[index] &= 0xFFFF;
222 parser->local.usage[index] |=
223 (parser->global.usage_page & 0xFFFF) << 16;
227 * Add a usage to the temporary parser table.
230 static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
232 if (parser->local.usage_index >= HID_MAX_USAGES) {
233 hid_err(parser->device, "usage index exceeded\n");
236 parser->local.usage[parser->local.usage_index] = usage;
243 complete_usage(parser, parser->local.usage_index);
245 parser->local.usage_size[parser->local.usage_index] = size;
246 parser->local.collection_index[parser->local.usage_index] =
247 parser->collection_stack_ptr ?
248 parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
249 parser->local.usage_index++;
257 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
267 application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
269 report = hid_register_report(parser->device, report_type,
270 parser->global.report_id, application);
272 hid_err(parser->device, "hid_register_report failed\n");
277 if ((parser->global.logical_minimum < 0 &&
278 parser->global.logical_maximum <
279 parser->global.logical_minimum) ||
280 (parser->global.logical_minimum >= 0 &&
281 (__u32)parser->global.logical_maximum <
282 (__u32)parser->global.logical_minimum)) {
284 parser->global.logical_minimum,
285 parser->global.logical_maximum);
290 report->size += parser->global.report_size * parser->global.report_count;
292 if (parser->device->ll_driver->max_buffer_size)
293 max_buffer_size = parser->device->ll_driver->max_buffer_size;
297 hid_err(parser->device, "report is too long\n");
301 if (!parser->local.usage_index) /* Ignore padding fields */
304 usages = max_t(unsigned, parser->local.usage_index,
305 parser->global.report_count);
311 field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
312 field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
318 if (i >= parser->local.usage_index)
319 j = parser->local.usage_index - 1;
320 field->usage[i].hid = parser->local.usage[j];
322 parser->local.collection_index[j];
331 field->report_size = parser->global.report_size;
332 field->report_count = parser->global.report_count;
333 field->logical_minimum = parser->global.logical_minimum;
334 field->logical_maximum = parser->global.logical_maximum;
335 field->physical_minimum = parser->global.physical_minimum;
336 field->physical_maximum = parser->global.physical_maximum;
337 field->unit_exponent = parser->global.unit_exponent;
338 field->unit = parser->global.unit;
371 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
377 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
378 hid_err(parser->device, "global environment stack overflow\n");
382 memcpy(parser->global_stack + parser->global_stack_ptr++,
383 &parser->global, sizeof(struct hid_global));
388 if (!parser->global_stack_ptr) {
389 hid_err(parser->device, "global environment stack underflow\n");
393 memcpy(&parser->global, parser->global_stack +
394 --parser->global_stack_ptr, sizeof(struct hid_global));
398 parser->global.usage_page = item_udata(item);
402 parser->global.logical_minimum = item_sdata(item);
406 if (parser->global.logical_minimum < 0)
407 parser->global.logical_maximum = item_sdata(item);
409 parser->global.logical_maximum = item_udata(item);
413 parser->global.physical_minimum = item_sdata(item);
417 if (parser->global.physical_minimum < 0)
418 parser->global.physical_maximum = item_sdata(item);
420 parser->global.physical_maximum = item_udata(item);
430 parser->global.unit_exponent = hid_snto32(raw_value, 4);
432 parser->global.unit_exponent = raw_value;
436 parser->global.unit = item_udata(item);
440 parser->global.report_size = item_udata(item);
441 if (parser->global.report_size > 256) {
442 hid_err(parser->device, "invalid report_size %d\n",
443 parser->global.report_size);
449 parser->global.report_count = item_udata(item);
450 if (parser->global.report_count > HID_MAX_USAGES) {
451 hid_err(parser->device, "invalid report_count %d\n",
452 parser->global.report_count);
458 parser->global.report_id = item_udata(item);
459 if (parser->global.report_id == 0 ||
460 parser->global.report_id >= HID_MAX_IDS) {
461 hid_err(parser->device, "report_id %u is invalid\n",
462 parser->global.report_id);
468 hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
477 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
495 if (parser->local.delimiter_depth != 0) {
496 hid_err(parser->device, "nested delimiters\n");
499 parser->local.delimiter_depth++;
500 parser->local.delimiter_branch++;
502 if (parser->local.delimiter_depth < 1) {
503 hid_err(parser->device, "bogus close delimiter\n");
506 parser->local.delimiter_depth--;
512 if (parser->local.delimiter_branch > 1) {
517 return hid_add_usage(parser, data, item->size);
521 if (parser->local.delimiter_branch > 1) {
526 parser->local.usage_minimum = data;
531 if (parser->local.delimiter_branch > 1) {
536 count = data - parser->local.usage_minimum;
537 if (count + parser->local.usage_index >= HID_MAX_USAGES) {
542 if (dev_name(&parser->device->dev))
543 hid_warn(parser->device,
545 data = HID_MAX_USAGES - parser->local.usage_index +
546 parser->local.usage_minimum - 1;
548 hid_err(parser->device,
554 for (n = parser->local.usage_minimum; n <= data; n++)
555 if (hid_add_usage(parser, n, item->size)) {
571 * As per specification, 6.2.2.8: "When the parser encounters a main item it
576 static void hid_concatenate_last_usage_page(struct hid_parser *parser)
582 if (!parser->local.usage_index)
585 usage_page = parser->global.usage_page;
591 for (i = parser->local.usage_index - 1; i >= 0; i--) {
592 if (parser->local.usage_size[i] > 2)
596 current_page = parser->local.usage[i] >> 16;
600 complete_usage(parser, i);
608 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
613 hid_concatenate_last_usage_page(parser);
619 ret = open_collection(parser, data & 0xff);
622 ret = close_collection(parser);
625 ret = hid_add_field(parser, HID_INPUT_REPORT, data);
628 ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
631 ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
634 hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag);
638 memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */
647 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
788 static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
790 struct hid_device *hid = parser->device;
796 static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
798 if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
799 parser->global.report_size == 8)
800 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
802 if (usage == 0xff0000c6 && parser->global.report_count == 1 &&
803 parser->global.report_size == 8)
804 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
807 static void hid_scan_collection(struct hid_parser *parser, unsigned type)
809 struct hid_device *hid = parser->device;
812 if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
821 if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
822 for (i = 0; i < parser->local.usage_index; i++)
823 if (parser->local.usage[i] == HID_GD_POINTER)
824 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
826 if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
827 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
829 if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR)
830 for (i = 0; i < parser->local.usage_index; i++)
831 if (parser->local.usage[i] ==
833 parser->device->group =
837 static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
842 hid_concatenate_last_usage_page(parser);
848 hid_scan_collection(parser, data & 0xff);
856 for (i = 0; i < parser->local.usage_index; i++)
857 hid_scan_input_usage(parser, parser->local.usage[i]);
862 for (i = 0; i < parser->local.usage_index; i++)
863 hid_scan_feature_usage(parser, parser->local.usage[i]);
867 /* Reset the local parser environment */
868 memset(&parser->local, 0, sizeof(parser->local));
880 struct hid_parser *parser;
884 static int (*dispatch_type[])(struct hid_parser *parser,
892 parser = vzalloc(sizeof(struct hid_parser));
893 if (!parser)
896 parser->device = hid;
905 dispatch_type[item.type](parser, &item);
910 if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
923 if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
924 && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
933 kfree(parser->collection_stack);
934 vfree(parser);
1203 struct hid_parser *parser;
1212 static int (*dispatch_type[])(struct hid_parser *parser,
1245 parser = vzalloc(sizeof(struct hid_parser));
1246 if (!parser) {
1251 parser->device = device;
1274 if (dispatch_type[item.type](parser, &item)) {
1282 if (parser->collection_stack_ptr) {
1286 if (parser->local.delimiter_depth) {
1297 kfree(parser->collection_stack);
1298 vfree(parser);
1308 kfree(parser->collection_stack);
1310 vfree(parser);
2621 pr_warn("hid_debug is now used solely for parser and driver debugging.\n"