Lines Matching refs:parser
119 static int open_collection(struct hid_parser *parser, unsigned type)
125 usage = parser->local.usage[0];
127 if (parser->collection_stack_ptr == parser->collection_stack_size) {
129 unsigned int new_size = parser->collection_stack_size +
132 collection_stack = krealloc(parser->collection_stack,
138 parser->collection_stack = collection_stack;
139 parser->collection_stack_size = new_size;
142 if (parser->device->maxcollection == parser->device->collection_size) {
145 parser->device->collection_size,
149 hid_err(parser->device, "failed to reallocate collection array\n");
152 memcpy(collection, parser->device->collection,
154 parser->device->collection_size);
155 memset(collection + parser->device->collection_size, 0,
157 parser->device->collection_size);
158 kfree(parser->device->collection);
159 parser->device->collection = collection;
160 parser->device->collection_size *= 2;
163 parser->collection_stack[parser->collection_stack_ptr++] =
164 parser->device->maxcollection;
166 collection_index = parser->device->maxcollection++;
167 collection = parser->device->collection + collection_index;
170 collection->level = parser->collection_stack_ptr - 1;
172 parser->collection_stack[collection->level - 1];
175 parser->device->maxapplication++;
184 static int close_collection(struct hid_parser *parser)
186 if (!parser->collection_stack_ptr) {
187 hid_err(parser->device, "collection stack underflow\n");
190 parser->collection_stack_ptr--;
199 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
201 struct hid_collection *collection = parser->device->collection;
204 for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
205 unsigned index = parser->collection_stack[n];
217 static void complete_usage(struct hid_parser *parser, unsigned int index)
219 parser->local.usage[index] &= 0xFFFF;
220 parser->local.usage[index] |=
221 (parser->global.usage_page & 0xFFFF) << 16;
225 * Add a usage to the temporary parser table.
228 static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
230 if (parser->local.usage_index >= HID_MAX_USAGES) {
231 hid_err(parser->device, "usage index exceeded\n");
234 parser->local.usage[parser->local.usage_index] = usage;
241 complete_usage(parser, parser->local.usage_index);
243 parser->local.usage_size[parser->local.usage_index] = size;
244 parser->local.collection_index[parser->local.usage_index] =
245 parser->collection_stack_ptr ?
246 parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
247 parser->local.usage_index++;
255 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
265 application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
267 report = hid_register_report(parser->device, report_type,
268 parser->global.report_id, application);
270 hid_err(parser->device, "hid_register_report failed\n");
275 if ((parser->global.logical_minimum < 0 &&
276 parser->global.logical_maximum <
277 parser->global.logical_minimum) ||
278 (parser->global.logical_minimum >= 0 &&
279 (__u32)parser->global.logical_maximum <
280 (__u32)parser->global.logical_minimum)) {
282 parser->global.logical_minimum,
283 parser->global.logical_maximum);
288 report->size += parser->global.report_size * parser->global.report_count;
290 if (parser->device->ll_driver->max_buffer_size)
291 max_buffer_size = parser->device->ll_driver->max_buffer_size;
295 hid_err(parser->device, "report is too long\n");
299 if (!parser->local.usage_index) /* Ignore padding fields */
302 usages = max_t(unsigned, parser->local.usage_index,
303 parser->global.report_count);
309 field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
310 field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
316 if (i >= parser->local.usage_index)
317 j = parser->local.usage_index - 1;
318 field->usage[i].hid = parser->local.usage[j];
320 parser->local.collection_index[j];
329 field->report_size = parser->global.report_size;
330 field->report_count = parser->global.report_count;
331 field->logical_minimum = parser->global.logical_minimum;
332 field->logical_maximum = parser->global.logical_maximum;
333 field->physical_minimum = parser->global.physical_minimum;
334 field->physical_maximum = parser->global.physical_maximum;
335 field->unit_exponent = parser->global.unit_exponent;
336 field->unit = parser->global.unit;
369 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
375 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
376 hid_err(parser->device, "global environment stack overflow\n");
380 memcpy(parser->global_stack + parser->global_stack_ptr++,
381 &parser->global, sizeof(struct hid_global));
386 if (!parser->global_stack_ptr) {
387 hid_err(parser->device, "global environment stack underflow\n");
391 memcpy(&parser->global, parser->global_stack +
392 --parser->global_stack_ptr, sizeof(struct hid_global));
396 parser->global.usage_page = item_udata(item);
400 parser->global.logical_minimum = item_sdata(item);
404 if (parser->global.logical_minimum < 0)
405 parser->global.logical_maximum = item_sdata(item);
407 parser->global.logical_maximum = item_udata(item);
411 parser->global.physical_minimum = item_sdata(item);
415 if (parser->global.physical_minimum < 0)
416 parser->global.physical_maximum = item_sdata(item);
418 parser->global.physical_maximum = item_udata(item);
428 parser->global.unit_exponent = hid_snto32(raw_value, 4);
430 parser->global.unit_exponent = raw_value;
434 parser->global.unit = item_udata(item);
438 parser->global.report_size = item_udata(item);
439 if (parser->global.report_size > 256) {
440 hid_err(parser->device, "invalid report_size %d\n",
441 parser->global.report_size);
447 parser->global.report_count = item_udata(item);
448 if (parser->global.report_count > HID_MAX_USAGES) {
449 hid_err(parser->device, "invalid report_count %d\n",
450 parser->global.report_count);
456 parser->global.report_id = item_udata(item);
457 if (parser->global.report_id == 0 ||
458 parser->global.report_id >= HID_MAX_IDS) {
459 hid_err(parser->device, "report_id %u is invalid\n",
460 parser->global.report_id);
466 hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
475 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
493 if (parser->local.delimiter_depth != 0) {
494 hid_err(parser->device, "nested delimiters\n");
497 parser->local.delimiter_depth++;
498 parser->local.delimiter_branch++;
500 if (parser->local.delimiter_depth < 1) {
501 hid_err(parser->device, "bogus close delimiter\n");
504 parser->local.delimiter_depth--;
510 if (parser->local.delimiter_branch > 1) {
515 return hid_add_usage(parser, data, item->size);
519 if (parser->local.delimiter_branch > 1) {
524 parser->local.usage_minimum = data;
529 if (parser->local.delimiter_branch > 1) {
534 count = data - parser->local.usage_minimum;
535 if (count + parser->local.usage_index >= HID_MAX_USAGES) {
540 if (dev_name(&parser->device->dev))
541 hid_warn(parser->device,
543 data = HID_MAX_USAGES - parser->local.usage_index +
544 parser->local.usage_minimum - 1;
546 hid_err(parser->device,
552 for (n = parser->local.usage_minimum; n <= data; n++)
553 if (hid_add_usage(parser, n, item->size)) {
569 * As per specification, 6.2.2.8: "When the parser encounters a main item it
574 static void hid_concatenate_last_usage_page(struct hid_parser *parser)
580 if (!parser->local.usage_index)
583 usage_page = parser->global.usage_page;
589 for (i = parser->local.usage_index - 1; i >= 0; i--) {
590 if (parser->local.usage_size[i] > 2)
594 current_page = parser->local.usage[i] >> 16;
598 complete_usage(parser, i);
606 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
611 hid_concatenate_last_usage_page(parser);
617 ret = open_collection(parser, data & 0xff);
620 ret = close_collection(parser);
623 ret = hid_add_field(parser, HID_INPUT_REPORT, data);
626 ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
629 ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
632 hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag);
636 memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */
645 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) &&
822 if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
823 for (i = 0; i < parser->local.usage_index; i++)
824 if (parser->local.usage[i] == HID_GD_POINTER)
825 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
827 if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
828 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
830 if ((parser->global.usage_page << 16) == HID_UP_GOOGLEVENDOR)
831 for (i = 0; i < parser->local.usage_index; i++)
832 if (parser->local.usage[i] ==
834 parser->device->group =
838 static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
843 hid_concatenate_last_usage_page(parser);
849 hid_scan_collection(parser, data & 0xff);
857 for (i = 0; i < parser->local.usage_index; i++)
858 hid_scan_input_usage(parser, parser->local.usage[i]);
863 for (i = 0; i < parser->local.usage_index; i++)
864 hid_scan_feature_usage(parser, parser->local.usage[i]);
868 /* Reset the local parser environment */
869 memset(&parser->local, 0, sizeof(parser->local));
881 struct hid_parser *parser;
885 static int (*dispatch_type[])(struct hid_parser *parser,
893 parser = vzalloc(sizeof(struct hid_parser));
894 if (!parser)
897 parser->device = hid;
906 dispatch_type[item.type](parser, &item);
911 if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
924 if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
925 && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
934 kfree(parser->collection_stack);
935 vfree(parser);
1204 struct hid_parser *parser;
1213 static int (*dispatch_type[])(struct hid_parser *parser,
1247 parser = vzalloc(sizeof(struct hid_parser));
1248 if (!parser) {
1253 parser->device = device;
1276 if (dispatch_type[item.type](parser, &item)) {
1284 if (parser->collection_stack_ptr) {
1288 if (parser->local.delimiter_depth) {
1299 kfree(parser->collection_stack);
1300 vfree(parser);
1310 kfree(parser->collection_stack);
1312 vfree(parser);