/*
* Copyright (c) 2011 Matej Klonfar
* Copyright (c) 2018 Ondrej Hlavaty
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup libusbhid
* @{
*/
/** @file
* HID report descriptor and report data parser implementation.
*/
#include <usb/hid/hidparser.h>
#include <errno.h>
#include <stdio.h>
#include <mem.h>
#include <usb/debug.h>
#include <assert.h>
#include <stdlib.h>
/*
* Constants defining current parsing mode for correct parsing of the set of
* local tags (usage) enclosed in delimter tags.
*/
/**
* Second delimiter tag was read. The set of local items (usage) ended.
*/
#define OUTSIDE_DELIMITER_SET 0
/**
* First delimiter tag was read. The set of local items (usage) started.
*/
#define START_DELIMITER_SET 1
/**
* Parser is in the set of local items.
*/
#define INSIDE_DELIMITER_SET 2
/** The new report item flag. Used to determine when the item is completly
* configured and should be added to the report structure
*/
#define USB_HID_NEW_REPORT_ITEM 1
/** No special action after the report descriptor tag is processed should be
* done
*/
#define USB_HID_NO_ACTION 2
#define USB_HID_RESET_OFFSET 3
#define USB_HID_INVALID -98
/** Unknown tag was founded in report descriptor data */
#define USB_HID_UNKNOWN_TAG -99
/**
* Checks if given collection path is already present in report structure and
* inserts it if not.
*
* @param report Report structure
* @param cmp_path The collection path
* @return Pointer to the result collection path in report structure.
* @retval NULL If some error occurs
*/
usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report,
usb_hid_report_path_t *cmp_path)
{
link_t *path_it = report->collection_paths.head.next;
usb_hid_report_path_t *path = NULL;
if ((report == NULL) || (cmp_path == NULL)) {
return NULL;
}
while (path_it != &report->collection_paths.head) {
path = list_get_instance(path_it, usb_hid_report_path_t,
cpath_link);
if (usb_hid_report_compare_usage_path(path, cmp_path,
USB_HID_PATH_COMPARE_STRICT) == 0) {
break;
}
path_it = path_it->next;
}
if (path_it == &report->collection_paths.head) {
path = usb_hid_report_path_clone(cmp_path);
if (path == NULL) {
return NULL;
}
list_append(&path->cpath_link, &report->collection_paths);
report->collection_paths_count++;
return path;
} else {
return list_get_instance(path_it, usb_hid_report_path_t,
cpath_link);
}
}
/**
* Initialize the report descriptor parser structure
*
* @param parser Report descriptor parser structure
* @return Error code
* @retval EINVAL If no report structure was given
* @retval EOK If report structure was successfully initialized
*/
errno_t usb_hid_report_init(usb_hid_report_t *report)
{
if (report == NULL) {
return EINVAL;
}
memset(report, 0, sizeof(usb_hid_report_t));
list_initialize(&report->reports);
list_initialize(&report->collection_paths);
report->use_report_ids = 0;
return EOK;
}
/**
*
*
* @param report Report structure in which the new report items should be
* stored
* @param report_item Current report descriptor's parsing state table
* @return Error code
* @retval EOK If all fields were successfully append to report
* @retval EINVAL If invalid parameters (NULL) was given
* @retval ENOMEM If there is no memmory to store new report description
*
*/
errno_t usb_hid_report_append_fields(usb_hid_report_t *report,
usb_hid_report_item_t *report_item)
{
usb_hid_report_field_t *field;
int i;
uint32_t *usages;
int usages_used = 0;
if ((report == NULL) || (report_item == NULL)) {
return EINVAL;
}
if (report_item->usages_count > 0) {
usages = malloc(sizeof(uint32_t) * report_item->usages_count);
memcpy(usages, report_item->usages, sizeof(int32_t) *
report_item->usages_count);
} else {
usages = NULL;
}
usb_hid_report_path_t *path = report_item->usage_path;
for (i = 0; i < report_item->count; i++) {
field = malloc(sizeof(usb_hid_report_field_t));
if (field == NULL) {
return ENOMEM;
}
memset(field, 0, sizeof(usb_hid_report_field_t));
link_initialize(&field->ritems_link);
/* fill the attributes */
field->logical_minimum = report_item->logical_minimum;
field->logical_maximum = report_item->logical_maximum;
field->physical_minimum = report_item->physical_minimum;
field->physical_maximum = report_item->physical_maximum;
if (USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
/*
* Store usage array. The Correct Usage Page and Usage is
* depending on data in report and will be filled later
*/
field->usage = 0;
field->usage_page = 0; //report_item->usage_page;
field->usages_count = report_item->usages_count;
field->usages = usages;
usages_used = 1;
} else {
/* Fill the correct Usage and Usage Page */
int32_t usage;
if (i < report_item->usages_count) {
usage = report_item->usages[i];
} else {
usage = report_item->usages[report_item->usages_count - 1];
}
if (USB_HID_IS_EXTENDED_USAGE(usage)) {
field->usage = USB_HID_EXTENDED_USAGE(usage);
field->usage_page =
USB_HID_EXTENDED_USAGE_PAGE(usage);
} else {
// should not occur
field->usage = usage;
field->usage_page = report_item->usage_page;
}
}
usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL,
field->usage_page);
usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL,
field->usage);
field->collection_path =
usb_hid_report_path_try_insert(report, path);
field->size = report_item->size;
field->offset = report_item->offset + (i * report_item->size);
if (report->use_report_ids != 0) {
field->offset += 8;
report->use_report_ids = 1;
}
field->item_flags = report_item->item_flags;
/* find the right report list */
usb_hid_report_description_t *report_des;
report_des = usb_hid_report_find_description(report,
report_item->id, report_item->type);
if (report_des == NULL) {
report_des = malloc(
sizeof(usb_hid_report_description_t));
if (report_des == NULL) {
return ENOMEM;
}
memset(report_des, 0,
sizeof(usb_hid_report_description_t));
report_des->type = report_item->type;
report_des->report_id = report_item->id;
if (report_des->report_id != 0) {
/* set up the bit length by report_id field */
report_des->bit_length = 8;
}
link_initialize (&report_des->reports_link);
list_initialize (&report_des->report_items);
list_append(&report_des->reports_link, &report->reports);
report->report_count++;
}
/* append this field to the end of founded report list */
list_append(&field->ritems_link, &report_des->report_items);
/* update the sizes */
report_des->bit_length += field->size;
report_des->item_length++;
}
// free only when not used!!!
if (usages && usages_used == 0) {
free(usages);
}
return EOK;
}
/**
* Finds description of report with given report_id and of given type in
* opaque report structure.
*
* @param report Opaque structure containing the parsed report descriptor
* @param report_id ReportId of report we are searching
* @param type Type of report we are searching
* @return Pointer to the particular report description
* @retval NULL If no description is founded
*/
usb_hid_report_description_t *usb_hid_report_find_description(
const usb_hid_report_t *report, uint8_t report_id,
usb_hid_report_type_t type)
{
if (report == NULL) {
return NULL;
}
list_foreach(report->reports, reports_link,
usb_hid_report_description_t, report_des) {
// if report id not set, return the first of the type
if (((report_des->report_id == report_id) || (report_id == 0)) &&
(report_des->type == type)) {
return report_des;
}
}
return NULL;
}
/** Parse HID report descriptor.
*
* @param parser Opaque HID report parser structure.
* @param data Data describing the report.
* @return Error code.
* @retval ENOMEM If no more memmory is available
* @retval EINVAL If invalid data are founded
* @retval EOK If report descriptor is successfully parsed
*/
errno_t usb_hid_parse_report_descriptor(usb_hid_report_t *report,
const uint8_t *data, size_t size)
{
size_t i = 0;
uint8_t tag = 0;
uint8_t item_size = 0;
int class = 0;
int ret;
usb_hid_report_item_t *report_item = 0;
usb_hid_report_item_t *new_report_item;
usb_hid_report_path_t *usage_path;
size_t offset_input = 0;
size_t offset_output = 0;
size_t offset_feature = 0;
link_t *item_link;
list_t stack;
list_initialize(&stack);
/* parser structure initialization */
if (usb_hid_report_init(report) != EOK) {
return EINVAL;
}
/* report item initialization */
if (!(report_item = malloc(sizeof(usb_hid_report_item_t)))) {
return ENOMEM;
}
memset(report_item, 0, sizeof(usb_hid_report_item_t));
link_initialize(&(report_item->link));
/* usage path context initialization */
if (!(usage_path = usb_hid_report_path())) {
free(report_item);
return ENOMEM;
}
usb_hid_report_path_append_item(usage_path, 0, 0);
while (i < size) {
if (!USB_HID_ITEM_IS_LONG(data[i])) {
if ((i + USB_HID_ITEM_SIZE(data[i])) >= size) {
return EINVAL;
}
tag = USB_HID_ITEM_TAG(data[i]);
item_size = USB_HID_ITEM_SIZE(data[i]);
class = USB_HID_ITEM_TAG_CLASS(data[i]);
ret = usb_hid_report_parse_tag(tag, class, data + i + 1,
item_size, report_item, usage_path);
switch (ret) {
case USB_HID_NEW_REPORT_ITEM:
/*
* store report item to report and create the
* new one store current collection path
*/
report_item->usage_path = usage_path;
usb_hid_report_path_set_report_id(
report_item->usage_path, report_item->id);
if (report_item->id != 0) {
report->use_report_ids = 1;
}
switch (tag) {
case USB_HID_REPORT_TAG_INPUT:
report_item->type =
USB_HID_REPORT_TYPE_INPUT;
report_item->offset = offset_input;
offset_input += report_item->count *
report_item->size;
break;
case USB_HID_REPORT_TAG_OUTPUT:
report_item->type =
USB_HID_REPORT_TYPE_OUTPUT;
report_item->offset = offset_output;
offset_output += report_item->count *
report_item->size;
break;
case USB_HID_REPORT_TAG_FEATURE:
report_item->type =
USB_HID_REPORT_TYPE_FEATURE;
report_item->offset = offset_feature;
offset_feature += report_item->count *
report_item->size;
break;
default:
usb_log_debug2(
"\tjump over - tag %X\n", tag);
break;
}
/*
* append new fields to the report structure
*/
usb_hid_report_append_fields(report,
report_item);
/* reset local items */
usb_hid_report_reset_local_items (report_item);
break;
case USB_HID_RESET_OFFSET:
offset_input = 0;
offset_output = 0;
offset_feature = 0;
usb_hid_report_path_set_report_id (usage_path,
report_item->id);
break;
case USB_HID_REPORT_TAG_PUSH:
// push current state to stack
new_report_item = usb_hid_report_item_clone(
report_item);
usb_hid_report_path_t *tmp_path =
usb_hid_report_path_clone(usage_path);
new_report_item->usage_path = tmp_path;
list_prepend (&new_report_item->link, &stack);
break;
case USB_HID_REPORT_TAG_POP:
// restore current state from stack
item_link = list_first(&stack);
if (item_link == NULL) {
return EINVAL;
}
free(report_item);
report_item = list_get_instance(item_link,
usb_hid_report_item_t, link);
usb_hid_report_usage_path_t *tmp_usage_path;
tmp_usage_path = list_get_instance(
report_item->usage_path->cpath_link.prev,
usb_hid_report_usage_path_t, rpath_items_link);
usb_hid_report_set_last_item(usage_path,
USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
usb_hid_report_set_last_item(usage_path,
USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
usb_hid_report_path_free(report_item->usage_path);
list_remove (item_link);
break;
default:
// nothing special to do
break;
}
/* jump over the processed block */
i += 1 + USB_HID_ITEM_SIZE(data[i]);
} else {
// TBD
i += 3 + USB_HID_ITEM_SIZE(data[i + 1]);
}
}
return EOK;
}
/**
* Parse one tag of the report descriptor
*
* @param Tag to parse
* @param Report descriptor buffer
* @param Size of data belongs to this tag
* @param Current report item structe
* @return Code of action to be done next
*/
int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
size_t item_size, usb_hid_report_item_t *report_item,
usb_hid_report_path_t *usage_path)
{
int ret;
switch (class) {
case USB_HID_TAG_CLASS_MAIN:
if ((ret = usb_hid_report_parse_main_tag(tag, data, item_size,
report_item, usage_path)) == 0) {
return USB_HID_NEW_REPORT_ITEM;
} else {
return ret;
}
break;
case USB_HID_TAG_CLASS_GLOBAL:
return usb_hid_report_parse_global_tag(tag, data, item_size,
report_item, usage_path);
break;
case USB_HID_TAG_CLASS_LOCAL:
return usb_hid_report_parse_local_tag(tag, data, item_size,
report_item, usage_path);
break;
default:
return USB_HID_NO_ACTION;
}
}
/**
* Parse main tags of report descriptor
*
* @param Tag identifier
* @param Data buffer
* @param Length of data buffer
* @param Current state table
* @return 0 or USB_HID_ code
*/
int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
size_t item_size, usb_hid_report_item_t *report_item,
usb_hid_report_path_t *usage_path)
{
usb_hid_report_usage_path_t *path_item;
switch (tag) {
case USB_HID_REPORT_TAG_INPUT:
case USB_HID_REPORT_TAG_OUTPUT:
case USB_HID_REPORT_TAG_FEATURE:
report_item->item_flags = *data;
return 0;
break;
case USB_HID_REPORT_TAG_COLLECTION:
/* store collection atributes */
path_item = list_get_instance(list_first(&usage_path->items),
usb_hid_report_usage_path_t, rpath_items_link);
path_item->flags = *data;
/* set last item */
usb_hid_report_set_last_item(usage_path,
USB_HID_TAG_CLASS_GLOBAL,
USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[report_item->usages_count - 1]));
usb_hid_report_set_last_item(usage_path,
USB_HID_TAG_CLASS_LOCAL,
USB_HID_EXTENDED_USAGE(report_item->usages[report_item->usages_count - 1]));
/*
* append the new one which will be set by common usage/usage
* page
*/
usb_hid_report_path_append_item(usage_path,
report_item->usage_page,
report_item->usages[report_item->usages_count - 1]);
usb_hid_report_reset_local_items (report_item);
return USB_HID_NO_ACTION;
break;
case USB_HID_REPORT_TAG_END_COLLECTION:
usb_hid_report_remove_last_item(usage_path);
return USB_HID_NO_ACTION;
break;
default:
return USB_HID_NO_ACTION;
}
return 0;
}
/**
* Parse global tags of report descriptor
*
* @param Tag identifier
* @param Data buffer
* @param Length of data buffer
* @param Current state table
* @return 0 or USB_HID_ code
*/
int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data,
size_t item_size, usb_hid_report_item_t *report_item,
usb_hid_report_path_t *usage_path)
{
switch (tag) {
case USB_HID_REPORT_TAG_USAGE_PAGE:
report_item->usage_page =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
report_item->logical_minimum = USB_HID_UINT32_TO_INT32(
usb_hid_report_tag_data_uint32(data, item_size),
item_size * 8);
break;
case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
usb_hid_report_tag_data_uint32(data, item_size),
item_size * 8);
break;
case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
usb_hid_report_tag_data_uint32(data, item_size),
item_size * 8);
break;
case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
usb_hid_report_tag_data_uint32(data, item_size),
item_size * 8);
break;
case USB_HID_REPORT_TAG_UNIT_EXPONENT:
report_item->unit_exponent = usb_hid_report_tag_data_uint32(
data, item_size);
break;
case USB_HID_REPORT_TAG_UNIT:
report_item->unit = usb_hid_report_tag_data_uint32(
data, item_size);
break;
case USB_HID_REPORT_TAG_REPORT_SIZE:
report_item->size = usb_hid_report_tag_data_uint32(
data, item_size);
break;
case USB_HID_REPORT_TAG_REPORT_COUNT:
report_item->count = usb_hid_report_tag_data_uint32(
data, item_size);
break;
case USB_HID_REPORT_TAG_REPORT_ID:
report_item->id = usb_hid_report_tag_data_uint32(data,
item_size);
return USB_HID_RESET_OFFSET;
break;
case USB_HID_REPORT_TAG_PUSH:
case USB_HID_REPORT_TAG_POP:
/*
* stack operations are done in top level parsing
* function
*/
return tag;
break;
default:
return USB_HID_NO_ACTION;
}
return 0;
}
/**
* Parse local tags of report descriptor
*
* @param Tag identifier
* @param Data buffer
* @param Length of data buffer
* @param Current state table
* @return 0 or USB_HID_ code
*/
int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data,
size_t item_size, usb_hid_report_item_t *report_item,
usb_hid_report_path_t *usage_path)
{
int32_t extended_usage;
switch (tag) {
case USB_HID_REPORT_TAG_USAGE:
switch (report_item->in_delimiter) {
case INSIDE_DELIMITER_SET:
/*
* Nothing to do.
* We catch only the first one
*/
break;
case START_DELIMITER_SET:
report_item->in_delimiter = INSIDE_DELIMITER_SET;
/* Fallthrough */
case OUTSIDE_DELIMITER_SET:
extended_usage = ((report_item->usage_page) << 16);
extended_usage +=
usb_hid_report_tag_data_uint32(data, item_size);
report_item->usages[report_item->usages_count] =
extended_usage;
report_item->usages_count++;
break;
}
break;
case USB_HID_REPORT_TAG_USAGE_MINIMUM:
if (item_size == 3) {
/* Usage extended usages */
report_item->extended_usage_page =
USB_HID_EXTENDED_USAGE_PAGE(
usb_hid_report_tag_data_uint32(data, item_size));
report_item->usage_minimum =
USB_HID_EXTENDED_USAGE(
usb_hid_report_tag_data_uint32(data, item_size));
} else {
report_item->usage_minimum =
usb_hid_report_tag_data_uint32(data, item_size);
}
break;
case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
if (item_size == 3) {
if (report_item->extended_usage_page !=
USB_HID_EXTENDED_USAGE_PAGE(
usb_hid_report_tag_data_uint32(data, item_size))) {
return USB_HID_INVALID;
}
/* Usage extended usages */
report_item->extended_usage_page =
USB_HID_EXTENDED_USAGE_PAGE(
usb_hid_report_tag_data_uint32(data, item_size));
report_item->usage_maximum =
USB_HID_EXTENDED_USAGE(
usb_hid_report_tag_data_uint32(data, item_size));
} else {
report_item->usage_maximum =
usb_hid_report_tag_data_uint32(data, item_size);
}
/* Put the records into the usages array */
for (int32_t i = report_item->usage_minimum;
i <= report_item->usage_maximum; i++) {
if (report_item->extended_usage_page) {
report_item->usages[report_item->usages_count++] =
(report_item->extended_usage_page << 16) + i;
} else {
report_item->usages[report_item->usages_count++] =
(report_item->usage_page << 16) + i;
}
}
report_item->extended_usage_page = 0;
break;
case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
report_item->designator_index =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
report_item->designator_minimum =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
report_item->designator_maximum =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_STRING_INDEX:
report_item->string_index =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_STRING_MINIMUM:
report_item->string_minimum =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_STRING_MAXIMUM:
report_item->string_maximum =
usb_hid_report_tag_data_uint32(data, item_size);
break;
case USB_HID_REPORT_TAG_DELIMITER:
report_item->in_delimiter =
usb_hid_report_tag_data_uint32(data, item_size);
break;
default:
return USB_HID_NO_ACTION;
}
return 0;
}
/**
* Converts raw data to uint32 (thats the maximum length of short item data)
*
* @param Data buffer
* @param Size of buffer
* @return Converted int32 number
*/
uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
{
unsigned int i;
uint32_t result;
result = 0;
for (i = 0; i < size; i++) {
result = (result | (data[i]) << (i * 8));
}
return result;
}
/**
* Prints content of given list of report items.
*
* @param List of report items (usb_hid_report_item_t)
* @return void
*/
void usb_hid_descriptor_print_list(list_t *list)
{
if (list == NULL || list_empty(list)) {
usb_log_debug("\tempty");
return;
}
list_foreach(*list, ritems_link, usb_hid_report_field_t,
report_item) {
usb_log_debug("\t\tOFFSET: %u", report_item->offset);
usb_log_debug("\t\tSIZE: %zu", report_item->size);
usb_log_debug("\t\tLOGMIN: %d",
report_item->logical_minimum);
usb_log_debug("\t\tLOGMAX: %d",
report_item->logical_maximum);
usb_log_debug("\t\tPHYMIN: %d",
report_item->physical_minimum);
usb_log_debug("\t\tPHYMAX: %d",
report_item->physical_maximum);
usb_log_debug("\t\ttUSAGEMIN: %X",
report_item->usage_minimum);
usb_log_debug("\t\tUSAGEMAX: %X",
report_item->usage_maximum);
usb_log_debug("\t\tUSAGES COUNT: %zu",
report_item->usages_count);
usb_log_debug("\t\tVALUE: %X", report_item->value);
usb_log_debug("\t\ttUSAGE: %X", report_item->usage);
usb_log_debug("\t\tUSAGE PAGE: %X", report_item->usage_page);
usb_hid_print_usage_path(report_item->collection_path);
}
}
/**
* Prints content of given report descriptor in human readable format.
*
* @param parser Parsed descriptor to print
* @return void
*/
void usb_hid_descriptor_print(usb_hid_report_t *report)
{
if (report == NULL)
return;
list_foreach(report->reports, reports_link,
usb_hid_report_description_t, report_des) {
usb_log_debug("Report ID: %d", report_des->report_id);
usb_log_debug("\tType: %d", report_des->type);
usb_log_debug("\tLength: %zu", report_des->bit_length);
usb_log_debug("\tB Size: %zu",
usb_hid_report_byte_size(report,
report_des->report_id,
report_des->type));
usb_log_debug("\tItems: %zu", report_des->item_length);
usb_hid_descriptor_print_list(&report_des->report_items);
}
}
/** Frees the HID report descriptor parser structure
*
* @param parser Opaque HID report parser structure
* @return void
*/
void usb_hid_report_deinit(usb_hid_report_t *report)
{
if (report == NULL) {
return;
}
// free collection paths
link_t *path_link;
usb_hid_report_path_t *path;
while (!list_empty(&report->collection_paths)) {
path_link = list_first(&report->collection_paths);
path = list_get_instance(path_link,
usb_hid_report_path_t, cpath_link);
list_remove(path_link);
usb_hid_report_path_free(path);
}
// free report items
usb_hid_report_description_t *report_des;
usb_hid_report_field_t *field;
while (!list_empty(&report->reports)) {
report_des = list_get_instance(list_first(&report->reports),
usb_hid_report_description_t, reports_link);
list_remove(&report_des->reports_link);
while (!list_empty(&report_des->report_items)) {
field = list_get_instance(
list_first(&report_des->report_items),
usb_hid_report_field_t, ritems_link);
list_remove(&field->ritems_link);
free(field);
}
free(report_des);
}
return;
}
/**
* @}
*/