/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2018, Joyent, Inc. */ #include #include #include #include #include #include /* * hidparser: Parser to generate parse tree for Report Descriptors * in HID devices. */ uint_t hparser_errmask = (uint_t)PRINT_MASK_ALL; uint_t hparser_errlevel = (uint_t)USB_LOG_L1; static usb_log_handle_t hparser_log_handle; /* * Array used to store corresponding strings for the * different item types for debugging. */ char *items[500]; /* Print items */ /* * modload support */ extern struct mod_ops mod_miscops; static struct modlmisc modlmisc = { &mod_miscops, /* Type of module */ "HID Parser" }; static struct modlinkage modlinkage = { MODREV_1, (void *)&modlmisc, NULL }; int _init(void) { int rval = mod_install(&modlinkage); if (rval == 0) { hparser_log_handle = usb_alloc_log_hdl(NULL, "hidparser", &hparser_errlevel, &hparser_errmask, NULL, 0); } return (rval); } int _fini() { int rval = mod_remove(&modlinkage); if (rval == 0) { usb_free_log_hdl(hparser_log_handle); } return (rval); } int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } /* * These functions are used internally in the parser. * local declarations */ static void hidparser_scan(hidparser_tok_t *); static int hidparser_Items(hidparser_tok_t *); static int hidparser_LocalItem(hidparser_tok_t *); static int hidparser_GlobalItem(hidparser_tok_t *); static int hidparser_ItemList(entity_item_t **, hidparser_tok_t *); static int hidparser_ReportDescriptor(entity_item_t **, hidparser_tok_t *); static int hidparser_ReportDescriptorDash(entity_item_t **, hidparser_tok_t *); static int hidparser_MainItem(entity_item_t **, hidparser_tok_t *); static void hidparser_free_attribute_list( entity_attribute_t *); static entity_item_t *hidparser_allocate_entity(hidparser_tok_t *); static void hidparser_add_attribute(hidparser_tok_t *); static entity_attribute_t *hidparser_cp_attribute_list( entity_attribute_t *); static entity_attribute_t *hidparser_find_attribute_end( entity_attribute_t *); static entity_attribute_t *hidparser_alloc_attrib_list(int); static void hidparser_report_err(int, int, int, int, char *); static int hidparser_isvalid_item(int); static entity_attribute_t *hidparser_lookup_attribute(entity_item_t *, int); static void hidparser_global_err_check(entity_item_t *); static void hidparser_local_err_check(entity_item_t *); static void hidparser_mainitem_err_check(entity_item_t *); static unsigned int hidparser_find_unsigned_val( entity_attribute_t *); static int hidparser_find_signed_val( entity_attribute_t *); static void hidparser_check_correspondence( entity_item_t *, int, int, int, int, char *, char *); static void hidparser_check_minmax_val(entity_item_t *, int, int, int, int); static void hidparser_check_minmax_val_signed( entity_item_t *, int, int, int, int); static void hidparser_error_delim(entity_item_t *, int); static int hidparser_get_usage_attribute_report_des( entity_item_t *, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int32_t *); static int hidparser_get_packet_size_report_des( entity_item_t *, uint32_t, uint32_t, uint32_t *); static int hidparser_get_main_item_data_descr_main( entity_item_t *, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t *); static void hidparser_print_entity( entity_item_t *entity, int indent_level); static void hidparser_print_this_attribute( entity_attribute_t *attribute, char *ident_space); static int hidparser_main(unsigned char *, size_t, entity_item_t **); static void hidparser_initialize_items(); static void hidparser_free_report_descr_handle( entity_item_t *); static int hidparser_print_report_descr_handle( entity_item_t *handle, int indent_level); static int hidparser_get_usage_list_in_order_internal( entity_item_t *parse_handle, uint_t collection_usage, uint_t report_id, uint_t main_item_type, hidparser_rpt_t *rpt); static void hidparser_fill_usage_info( hidparser_usage_info_t *ui, entity_attribute_t *attribute); static int hidparser_get_report_id_list_internal( entity_item_t *parser_handle, uint_t main_item_type, hidparser_report_id_list_t *id_lst); /* * The hidparser_lookup_first(N) of a non-terminal N is stored as an array of * integer tokens, terminated by 0. Right now there is only one element. */ static hidparser_terminal_t first_Items[] = { R_ITEM_USAGE_PAGE, R_ITEM_LOGICAL_MINIMUM, R_ITEM_LOGICAL_MAXIMUM, \ R_ITEM_PHYSICAL_MINIMUM, R_ITEM_PHYSICAL_MAXIMUM, R_ITEM_UNIT, \ R_ITEM_EXPONENT, R_ITEM_REPORT_SIZE, R_ITEM_REPORT_COUNT, \ R_ITEM_REPORT_ID, \ R_ITEM_USAGE, R_ITEM_USAGE_MIN, R_ITEM_USAGE_MAX, \ R_ITEM_DESIGNATOR_INDEX, \ R_ITEM_DESIGNATOR_MIN, R_ITEM_STRING_INDEX, R_ITEM_STRING_MIN, \ R_ITEM_STRING_MAX, \ R_ITEM_SET_DELIMITER, \ 0 }; /* * Each non-terminal is represented by a function. In a top-down parser, * whenever a non-terminal is encountered on the state diagram, the * corresponding function is called. Because of the grammar, there is NO * backtracking. If there is an error in the middle, the parser returns * HIDPARSER_FAILURE */ static hidparser_terminal_t *hid_first_list[] = { first_Items }; /* * hidparser_parse_report_descriptor: * Calls the main parser routine */ int hidparser_parse_report_descriptor( unsigned char *descriptor, size_t size, usb_hid_descr_t *hid_descriptor, hidparser_handle_t *parse_handle) { int error = 0; entity_item_t *root; hidparser_initialize_items(); error = hidparser_main(descriptor, size, &root); if (error != HIDPARSER_SUCCESS) { return (HIDPARSER_FAILURE); } else { *parse_handle = kmem_zalloc( sizeof (hidparser_handle), KM_SLEEP); (*parse_handle)->hidparser_handle_hid_descr = hid_descriptor; (*parse_handle)->hidparser_handle_parse_tree = root; return (HIDPARSER_SUCCESS); } } /* * hidparser_free_report_descriptor_handle: * Frees the parse_handle which consists of a pointer to the parse * tree and a pointer to the Hid descriptor structure */ int hidparser_free_report_descriptor_handle(hidparser_handle_t parse_handle) { if (parse_handle != NULL) { hidparser_free_report_descr_handle( parse_handle->hidparser_handle_parse_tree); if (parse_handle != NULL) { kmem_free(parse_handle, sizeof (hidparser_handle)); } } return (HIDPARSER_SUCCESS); } /* * hidparser_get_country_code: * Return the bCountryCode from the Hid Descriptor * to the hid module. */ int hidparser_get_country_code(hidparser_handle_t parser_handle, uint16_t *country_code) { if ((parser_handle == NULL) || (parser_handle->hidparser_handle_hid_descr == NULL)) { return (HIDPARSER_FAILURE); } *country_code = parser_handle->hidparser_handle_hid_descr->bCountryCode; return (HIDPARSER_SUCCESS); } /* * hidparser_get_packet_size: * Get the packet size(sum of REPORT_SIZE * REPORT_COUNT) * corresponding to a report id and an item type */ int hidparser_get_packet_size(hidparser_handle_t parser_handle, uint_t report_id, uint_t main_item_type, uint_t *size) { if ((parser_handle == NULL) || (parser_handle-> hidparser_handle_parse_tree == NULL)) { return (HIDPARSER_FAILURE); } *size = 0; return (hidparser_get_packet_size_report_des( parser_handle->hidparser_handle_parse_tree, report_id, main_item_type, size)); } /* * hidparser_get_packet_size_report_des: * Get the packet size(sum of REPORT_SIZE * REPORT_COUNT) * corresponding to a report id and an item type */ int hidparser_get_packet_size_report_des(entity_item_t *parser_handle, uint32_t report_id, uint32_t main_item_type, uint32_t *size) { entity_item_t *current = parser_handle; entity_attribute_t *attribute; uint32_t temp; uchar_t foundsize, foundcount, foundreportid, right_report_id; foundsize = 0; foundcount = 0; right_report_id = 0; while (current) { if (current->entity_item_type == R_ITEM_COLLECTION) { (void) hidparser_get_packet_size_report_des( current->info.child, report_id, main_item_type, size); } else if (current->entity_item_type == main_item_type) { temp = 1; foundsize = 0; foundcount = 0; foundreportid = 0; attribute = current->entity_item_attributes; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_REPORT_ID) { foundreportid = 1; if ((attribute-> entity_attribute_value[0]) == report_id) { right_report_id = 1; } } else if (attribute->entity_attribute_tag == R_ITEM_REPORT_SIZE) { foundsize = 1; temp *= hidparser_find_unsigned_val( attribute); if (foundcount == 1) { if (report_id && right_report_id) { break; } } } else if (attribute->entity_attribute_tag == R_ITEM_REPORT_COUNT) { foundcount = 1; temp *= hidparser_find_unsigned_val( attribute); if (foundsize == 1) { if (report_id && right_report_id) { break; } } } attribute = attribute->entity_attribute_next; } /* end while */ if (foundreportid) { if (right_report_id) { *size = *size + temp; } } else if (report_id == HID_REPORT_ID_UNDEFINED) { /* Just sanity checking */ *size = *size + temp; } right_report_id = 0; } /* end else if */ current = current->entity_item_right_sibling; } /* end while current */ return (HIDPARSER_SUCCESS); } /* * hidparser_get_usage_attribute: * Get the attribute value corresponding to a particular * report id, main item and usage */ int hidparser_get_usage_attribute(hidparser_handle_t parser_handle, uint_t report_id, uint_t main_item_type, uint_t usage_page, uint_t usage_id, uint_t usage_attribute, int *usage_attribute_value) { return (hidparser_get_usage_attribute_report_des( parser_handle->hidparser_handle_parse_tree, report_id, main_item_type, usage_page, usage_id, usage_attribute, usage_attribute_value)); } /* * hidparser_get_usage_attribute_report_des: * Called by the wrapper function hidparser_get_usage_attribute() */ static int hidparser_get_usage_attribute_report_des(entity_item_t *parser_handle, uint_t report_id, uint_t main_item_type, uint_t usage_page, uint_t usage_id, uint_t usage_attribute, int *usage_attribute_value) { entity_item_t *current = parser_handle; entity_attribute_t *attribute; uchar_t found_page, found_ret_value, found_usage_id; uchar_t foundreportid, right_report_id; uint32_t usage; short attvalue; found_page = 0; found_ret_value = 0; found_usage_id = 0; foundreportid = 0; right_report_id = 0; while (current) { if (usage_id == HID_USAGE_UNDEFINED) { found_usage_id = 1; } if (current->entity_item_type == R_ITEM_COLLECTION) { if (hidparser_get_usage_attribute_report_des( current->info.child, report_id, main_item_type, usage_page, usage_id, usage_attribute, usage_attribute_value) == HIDPARSER_SUCCESS) { return (HIDPARSER_SUCCESS); } } else if (current->entity_item_type == main_item_type) { /* Match Item Type */ attribute = current->entity_item_attributes; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_USAGE) { usage = hidparser_find_unsigned_val( attribute); if (usage_id == HID_USAGE_ID(usage)) { found_usage_id = 1; } else { /* * If we are trying to find out * say, report size of usage = * 0, a m.i with a valid usage * will not contain that */ if (usage_id == HID_USAGE_UNDEFINED) { found_usage_id = 0; } } if (found_usage_id && attribute-> entity_attribute_length == 3) { /* * This is an extended usage ie. * usage page in upper 16 bits * or-ed with usage in the lower * 16 bits. */ if (HID_USAGE_PAGE(usage) && HID_USAGE_PAGE(usage) == usage_page) { found_page = 1; } else { found_usage_id = 0; } } } else if (attribute->entity_attribute_tag == R_ITEM_USAGE_PAGE) { if (attribute-> entity_attribute_value[0] == usage_page) { /* Match Usage Page */ found_page = 1; } } else if (attribute->entity_attribute_tag == R_ITEM_REPORT_ID) { foundreportid = 1; if (attribute-> entity_attribute_value[0] == report_id) { right_report_id = 1; } } if (attribute->entity_attribute_tag == usage_attribute) { /* Match attribute */ found_ret_value = 1; *usage_attribute_value = attribute->entity_attribute_value[0]; if (attribute-> entity_attribute_length == 2) { attvalue = (attribute-> entity_attribute_value[0] & 0xff) | (attribute-> entity_attribute_value[1] << 8); *usage_attribute_value = attvalue; } } attribute = attribute->entity_attribute_next; } if (found_usage_id && found_page && found_ret_value) { if (foundreportid) { if (right_report_id) { return (HIDPARSER_SUCCESS); } else if (report_id == HID_REPORT_ID_UNDEFINED) { return (HIDPARSER_SUCCESS); } } else { return (HIDPARSER_SUCCESS); } } } /* * search the next main item, right sibling of this one */ if (current->entity_item_right_sibling != NULL) { current = current->entity_item_right_sibling; found_usage_id = found_page = found_ret_value = 0; /* Don't change foundreportid */ right_report_id = 0; } else { break; } } /* Don't give junk result */ *usage_attribute_value = 0; return (HIDPARSER_NOT_FOUND); } /* * hidparser_get_main_item_data_descr: * Get the data value corresponding to a particular * Main Item (Input, Output, Feature) */ int hidparser_get_main_item_data_descr(hidparser_handle_t parser_handle, uint_t report_id, uint_t main_item_type, uint_t usage_page, uint_t usage_id, uint_t *main_item_descr_value) { return hidparser_get_main_item_data_descr_main( parser_handle->hidparser_handle_parse_tree, report_id, main_item_type, usage_page, usage_id, main_item_descr_value); } /* * hidparser_get_main_item_data_descr_main: * Called by the wrapper function hidparser_get_main_item_data_descr() */ static int hidparser_get_main_item_data_descr_main(entity_item_t *parser_handle, uint_t report_id, uint_t main_item_type, uint_t usage_page, uint_t usage_id, uint_t *main_item_descr_value) { entity_item_t *current = parser_handle; entity_attribute_t *attribute; uchar_t found_page, found_usage_id; uchar_t foundreportid, right_report_id; uint32_t usage; found_page = 0; found_usage_id = 0; foundreportid = 0; right_report_id = 0; while (current) { if (usage_id == HID_USAGE_UNDEFINED) { found_usage_id = 1; } if (current->entity_item_type == R_ITEM_COLLECTION) { if (hidparser_get_main_item_data_descr_main( current->info.child, report_id, main_item_type, usage_page, usage_id, main_item_descr_value) == HIDPARSER_SUCCESS) { return (HIDPARSER_SUCCESS); } } else if (current->entity_item_type == main_item_type) { /* Match Item Type */ attribute = current->entity_item_attributes; if (report_id == HID_REPORT_ID_UNDEFINED) { foundreportid = right_report_id = 1; } while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_USAGE) { usage = hidparser_find_unsigned_val( attribute); if (usage_id == HID_USAGE_ID(usage)) { found_usage_id = 1; if (attribute-> entity_attribute_length == 3) { if (HID_USAGE_PAGE( usage) && HID_USAGE_PAGE( usage) == usage_page) { found_page = 1; } else { found_usage_id = 0; } } if (found_usage_id && found_page && foundreportid && right_report_id) { *main_item_descr_value = current-> entity_item_params[0]; break; } } } else if ((attribute->entity_attribute_tag == R_ITEM_USAGE_PAGE) && (attribute->entity_attribute_value[0] == usage_page)) { /* Match Usage Page */ found_page = 1; if (found_usage_id && foundreportid && right_report_id) { *main_item_descr_value = current-> entity_item_params[0]; break; } } else if (attribute->entity_attribute_tag == R_ITEM_REPORT_ID) { foundreportid = 1; if (attribute-> entity_attribute_value[0] == report_id) { right_report_id = 1; } else { break; } } attribute = attribute->entity_attribute_next; } if (foundreportid) { if (right_report_id) { if (found_usage_id && found_page) { return (HIDPARSER_SUCCESS); } } } } /* * search the next main item, right sibling of this one */ if (current->entity_item_right_sibling != NULL) { current = current->entity_item_right_sibling; found_page = found_usage_id = right_report_id = 0; } else { break; } } *main_item_descr_value = (uint_t)NULL; return (HIDPARSER_NOT_FOUND); } /* * hidparser_lookup_usage_collection: * Look up the collection specified by the usage page and usage id */ int hidparser_lookup_usage_collection(hidparser_handle_t parse_handle, uint_t lusage_page, uint_t lusage_id) { entity_item_t *current; entity_attribute_t *attribute; int found_usage_id = 0; int found_page = 0; uint32_t usage; uint_t usage_page; uint_t usage_id; if ((parse_handle == NULL) || (parse_handle->hidparser_handle_parse_tree == NULL)) return (HIDPARSER_FAILURE); current = parse_handle->hidparser_handle_parse_tree; while (current != NULL) { if (current->entity_item_type != R_ITEM_COLLECTION) { current = current->entity_item_right_sibling; continue; } attribute = current->entity_item_attributes; found_usage_id = 0; found_page = 0; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_USAGE) { found_usage_id = 1; usage = hidparser_find_unsigned_val(attribute); usage_id = HID_USAGE_ID(usage); if (attribute->entity_attribute_length == 3) { if (HID_USAGE_PAGE(usage)) { found_page = 1; usage_page = HID_USAGE_PAGE(usage); } } if (found_page) { goto check_usage; } } else if (attribute->entity_attribute_tag == R_ITEM_USAGE_PAGE) { found_page = 1; usage_page = attribute->entity_attribute_value[0]; if (found_usage_id) { goto check_usage; } } attribute = attribute->entity_attribute_next; } check_usage: if ((usage_page == lusage_page) && (usage_id == lusage_id)) return (HIDPARSER_SUCCESS); else current = current->entity_item_right_sibling; } return (HIDPARSER_FAILURE); } /* * hidparser_get_top_level_collection_usage: * Get the usage page and usage for the top level collection item */ int hidparser_get_top_level_collection_usage(hidparser_handle_t parse_handle, uint_t *usage_page, uint_t *usage_id) { entity_item_t *current; entity_attribute_t *attribute; int found_usage_id = 0; int found_page = 0; uint32_t usage; if ((parse_handle == NULL) || (parse_handle->hidparser_handle_parse_tree == NULL)) return (HIDPARSER_FAILURE); current = parse_handle->hidparser_handle_parse_tree; if (current->entity_item_type != R_ITEM_COLLECTION) { return (HIDPARSER_FAILURE); } attribute = current->entity_item_attributes; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_USAGE) { found_usage_id = 1; usage = hidparser_find_unsigned_val(attribute); *usage_id = HID_USAGE_ID(usage); if (attribute->entity_attribute_length == 3) { if (HID_USAGE_PAGE(usage)) { found_page = 1; *usage_page = HID_USAGE_PAGE(usage); } } if (found_usage_id && found_page) { return (HIDPARSER_SUCCESS); } } else if (attribute->entity_attribute_tag == R_ITEM_USAGE_PAGE) { found_page = 1; *usage_page = attribute->entity_attribute_value[0]; if (found_usage_id && found_page) { return (HIDPARSER_SUCCESS); } } attribute = attribute->entity_attribute_next; } return (HIDPARSER_FAILURE); } /* * hidparser_get_usage_list_in_order: * Find all the usages corresponding to a main item and report id. * Note that only short items are supported. * * Arguments: * parser_handle: * hid parser handle * report id: * report id of the particular report where the usages belong to * main_item_type: * type of report, either Input, Output, or Feature * usage_list: * Filled in with the pointer to the first element of the * usage list * * Return values: * HIDPARSER_SUCCESS - returned success * HIDPARSER_NOT_FOUND - usage specified by the parameters was not found * HIDPARSER_FAILURE - unspecified failure */ int hidparser_get_usage_list_in_order(hidparser_handle_t parser_handle, uint_t report_id, uint_t main_item_type, hidparser_rpt_t *rpt) { if ((parser_handle == NULL) || (parser_handle->hidparser_handle_parse_tree == NULL)) { return (HIDPARSER_FAILURE); } rpt->no_of_usages = 0; return (hidparser_get_usage_list_in_order_internal( parser_handle->hidparser_handle_parse_tree, HID_USAGE_UNDEFINED, report_id, main_item_type, rpt)); } static int hidparser_get_usage_list_in_order_internal(entity_item_t *parser_handle, uint_t collection_usage, uint_t report_id, uint_t main_item_type, hidparser_rpt_t *rpt) { /* setup wrapper function */ entity_item_t *current = parser_handle; entity_attribute_t *attribute; uchar_t foundreportid, right_report_id, valid_usage; uchar_t found_usage_min, found_usage_max, found_usage; int i, j; int rval; uint32_t usage, usage_min, usage_max, usage_id[USAGE_MAX]; hidparser_usage_info_t *ui; found_usage_min = 0; found_usage_max = 0; foundreportid = 0; right_report_id = 0; while (current) { if (current->entity_item_type == R_ITEM_COLLECTION) { /* * find collection usage information for this * collection */ valid_usage = 0; attribute = current->entity_item_attributes; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_USAGE) { usage = hidparser_find_unsigned_val( attribute); valid_usage = 1; } attribute = attribute->entity_attribute_next; } if (!valid_usage) { usage = HID_USAGE_UNDEFINED; } rval = hidparser_get_usage_list_in_order_internal( current->info.child, usage, report_id, main_item_type, rpt); if (rval != HIDPARSER_SUCCESS) { return (rval); } } else if (current->entity_item_type == main_item_type) { /* Match Item Type */ foundreportid = 0; right_report_id = 0; found_usage_min = 0; found_usage_max = 0; found_usage = 0; valid_usage = 0; attribute = current->entity_item_attributes; while (attribute != NULL) { switch (attribute->entity_attribute_tag) { case R_ITEM_REPORT_ID: foundreportid = 1; if (attribute-> entity_attribute_value[0] == report_id) { right_report_id = 1; } else { /* different report id */ valid_usage = 1; } break; case R_ITEM_USAGE: if (found_usage >= USAGE_MAX) { return (HIDPARSER_FAILURE); } usage = hidparser_find_unsigned_val( attribute); if (usage) { usage_id[found_usage] = usage; found_usage++; } break; case R_ITEM_USAGE_MIN: found_usage_min = 1; usage_min = hidparser_find_unsigned_val( attribute); break; case R_ITEM_USAGE_MAX: found_usage_max = 1; usage_max = hidparser_find_unsigned_val( attribute); break; case R_ITEM_SET_DELIMITER: /* skip over alternate usages */ do { attribute = attribute-> entity_attribute_next; } while (attribute-> entity_attribute_tag != R_ITEM_SET_DELIMITER); break; } attribute = attribute->entity_attribute_next; } /* * If we have a report id match (or report ids * are not present), and have a usage item or * usage min&max, put the usage item into the * list. Don't put undefined usage items * (HID_USAGE_UNDEFINED, 0) into the list; * a 0 usage item is used to match padding * fields that don't have an attached usage. */ if (!foundreportid || (foundreportid && right_report_id)) { for (j = 0; j < found_usage; j++) { /* Put in usage list */ if (rpt->no_of_usages >= USAGE_MAX) { return (HIDPARSER_FAILURE); } i = rpt->no_of_usages++; ui = &(rpt->usage_descr[i]); hidparser_fill_usage_info(ui, current->entity_item_attributes); ui->rptcnt /= found_usage; ui->collection_usage = collection_usage; ui->usage_id = HID_USAGE_ID( usage_id[j]); /* * This is an extended usage ie. * usage page in upper 16 bits * or-ed with usage in the lower * 16 bits. */ if (usage_id[j] >> 16) { ui->usage_page = HID_USAGE_PAGE(usage_id[j]); } rpt->report_id = report_id; valid_usage = 1; } if (found_usage_min && found_usage_max) { /* Put in usage list */ if (rpt->no_of_usages >= USAGE_MAX) { return (HIDPARSER_FAILURE); } if (found_usage) { /* handle duplication */ ui->usage_min = HID_USAGE_ID( usage_min); ui->usage_max = HID_USAGE_ID( usage_max); } else { i = rpt->no_of_usages++; ui = &(rpt->usage_descr[i]); hidparser_fill_usage_info(ui, current-> entity_item_attributes); ui->collection_usage = collection_usage; ui->usage_min = HID_USAGE_ID( usage_min); ui->usage_max = HID_USAGE_ID( usage_max); rpt->report_id = report_id; valid_usage = 1; } /* * This is an extended usage ie. * usage page in upper 16 bits * or-ed with usage_max in the lower * 16 bits. */ if (usage_max >> 16) { ui->usage_page = HID_USAGE_PAGE(usage_max); } } } /* * This main item contains no usage * Fill in with usage "UNDEFINED". * If report id is valid, only the * main item with matched report id * can be filled in. */ if (!valid_usage) { if (rpt->no_of_usages >= USAGE_MAX) { return (HIDPARSER_FAILURE); } i = rpt->no_of_usages++; ui = &(rpt->usage_descr[i]); hidparser_fill_usage_info(ui, current->entity_item_attributes); ui->collection_usage = collection_usage; ui->usage_id = HID_USAGE_UNDEFINED; rpt->report_id = report_id; } } current = current->entity_item_right_sibling; } /* end while current */ return (HIDPARSER_SUCCESS); } /* * hidparser_fill_usage_info(): * Fill in the mandatory item information for a main item. * See HID 6.2.2. */ static void hidparser_fill_usage_info(hidparser_usage_info_t *ui, entity_attribute_t *attribute) { bzero(ui, sizeof (*ui)); while (attribute) { switch (attribute->entity_attribute_tag) { case R_ITEM_LOGICAL_MINIMUM: ui->lmin = hidparser_find_signed_val(attribute); break; case R_ITEM_LOGICAL_MAXIMUM: ui->lmax = hidparser_find_signed_val(attribute); break; case R_ITEM_REPORT_COUNT: ui->rptcnt = hidparser_find_unsigned_val(attribute); break; case R_ITEM_REPORT_SIZE: ui->rptsz = hidparser_find_unsigned_val(attribute); break; case R_ITEM_USAGE_PAGE: ui->usage_page = hidparser_find_unsigned_val(attribute) & 0xffff; break; } attribute = attribute->entity_attribute_next; } } /* * hidparser_get_report_id_list: * Return a list of all report ids used for descriptor items * corresponding to a main item. * * Arguments: * parser_handle: * hid parser handle * main_item_type: * type of report, either Input, Output, or Feature * report_id_list: * Filled in with a list of report ids found in the descriptor * * Return values: * HIDPARSER_SUCCESS - returned success * HIDPARSER_FAILURE - unspecified failure */ int hidparser_get_report_id_list(hidparser_handle_t parser_handle, uint_t main_item_type, hidparser_report_id_list_t *report_id_list) { if ((parser_handle == NULL) || (parser_handle->hidparser_handle_parse_tree == NULL)) { return (HIDPARSER_FAILURE); } report_id_list->no_of_report_ids = 0; return (hidparser_get_report_id_list_internal( parser_handle->hidparser_handle_parse_tree, main_item_type, report_id_list)); } /* * hidparser_get_report_id_list_internal: * internal function that generates list of all report ids */ int hidparser_get_report_id_list_internal( entity_item_t *parser_handle, uint_t main_item_type, hidparser_report_id_list_t *id_lst) { /* setup wrapper function */ entity_item_t *current = parser_handle; entity_attribute_t *attribute; uint_t report_id = 0; int i = 0; int rval; while (current) { if (current->entity_item_type == R_ITEM_COLLECTION) { rval = hidparser_get_report_id_list_internal( current->info.child, main_item_type, id_lst); if (rval != HIDPARSER_SUCCESS) { return (rval); } } else if (current->entity_item_type == main_item_type) { /* Match Item Type */ attribute = current->entity_item_attributes; while (attribute != NULL) { if (attribute->entity_attribute_tag == R_ITEM_REPORT_ID) { /* Found a Report ID */ report_id = attribute-> entity_attribute_value[0]; /* Report ID already in list? */ for (i = 0; i < id_lst->no_of_report_ids; i++) { if (report_id == id_lst-> report_id[i]) { break; } } if (i >= id_lst->no_of_report_ids) { /* * New Report ID found, put * in list */ if (i >= REPORT_ID_MAX) { return (HIDPARSER_FAILURE); } id_lst->report_id[i] = report_id; id_lst->no_of_report_ids++; } } attribute = attribute->entity_attribute_next; } } current = current->entity_item_right_sibling; } /* end while current */ return (HIDPARSER_SUCCESS); } /* * hidparser_print_report_descr_handle: * Functions to print the parse tree. Currently not * being called. */ static int hidparser_print_report_descr_handle(entity_item_t *handle, int indent_level) { entity_item_t *current = handle; while (current) { if (current->info.child) { hidparser_print_entity(current, indent_level); /* do children */ (void) hidparser_print_report_descr_handle( current->info.child, indent_level+1); } else /* just a regular entity */ { hidparser_print_entity(current, indent_level); } current = current->entity_item_right_sibling; } return (HIDPARSER_SUCCESS); } #define SPACE_PER_LEVEL 5 /* * hidparser_print_entity ; * Prints the entity items recursively */ static void hidparser_print_entity(entity_item_t *entity, int indent_level) { char indent_space[256]; int count; entity_attribute_t *attr; indent_level *= SPACE_PER_LEVEL; for (count = 0; indent_level--; count++) indent_space[count] = ' '; indent_space[count] = 0; attr = entity->entity_item_attributes; while (attr) { hidparser_print_this_attribute(attr, indent_space); attr = attr->entity_attribute_next; } USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "%s%s(0x%x)", indent_space, items[entity->entity_item_type], (entity->entity_item_params_leng ? entity->entity_item_params[0] & 0xFF : 0x00)); } /* * hidparser_print_this_attribute: * Prints the attribute passed in the argument */ static void hidparser_print_this_attribute(entity_attribute_t *attribute, char *ident_space) { if (ident_space == NULL) { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "%s(0x%X)", items[attribute->entity_attribute_tag], hidparser_find_unsigned_val(attribute)); } else { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "%s%s(0x%X)", ident_space, items[attribute->entity_attribute_tag], hidparser_find_unsigned_val(attribute)); } } /* * The next few functions will be used for parsing using the * grammar: * * Start -> ReportDescriptor * * ReportDescriptor -> ItemList * * ItemList -> Items MainItem ItemList * | epsilon * * MainItem -> BeginCollection ItemList EndCollection * | Input * | Output * | Feature * * Items -> GlobalItem Items * | LocalItem Items * | SetDelimiterOpen LocalItemList * SetDelimiterClose Items * | epsilon * * LocalItemList -> LocalItem Temp2 * * Temp2 -> LocalItem Temp2 * | epsilon * * GlobalItem -> UsagePage * | LogicalMinimum * | LogicalMaximum * | PhysicalMinimum * | PhysicalMaximum * | Unit * | Exponent * | ReportSize * | ReportCount * | ReportID * * LocalItem -> Usage * | UsageMinimum * | UsageMaximum * | DesignatorIndex * | DesignatorMinimum * | StringIndex * | StringMinimum * | StringMaximum * */ /* * hidparser_lookup_first: * Looks up if token belongs to the FIRST of the function tag * that is passed through the first argument */ static int hidparser_lookup_first(int func_index, int token) { int *itemp; itemp = hid_first_list[func_index]; while (*itemp != 0) { /* get the next terminal on the list */ if (*itemp == token) { return (HIDPARSER_SUCCESS); } itemp++; } /* token is not on the FIRST list */ return (HIDPARSER_FAILURE); } /* * hidparser_main: * Function called from hidparser_parse_report_descriptor() * to parse the Report Descriptor */ static int hidparser_main(unsigned char *descriptor, size_t size, entity_item_t **item_ptr) { hidparser_tok_t *scan_ifp; int retval; scan_ifp = kmem_zalloc(sizeof (hidparser_tok_t), KM_SLEEP); scan_ifp->hidparser_tok_text = kmem_zalloc(HIDPARSER_TEXT_LENGTH, KM_SLEEP); scan_ifp->hidparser_tok_max_bsize = size; scan_ifp->hidparser_tok_entity_descriptor = descriptor; *item_ptr = NULL; retval = hidparser_ReportDescriptorDash(item_ptr, scan_ifp); /* * Free the Local & Global item list * It maybe the case that no tree has been built * up but there have been allocation in the attribute * & control lists */ if (scan_ifp->hidparser_tok_gitem_head) { hidparser_free_attribute_list( scan_ifp->hidparser_tok_gitem_head); } if (scan_ifp->hidparser_tok_litem_head) { hidparser_free_attribute_list( scan_ifp->hidparser_tok_litem_head); } kmem_free(scan_ifp->hidparser_tok_text, HIDPARSER_TEXT_LENGTH); kmem_free(scan_ifp, sizeof (hidparser_tok_t)); return (retval); } /* * hidparser_ReportDescriptorDash: * Synthetic start symbol, implements * hidparser_ReportDescriptor */ static int hidparser_ReportDescriptorDash(entity_item_t ** item_ptr, hidparser_tok_t *scan_ifp) { if ((hidparser_ReportDescriptor(item_ptr, scan_ifp) == HIDPARSER_SUCCESS) && (scan_ifp->hidparser_tok_token == 0)) { return (HIDPARSER_SUCCESS); } /* * In case of failure, free the kernel memory * allocated for partial building of the tree, * if any */ if (*item_ptr != NULL) { (void) hidparser_free_report_descr_handle(*item_ptr); } *item_ptr = NULL; return (HIDPARSER_FAILURE); } /* * hidparser_ReportDescriptor: * Implements the Rule: * ReportDescriptor -> ItemList */ static int hidparser_ReportDescriptor(entity_item_t ** item_ptr, hidparser_tok_t *scan_ifp) { hidparser_scan(scan_ifp); /* * We do not search for the token in FIRST(ReportDescriptor) * since - * * FIRST(ReportDescriptor) == FIRST(ItemList) * ReportDescriptor ----> ItemList */ if (hidparser_ItemList(item_ptr, scan_ifp) == HIDPARSER_SUCCESS) { return (HIDPARSER_SUCCESS); } return (HIDPARSER_FAILURE); } /* * hidparser_ItemList: * Implements the Rule: * ItemList -> Items MainItem ItemList | epsilon * * This function constructs the tree on which depends the "hidparser" * consumer functions. Basically the structure of the tree is * * C--[RS]->EC--[RS]->C--[RS]->EC..(and so on) * | * [CH] <== This relationship is true for other "C's" * | also. * v * C/-------------/I/O/F <== [ Any of these ] * | ------ * | | * v v * [CH | RS] [ RS ] * C/I/O/F | EC I/O/F * | * | * and so on... * * where C = Collection * EC = EndCollection * I = Input * O = Output * F = Feature "Main" Items. * * and the relationships are [RS] for right sibling and [CH] for * child. [CH | RS ] stands for "child or right sibling" with the * possible values below it. */ static int hidparser_ItemList(entity_item_t ** item_ptr, hidparser_tok_t *scan_ifp) { entity_item_t *curr_ei, *cache_ei, *prev_ei, *tmp_ei; boolean_t root_coll = B_FALSE; curr_ei = cache_ei = prev_ei = tmp_ei = NULL; while (scan_ifp->hidparser_tok_token != 0) { if (hidparser_Items(scan_ifp) == HIDPARSER_FAILURE) { return (HIDPARSER_FAILURE); } if (hidparser_MainItem(&curr_ei, scan_ifp) == HIDPARSER_FAILURE) { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Invalid MAIN item 0x%x in input stream", scan_ifp->hidparser_tok_token); return (HIDPARSER_FAILURE); } if (curr_ei->entity_item_type == R_ITEM_COLLECTION) { if (root_coll == B_FALSE) { *item_ptr = curr_ei; root_coll = B_TRUE; } curr_ei->prev_coll = cache_ei; cache_ei = curr_ei; USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "Start Collection:cache_ei = 0x%p," " curr_ei = 0x%p", (void *)cache_ei, (void *)curr_ei); if (prev_ei == NULL) { prev_ei = curr_ei; continue; } if (prev_ei->entity_item_type == R_ITEM_COLLECTION) { prev_ei->info.child = curr_ei; } else { prev_ei->entity_item_right_sibling = curr_ei; } } else if (curr_ei->entity_item_type == R_ITEM_END_COLLECTION) { tmp_ei = cache_ei->prev_coll; cache_ei->entity_item_right_sibling = curr_ei; USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "End Collection: cache_ei = 0x%p, " "curr_ei = 0x%p", (void *)cache_ei, (void *)curr_ei); if (tmp_ei != NULL) { /* * As will be the case for final end * collection. */ cache_ei = tmp_ei; } tmp_ei = NULL; } else { if (prev_ei == NULL) { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Invalid First MAIN item 0x%x", scan_ifp->hidparser_tok_token); return (HIDPARSER_FAILURE); } if (prev_ei->entity_item_type == R_ITEM_COLLECTION) { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "Main Item: token = 0x%x, " "curr_ei = 0x%p " "will be the child of prev_ei " "= 0x%p, " "cache_ei being 0x%p", curr_ei->entity_item_type, (void *)curr_ei, (void *)prev_ei, (void *)cache_ei); prev_ei->info.child = curr_ei; } else { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "Main Item: token = 0x%x, " "curr_ei = 0x%p " "will be the right sibling of " "prev_ei = 0x%p, " "cache_ei being 0x%p", curr_ei->entity_item_type, (void *)curr_ei, (void *)prev_ei, (void *)cache_ei); prev_ei->entity_item_right_sibling = curr_ei; } } prev_ei = curr_ei; } if (*item_ptr != cache_ei) { /* Something wrong happened */ USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Failed to parse report descriptor"); return (HIDPARSER_FAILURE); } (void) hidparser_print_report_descr_handle(cache_ei, 0); return (HIDPARSER_SUCCESS); } /* * hidparser_MainItem: * Implements the Rule: * MainItem -> BeginCollection ItemList EndCollection * | Input * | Output * | Feature */ static int hidparser_MainItem(entity_item_t ** item_ptr, hidparser_tok_t *scan_ifp) { switch (scan_ifp->hidparser_tok_token) { case R_ITEM_INPUT: /* FALLTHRU */ case R_ITEM_OUTPUT: /* FALLTHRU */ case R_ITEM_FEATURE: case R_ITEM_COLLECTION: case R_ITEM_END_COLLECTION: *item_ptr = hidparser_allocate_entity(scan_ifp); USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "hidparser_MainItem:index = 0x%lx token = 0x%x", scan_ifp->hidparser_tok_index - (*item_ptr)->entity_item_params_leng - 1, scan_ifp->hidparser_tok_token); hidparser_scan(scan_ifp); hidparser_global_err_check(*item_ptr); hidparser_local_err_check(*item_ptr); hidparser_mainitem_err_check(*item_ptr); return (HIDPARSER_SUCCESS); default: break; } *item_ptr = NULL; return (HIDPARSER_FAILURE); } /* * hidparser_Items: * Implements the Rule: * Items -> GlobalItem Items * | LocalItem Items * | SetDelimiterOpen LocalItemList * SetDelimiterClose Items * | epsilon */ static int hidparser_Items(hidparser_tok_t *scan_ifp) { boolean_t delim_pre = B_FALSE; int token = scan_ifp->hidparser_tok_token; while (hidparser_lookup_first(HIDPARSER_ITEMS, token) == HIDPARSER_SUCCESS) { if (token == R_ITEM_SET_DELIMITER) { if (delim_pre == B_FALSE) { if (scan_ifp->hidparser_tok_text[0] != 1) { hidparser_error_delim(NULL, HIDPARSER_DELIM_ERR1); } else { delim_pre = B_TRUE; } } else { if (scan_ifp->hidparser_tok_text[0] != 0) { hidparser_error_delim(NULL, HIDPARSER_DELIM_ERR2); } else { delim_pre = B_FALSE; } } (void) hidparser_LocalItem(scan_ifp); token = scan_ifp->hidparser_tok_token; } else if (hidparser_GlobalItem(scan_ifp) == HIDPARSER_SUCCESS) { token = scan_ifp->hidparser_tok_token; } else if (hidparser_LocalItem(scan_ifp) == HIDPARSER_SUCCESS) { token = scan_ifp->hidparser_tok_token; } } return (HIDPARSER_SUCCESS); /* epsilon */ } /* * hidparser_GlobalItem: * Implements the Rule: * GlobalItem -> UsagePage * | LogicalMinimum * | LocgicalMaximum * | PhysicalMinimum * | PhysicalMaximum * | Unit * | Exponent * | ReportSize * | ReportCount * | ReportID */ static int hidparser_GlobalItem(hidparser_tok_t *scan_ifp) { int i; entity_attribute_stack_t *elem; switch (scan_ifp->hidparser_tok_token) { case R_ITEM_USAGE_PAGE: /* Error check */ for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) { /* Undefined data value: 0 */ if (scan_ifp->hidparser_tok_text[i] == 0) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, R_ITEM_USAGE_PAGE, 0, "Data field should be non-Zero"); } /* Reserved values 0x0A-0xFE */ else if ((scan_ifp->hidparser_tok_text[i] >= 0x0a) && (scan_ifp->hidparser_tok_text[i] <= 0xFE)) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, R_ITEM_USAGE_PAGE, 1, "Data field should not use " "reserved values"); } } break; case R_ITEM_UNIT: /* FALLTHRU */ case R_ITEM_EXPONENT: /* * Error check: * Nibble 7 should be zero */ if (scan_ifp->hidparser_tok_leng == 4) { if ((scan_ifp->hidparser_tok_text[3] & 0xf0) != 0) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, scan_ifp->hidparser_tok_token, 0, "Data field reserved bits should " "be Zero"); } } break; case R_ITEM_REPORT_COUNT: /* * Error Check: * Report Count should be nonzero */ for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) { if (scan_ifp->hidparser_tok_text[i]) break; } if (i == scan_ifp->hidparser_tok_leng) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_REPORT_COUNT, 0, "Report Count = 0"); } break; case R_ITEM_REPORT_ID: /* * Error check: * Report Id should be nonzero & <= 255 */ if (scan_ifp->hidparser_tok_leng != 1) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_REPORT_ID, 1, "Must be contained in a byte"); } if (!scan_ifp->hidparser_tok_text[0]) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_REPORT_ID, 0, "Report Id must be non-zero"); } break; case R_ITEM_LOGICAL_MINIMUM: break; case R_ITEM_LOGICAL_MAXIMUM: break; case R_ITEM_PHYSICAL_MINIMUM: break; case R_ITEM_PHYSICAL_MAXIMUM: break; case R_ITEM_REPORT_SIZE: break; case R_ITEM_PUSH: if (scan_ifp->hidparser_tok_leng != 0) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, scan_ifp->hidparser_tok_token, 0, "Data Field size should be zero"); } else { elem = (entity_attribute_stack_t *)kmem_zalloc( sizeof (entity_attribute_stack_t), KM_SLEEP); elem->list = hidparser_cp_attribute_list( scan_ifp->hidparser_tok_gitem_head); if (scan_ifp->hidparser_head) { elem->next = scan_ifp->hidparser_head; } scan_ifp->hidparser_head = elem; } break; case R_ITEM_POP: if (scan_ifp->hidparser_tok_leng != 0) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, scan_ifp->hidparser_tok_token, 0, "Data Field size should be zero"); } else { /* Free the current global list */ hidparser_free_attribute_list(scan_ifp-> hidparser_tok_gitem_head); scan_ifp->hidparser_tok_gitem_head = scan_ifp->hidparser_head->list; scan_ifp->hidparser_head->list = NULL; elem = scan_ifp->hidparser_head; scan_ifp->hidparser_head = elem->next; kmem_free(elem, sizeof (entity_attribute_stack_t)); } break; default: return (HIDPARSER_FAILURE); /*NOTREACHED*/ } hidparser_add_attribute(scan_ifp); USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "hidparser_GlobalItem:index = 0x%lx token = 0x%x", scan_ifp->hidparser_tok_index - scan_ifp->hidparser_tok_leng - 1, scan_ifp->hidparser_tok_token); hidparser_scan(scan_ifp); return (HIDPARSER_SUCCESS); } /* * hidparser_LocalItem: * Implements the Rule: * LocalItem -> Usage * | UsageMinimum * | UsageMaximum * | DesignatorIndex * | DesignatorMinimum * | StringIndex * | StringMinimum * | StringMaximum */ static int hidparser_LocalItem(hidparser_tok_t *scan_ifp) { int i; switch (scan_ifp->hidparser_tok_token) { case R_ITEM_USAGE: /* * Error Check: * Data Field should be nonzero */ for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) { if (scan_ifp->hidparser_tok_text[i]) break; } if (i == scan_ifp->hidparser_tok_leng) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, R_ITEM_USAGE, 0, "Data Field should be non-zero"); } /* FALLTHRU */ case R_ITEM_USAGE_MIN: /* FALLTHRU */ case R_ITEM_USAGE_MAX: /* FALLTHRU */ case R_ITEM_DESIGNATOR_INDEX: /* FALLTHRU */ case R_ITEM_DESIGNATOR_MIN: /* FALLTHRU */ case R_ITEM_STRING_INDEX: /* FALLTHRU */ case R_ITEM_STRING_MIN: /* FALLTHRU */ case R_ITEM_STRING_MAX: /* FALLTHRU */ case R_ITEM_SET_DELIMITER: hidparser_add_attribute(scan_ifp); USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "hidparser_LocalItem:index = 0x%lx token = 0x%x", scan_ifp->hidparser_tok_index - scan_ifp->hidparser_tok_leng - 1, scan_ifp->hidparser_tok_token); hidparser_scan(scan_ifp); return (HIDPARSER_SUCCESS); /*NOTREACHED*/ default: break; } return (HIDPARSER_FAILURE); } /* * hidparser_allocate_entity: * Allocate Item of type 'type', length 'leng' and * params 'text'. Fill in the attributes allocated * so far from both the local and global item lists. * Make the child and sibling of the item NULL. */ static entity_item_t * hidparser_allocate_entity(hidparser_tok_t *scan_ifp) { entity_item_t *entity; entity_attribute_t *aend; int entity_type = scan_ifp->hidparser_tok_token; unsigned char *text = scan_ifp->hidparser_tok_text; int len = scan_ifp->hidparser_tok_leng; entity = kmem_zalloc(sizeof (entity_item_t), KM_SLEEP); entity->entity_item_type = entity_type; entity->entity_item_params_leng = len; if (len != 0) { entity->entity_item_params = kmem_zalloc(len, KM_SLEEP); (void) bcopy(text, entity->entity_item_params, len); } /* * Copy attributes from entity attribute state table if not * end collection. */ if (entity_type != R_ITEM_END_COLLECTION) { entity->entity_item_attributes = hidparser_cp_attribute_list( scan_ifp->hidparser_tok_gitem_head); /* * append the control attributes, then clear out the control * attribute state table list */ if (entity->entity_item_attributes) { aend = hidparser_find_attribute_end( entity->entity_item_attributes); aend->entity_attribute_next = scan_ifp->hidparser_tok_litem_head; scan_ifp->hidparser_tok_litem_head = NULL; } else { entity->entity_item_attributes = scan_ifp->hidparser_tok_litem_head; scan_ifp->hidparser_tok_litem_head = NULL; } } entity->info.child = entity->entity_item_right_sibling = 0; return (entity); } /* * hidparser_add_attribute: * Add an attribute to the global or local item list * If the last 4th bit from right is 1, add to the local item list * Else add to the global item list */ static void hidparser_add_attribute(hidparser_tok_t *scan_ifp) { entity_attribute_t *newattrib, **previous, *elem; int entity = scan_ifp->hidparser_tok_token; unsigned char *text = scan_ifp->hidparser_tok_text; int len = scan_ifp->hidparser_tok_leng; if (len == 0) { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "hidparser_add_attribute: len = 0 for item = 0x%x", entity); return; } if (entity & HIDPARSER_ISLOCAL_MASK) { previous = &scan_ifp->hidparser_tok_litem_head; } else { previous = &scan_ifp->hidparser_tok_gitem_head; } elem = *previous; /* * remove attribute if it is already on list, except * for control attributes(local items), as we could have * multiple usages... * unless we want to hassle with checking for unique parameters. */ while (elem) { if (elem->entity_attribute_tag == entity && !(entity & HIDPARSER_ISLOCAL_MASK)) { *previous = elem->entity_attribute_next; kmem_free(elem->entity_attribute_value, elem->entity_attribute_length); kmem_free(elem, sizeof (entity_attribute_t)); elem = *previous; } else { previous = &elem->entity_attribute_next; elem = elem->entity_attribute_next; } } /* create new attribute for this entry */ newattrib = hidparser_alloc_attrib_list(1); newattrib->entity_attribute_tag = entity; newattrib->entity_attribute_value = kmem_zalloc(len, KM_SLEEP); (void) bcopy(text, newattrib->entity_attribute_value, len); newattrib->entity_attribute_length = len; /* attach to end of list */ *previous = newattrib; } /* * hidparser_alloc_attrib_list: * Allocate space for n attributes , create a linked list and * return the head */ static entity_attribute_t * hidparser_alloc_attrib_list(int count) { entity_attribute_t *head, *current; if (count <= 0) { return (NULL); } head = kmem_zalloc(sizeof (entity_attribute_t), KM_SLEEP); count--; current = head; while (count--) { current->entity_attribute_next = kmem_zalloc( sizeof (entity_attribute_t), KM_SLEEP); current = current->entity_attribute_next; } current->entity_attribute_next = NULL; return (head); } /* * hidparser_cp_attribute_list: * Copies the Global item list pointed to by head * We create a clone of the global item list here * because we want to retain the Global items to * the next Main Item. */ static entity_attribute_t * hidparser_cp_attribute_list(entity_attribute_t *head) { entity_attribute_t *return_value, *current_src, *current_dst; if (!head) { return (NULL); } current_src = head; current_dst = return_value = hidparser_alloc_attrib_list(1); while (current_src) { current_dst->entity_attribute_tag = current_src->entity_attribute_tag; current_dst->entity_attribute_length = current_src->entity_attribute_length; current_dst->entity_attribute_value = kmem_zalloc( current_dst->entity_attribute_length, KM_SLEEP); (void) bcopy(current_src->entity_attribute_value, current_dst->entity_attribute_value, current_src->entity_attribute_length); if (current_src->entity_attribute_next) { current_dst->entity_attribute_next = hidparser_alloc_attrib_list(1); } else { current_dst->entity_attribute_next = NULL; } current_src = current_src->entity_attribute_next; current_dst = current_dst->entity_attribute_next; } return (return_value); } /* * hidparser_find_attribute_end: * Find the last item in the attribute list pointed to by head */ static entity_attribute_t * hidparser_find_attribute_end(entity_attribute_t *head) { if (head == NULL) { return (NULL); } while (head->entity_attribute_next != NULL) { head = head->entity_attribute_next; } return (head); } /* * hidparser_free_report_descr_handle: * Free the parse tree pointed to by handle */ static void hidparser_free_report_descr_handle(entity_item_t *handle) { entity_item_t *next, *current, *child; current = handle; while (current) { child = current->info.child; next = current->entity_item_right_sibling; if (current->entity_item_type == R_ITEM_COLLECTION) { if (current->entity_item_params != NULL) kmem_free(current->entity_item_params, current->entity_item_params_leng); if (current->entity_item_attributes != NULL) hidparser_free_attribute_list( current->entity_item_attributes); USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "FREE 1: %s", items[current->entity_item_type]); kmem_free(current, sizeof (entity_item_t)); (void) hidparser_free_report_descr_handle(child); } else { if (current->entity_item_params != NULL) { kmem_free(current->entity_item_params, current->entity_item_params_leng); } if (current->entity_item_attributes != NULL) { hidparser_free_attribute_list( current->entity_item_attributes); } USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "FREE 2: %s", items[current->entity_item_type]); kmem_free(current, sizeof (entity_item_t)); } current = next; } } /* * hidparser_free_attribute_list: * Free the attribute list pointed to by head */ static void hidparser_free_attribute_list(entity_attribute_t *head) { entity_attribute_t *next, *current; current = head; while (current) { next = current->entity_attribute_next; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "FREE: %s value_length = %d", items[current->entity_attribute_tag], current->entity_attribute_length); if (current->entity_attribute_value != NULL) { USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "\tvalue = 0x%x", current->entity_attribute_value[0]); kmem_free(current->entity_attribute_value, current->entity_attribute_length); } kmem_free(current, sizeof (entity_attribute_t)); current = next; } } /* * hidparser_initialize_items: * Initialize items array before start scanning and parsing. * This array of strings are used for printing purpose. */ static void hidparser_initialize_items(void) { items[R_ITEM_USAGE] = "Usage"; items[R_ITEM_USAGE_MIN] = "Usage Minimum"; items[R_ITEM_USAGE_MAX] = "Usage Maximum"; items[R_ITEM_DESIGNATOR_INDEX] = "Designator Index"; items[R_ITEM_DESIGNATOR_MIN] = "Designator Minimum"; items[R_ITEM_DESIGNATOR_MAX] = "Designator Maximum"; items[R_ITEM_STRING_INDEX] = "String Index"; items[R_ITEM_STRING_MIN] = "String Minimum"; items[R_ITEM_STRING_MAX] = "String Maximum"; items[R_ITEM_USAGE_PAGE] = "Usage Page"; items[R_ITEM_LOGICAL_MINIMUM] = "Logical Minimum"; items[R_ITEM_LOGICAL_MAXIMUM] = "Logical Maximum"; items[R_ITEM_PHYSICAL_MINIMUM] = "Physical Minimum"; items[R_ITEM_PHYSICAL_MAXIMUM] = "Physical Maximum"; items[R_ITEM_EXPONENT] = "Exponent"; items[R_ITEM_UNIT] = "Unit"; items[R_ITEM_REPORT_SIZE] = "Report Size"; items[R_ITEM_REPORT_ID] = "Report Id"; items[R_ITEM_REPORT_COUNT] = "Report Count"; items[R_ITEM_PUSH] = "Push"; items[R_ITEM_POP] = "Pop"; items[R_ITEM_INPUT] = "Input"; items[R_ITEM_OUTPUT] = "Output"; items[R_ITEM_COLLECTION] = "Collection"; items[R_ITEM_FEATURE] = "Feature"; items[R_ITEM_END_COLLECTION] = "End Collection"; items[R_ITEM_SET_DELIMITER] = "Delimiter"; } /* * hidparser_scan: * This function scans the input entity descriptor, sees the data * length, returns the next token, data bytes and length in the * scan_ifp structure. */ static void hidparser_scan(hidparser_tok_t *scan_ifp) { int count; int ch; int parsed_length; unsigned char *parsed_text; unsigned char *entity_descriptor; char err_str[32]; size_t entity_buffer_size, index; index = scan_ifp->hidparser_tok_index; entity_buffer_size = scan_ifp->hidparser_tok_max_bsize; parsed_length = 0; parsed_text = scan_ifp->hidparser_tok_text; entity_descriptor = scan_ifp->hidparser_tok_entity_descriptor; next_item: if (index <= entity_buffer_size -1) { ch = 0xFF & entity_descriptor[index]; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: index = 0x%lx ch = 0x%x", index, ch); index++; /* * Error checking: * Unrecognized items should be passed over * by the parser. * Section 5.4 */ if (!(hidparser_isvalid_item(ch))) { (void) sprintf(err_str, "%s: 0x%2x", "Unknown or reserved item", ch); hidparser_report_err(HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, 0, 0x3F, err_str); goto next_item; } if (ch == EXTENDED_ITEM) { parsed_length = entity_descriptor[index++]; ch = entity_descriptor[index++]; hidparser_report_err(HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, 0, 0x3E, "Long item defined"); } else { parsed_length = ch & 0x03; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: parsed_length = %x", parsed_length); /* 3 really means 4.. see p.21 HID */ if (parsed_length == 3) parsed_length++; } for (count = 0; count < parsed_length; count++) { parsed_text[count] = entity_descriptor[index]; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: parsed_text[%d] = 0x%x," "index = 0x%lx", count, parsed_text[count], index); index++; } USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: lexical analyzer found 0x%x " "before translation", ch); scan_ifp->hidparser_tok_index = index; scan_ifp->hidparser_tok_leng = parsed_length; scan_ifp->hidparser_tok_token = ch & 0xFC; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: aindex = 0x%lx", index); } else { USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "scanner: eindex = 0x%lx", index); scan_ifp->hidparser_tok_leng = 0; scan_ifp->hidparser_tok_token = 0; /* EOF */ } } /* * hidparser_report_err: * Construct and print the error code * Ref: Hidview error check list */ static void hidparser_report_err(int err_level, int err_type, int tag, int subcode, char *msg) { unsigned int BmParserErrorCode = 0; if (err_level) { BmParserErrorCode |= HIDPARSER_ERR_ERROR; } if (err_type) { BmParserErrorCode |= HIDPARSER_ERR_STANDARD; } BmParserErrorCode |= (tag << 8) & HIDPARSER_ERR_TAG_MASK; BmParserErrorCode |= subcode & HIDPARSER_ERR_SUBCODE_MASK; if (err_level) { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "err code = 0x%4x, err str = %s", BmParserErrorCode, msg); } else { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "wrn code = 0x%4x, wrn str = %s", BmParserErrorCode, msg); } } /* * hidparser_isvalid_item: * Find if the item tag is a valid one */ static int hidparser_isvalid_item(int tag) { if (tag == EXTENDED_ITEM) { return (1); } tag &= 0xFC; if ((tag == R_ITEM_INPUT) || (tag == R_ITEM_OUTPUT) || (tag == R_ITEM_COLLECTION) || (tag == R_ITEM_FEATURE) || (tag == R_ITEM_END_COLLECTION) || (tag == R_ITEM_USAGE_PAGE) || (tag == R_ITEM_LOGICAL_MINIMUM) || (tag == R_ITEM_LOGICAL_MAXIMUM) || (tag == R_ITEM_PHYSICAL_MINIMUM) || (tag == R_ITEM_PHYSICAL_MAXIMUM) || (tag == R_ITEM_EXPONENT) || (tag == R_ITEM_UNIT) || (tag == R_ITEM_REPORT_SIZE) || (tag == R_ITEM_REPORT_ID) || (tag == R_ITEM_REPORT_COUNT) || (tag == R_ITEM_PUSH) || (tag == R_ITEM_POP) || (tag == R_ITEM_USAGE) || (tag == R_ITEM_USAGE_MIN) || (tag == R_ITEM_USAGE_MAX) || (tag == R_ITEM_DESIGNATOR_INDEX) || (tag == R_ITEM_DESIGNATOR_MIN) || (tag == R_ITEM_DESIGNATOR_MAX) || (tag == R_ITEM_STRING_INDEX) || (tag == R_ITEM_STRING_MIN) || (tag == R_ITEM_STRING_MAX) || (tag == R_ITEM_SET_DELIMITER)) { return (1); } else { return (0); } } /* * hidparser_lookup_attribute: * Takes an item pointer(report structure) and a tag(e.g Logical * Min) as input. Returns the corresponding attribute structure. * Presently used for error checking only. */ static entity_attribute_t * hidparser_lookup_attribute(entity_item_t *item, int attr_tag) { entity_attribute_t *temp; if (item == NULL) { return (NULL); } temp = item->entity_item_attributes; while (temp != NULL) { if (temp->entity_attribute_tag == attr_tag) { return (temp); } temp = temp->entity_attribute_next; } return (NULL); } /* * hidparser_global_err_check: * Error checking for Global Items that need to be * performed in MainItem */ static void hidparser_global_err_check(entity_item_t *mainitem) { hidparser_check_minmax_val_signed(mainitem, R_ITEM_LOGICAL_MINIMUM, R_ITEM_LOGICAL_MAXIMUM, 0, 0); hidparser_check_minmax_val_signed(mainitem, R_ITEM_PHYSICAL_MINIMUM, R_ITEM_PHYSICAL_MAXIMUM, 0, 0); hidparser_check_correspondence(mainitem, R_ITEM_PHYSICAL_MINIMUM, R_ITEM_PHYSICAL_MAXIMUM, 0, 0, "Must have a corresponding Physical min", "Must have a corresponding Physical max"); hidparser_check_correspondence(mainitem, R_ITEM_PUSH, R_ITEM_POP, 1, 0, "Should have a corresponding Pop", "Must have a corresponding Push"); } /* * hidparser_mainitem_err_check: * Error checking for Main Items */ static void hidparser_mainitem_err_check(entity_item_t *mainitem) { int itemmask = 0; entity_attribute_t *attr; attr = mainitem->entity_item_attributes; if (attr != NULL) { while (attr) { switch (attr->entity_attribute_tag) { case R_ITEM_LOGICAL_MINIMUM: itemmask |= 0x01; break; case R_ITEM_LOGICAL_MAXIMUM: itemmask |= 0x02; break; case R_ITEM_REPORT_SIZE: itemmask |= 0x04; break; case R_ITEM_REPORT_COUNT: itemmask |= 0x08; break; case R_ITEM_USAGE_PAGE: itemmask |= 0x10; break; default: break; } /* switch */ attr = attr->entity_attribute_next; } /* while */ } /* if */ if ((mainitem->entity_item_type == R_ITEM_COLLECTION) || (mainitem->entity_item_type == R_ITEM_END_COLLECTION)) { return; } if (itemmask != 0x1f) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, mainitem->entity_item_type, 0, "Required Global/Local items must be defined"); } } /* * hidparser_local_err_check: * Error checking for Local items that is done when a MainItem * is encountered */ static void hidparser_local_err_check(entity_item_t *mainitem) { hidparser_check_correspondence(mainitem, R_ITEM_USAGE_MIN, R_ITEM_USAGE_MAX, 0, 0, "Must have a corresponding Usage Min", "Must have a corresponding Usage Max"); hidparser_check_minmax_val(mainitem, R_ITEM_USAGE_MIN, R_ITEM_USAGE_MAX, 1, 1); hidparser_check_correspondence(mainitem, R_ITEM_DESIGNATOR_MIN, R_ITEM_DESIGNATOR_MAX, 0, 0, "Must have a corresponding Designator min", "Must have a corresponding Designator Max"); hidparser_check_minmax_val(mainitem, R_ITEM_DESIGNATOR_MIN, R_ITEM_DESIGNATOR_MAX, 1, 1); hidparser_check_correspondence(mainitem, R_ITEM_STRING_MIN, R_ITEM_STRING_MAX, 0, 0, "Must have a corresponding String min", "Must have a corresponding String Max"); hidparser_check_minmax_val(mainitem, R_ITEM_STRING_MIN, R_ITEM_STRING_MAX, 1, 1); } /* * hidparser_find_unsigned_val: * Find the value for multibyte data * Ref: Section 5.8 of HID Spec 1.0 */ static unsigned int hidparser_find_unsigned_val(entity_attribute_t *attr) { char *text; int len, i; unsigned int ret = 0; text = attr->entity_attribute_value; len = attr->entity_attribute_length; for (i = 0; i < len; i++) { ret |= ((text[i] & 0xff) << (8*i)); } return (ret); } /* * hidparser_find_signed_val: * Find the value for signed multibyte data * Ref: Section 5.8 of HID Spec 1.0 */ static signed int hidparser_find_signed_val(entity_attribute_t *attr) { char *text; int len, i; int ret = 0; text = attr->entity_attribute_value; len = attr->entity_attribute_length; for (i = 0; i < len - 1; i++) { ret |= ((text[i] & 0xff) << (8 * i)); } if (len > 0) { ret |= (text[i] << (8 * i)); } return (ret); } /* * hidparser_check_correspondence: * Check if the item item2 corresponding to item1 exists and vice versa * If not report the appropriate error */ static void hidparser_check_correspondence(entity_item_t *mainitem, int item_tag1, int item_tag2, int val1, int val2, char *str1, char *str2) { entity_attribute_t *temp1, *temp2; temp1 = hidparser_lookup_attribute(mainitem, item_tag1); temp2 = hidparser_lookup_attribute(mainitem, item_tag2); if ((temp1 != NULL) && (temp2 == NULL)) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag1, val1, str1); } if ((temp2 != NULL) && (temp1 == NULL)) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag2, val2, str2); } } /* * hidparser_check_minmax_val: * Check if the Min value <= Max and vice versa * Print for warnings and errors have been taken care separately. */ static void hidparser_check_minmax_val(entity_item_t *mainitem, int item_tag1, int item_tag2, int val1, int val2) { entity_attribute_t *temp1, *temp2; temp1 = hidparser_lookup_attribute(mainitem, item_tag1); temp2 = hidparser_lookup_attribute(mainitem, item_tag2); if ((temp1 != NULL) && (temp2 != NULL)) { if (hidparser_find_unsigned_val(temp1) > hidparser_find_unsigned_val(temp2)) { if ((item_tag1 == R_ITEM_LOGICAL_MINIMUM) || (item_tag1 == R_ITEM_PHYSICAL_MINIMUM)) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, item_tag1, val1, "unsigned: Min should be <= to Max"); } else { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag1, val1, "Min must be <= to Max"); } } if (hidparser_find_unsigned_val(temp2) < hidparser_find_unsigned_val(temp1)) { if ((item_tag2 == R_ITEM_LOGICAL_MAXIMUM) || (item_tag2 == R_ITEM_PHYSICAL_MAXIMUM)) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag2, val2, "unsigned: Max should be >= to Min"); } else { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag2, val2, "Max must be >= to Min"); } } } /* if (temp1 != NULL) && (temp2 != NULL) */ } /* * hidparser_check_minmax_val_signed: * Check if the Min value <= Max and vice versa * Print for warnings and errors have been taken care separately. */ static void hidparser_check_minmax_val_signed(entity_item_t *mainitem, int item_tag1, int item_tag2, int val1, int val2) { entity_attribute_t *temp1, *temp2; temp1 = hidparser_lookup_attribute(mainitem, item_tag1); temp2 = hidparser_lookup_attribute(mainitem, item_tag2); if ((temp1 != NULL) && (temp2 != NULL)) { if (hidparser_find_signed_val(temp1) > hidparser_find_signed_val(temp2)) { if ((item_tag1 == R_ITEM_LOGICAL_MINIMUM) || (item_tag1 == R_ITEM_PHYSICAL_MINIMUM)) { hidparser_report_err( HIDPARSER_ERR_WARN, HIDPARSER_ERR_STANDARD, item_tag1, val1, "signed: Min should be <= to Max"); } else { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag1, val1, "Min must be <= to Max"); } } if (hidparser_find_signed_val(temp2) < hidparser_find_signed_val(temp1)) { if ((item_tag2 == R_ITEM_LOGICAL_MAXIMUM) || (item_tag2 == R_ITEM_PHYSICAL_MAXIMUM)) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag2, val2, "signed: Max should be >= to Min"); } else { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, item_tag2, val2, "Max must be >= to Min"); } } } /* if (temp1 != NULL) && (temp2 != NULL) */ } /* * hidparser_error_delim: * Error check for Delimiter Sets */ static void hidparser_error_delim(entity_item_t *item, int err) { entity_attribute_t *attr; switch (err) { case HIDPARSER_DELIM_ERR1: hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_SET_DELIMITER, 0, "Must be Delimiter Open"); break; case HIDPARSER_DELIM_ERR2: hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_SET_DELIMITER, 0, "Must be Delimiter Close"); break; case HIDPARSER_DELIM_ERR3: attr = item->entity_item_attributes; while (attr != NULL) { if ((attr->entity_attribute_tag != R_ITEM_USAGE) && (attr->entity_attribute_tag != R_ITEM_USAGE_MIN) && (attr->entity_attribute_tag != R_ITEM_USAGE_MAX)) { hidparser_report_err( HIDPARSER_ERR_ERROR, HIDPARSER_ERR_STANDARD, R_ITEM_SET_DELIMITER, 3, "May only contain Usage, " "Usage Min and Usage Max"); } attr = attr->entity_attribute_next; } break; default: break; } } /* * hidparser_find_max_packet_size_from_report_descriptor: * find packet size of the largest report in the report descriptor */ void hidparser_find_max_packet_size_from_report_descriptor( hidparser_handle_t hparser_handle, hidparser_packet_info_t *hpack) { int rval, i; uint_t packet_size; uint_t max_packet_size; uint_t max_report_id; hidparser_report_id_list_t report_id_list; USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle, "hidparser_find_max_packet_size_from_report_descriptor"); /* get a list of input reports */ rval = hidparser_get_report_id_list(hparser_handle, R_ITEM_INPUT, &report_id_list); if (rval != HIDPARSER_SUCCESS) { USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "No report id used"); } else { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "%d unique report IDs found in hid report descriptor", report_id_list.no_of_report_ids); for (i = 0; i < (report_id_list.no_of_report_ids); i++) { USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "report_id: %d", report_id_list.report_id[i]); } } if ((rval != HIDPARSER_SUCCESS) || (report_id_list.no_of_report_ids == 0)) { /* * since no report id is used, get the packet size * for the only report available */ (void) hidparser_get_packet_size(hparser_handle, 0, R_ITEM_INPUT, &packet_size); USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Not using report id prefix. HID packet size = %d", packet_size); hpack->max_packet_size = packet_size; hpack->report_id = HID_REPORT_ID_UNDEFINED; } else { /* * hid device uses multiple reports with report id prefix byte. * Find the longest input report. * See HID 8.4. */ max_packet_size = 0; max_report_id = 0; for (i = 0; i < (report_id_list.no_of_report_ids); i++) { (void) hidparser_get_packet_size(hparser_handle, report_id_list.report_id[i], R_ITEM_INPUT, &packet_size); if (packet_size > max_packet_size) { max_packet_size = packet_size; max_report_id = report_id_list.report_id[i]; } USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Report ID %d has a packet size of %d", report_id_list.report_id[i], packet_size); } hpack->max_packet_size = max_packet_size; hpack->report_id = max_report_id; USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle, "Report ID %d has the maximum packet size of %d", max_report_id, max_packet_size); } }