Index: uspace/app/usbinfo/dump.c =================================================================== --- uspace/app/usbinfo/dump.c (revision 8426912a80865517c3d41d9b1d15bcf0ebe5ba4b) +++ uspace/app/usbinfo/dump.c (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -45,4 +45,5 @@ #include "usbinfo.h" +#include #define INDENT " " @@ -125,4 +126,83 @@ } +static void dump_tree_descriptor(uint8_t *descriptor, size_t depth) +{ + if (descriptor == NULL) { + return; + } + while (depth > 0) { + printf(" "); + depth--; + } + int type = (int) *(descriptor + 1); + const char *name = "unknown"; + switch (type) { +#define _TYPE(descriptor_type) \ + case USB_DESCTYPE_##descriptor_type: name = #descriptor_type; break + _TYPE(DEVICE); + _TYPE(CONFIGURATION); + _TYPE(STRING); + _TYPE(INTERFACE); + _TYPE(ENDPOINT); + _TYPE(HID); + _TYPE(HID_REPORT); + _TYPE(HID_PHYSICAL); + _TYPE(HUB); +#undef _TYPE + } + printf("0x%02x (%s)\n", type, name); +} + +static void dump_tree_internal(usb_dp_parser_t *parser, usb_dp_parser_data_t *data, + uint8_t *root, size_t depth) +{ + if (root == NULL) { + return; + } + dump_tree_descriptor(root, depth); + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root); + do { + dump_tree_internal(parser, data, child, depth + 1); + child = usb_dp_get_sibling_descriptor(parser, data, root, child); + } while (child != NULL); +} + +static void dump_tree(usb_dp_parser_t *parser, usb_dp_parser_data_t *data) +{ + uint8_t *ptr = data->data; + printf("Descriptor tree:\n"); + dump_tree_internal(parser, data, ptr, 1); +} + +#define NESTING(parentname, childname) \ + { \ + .child = USB_DESCTYPE_##childname, \ + .parent = USB_DESCTYPE_##parentname, \ + } +#define LAST_NESTING { -1, -1 } + +static usb_dp_descriptor_nesting_t descriptor_nesting[] = { + NESTING(CONFIGURATION, INTERFACE), + NESTING(INTERFACE, ENDPOINT), + NESTING(INTERFACE, HUB), + NESTING(INTERFACE, HID), + NESTING(HID, HID_REPORT), + LAST_NESTING +}; + +static usb_dp_parser_t parser = { + .nesting = descriptor_nesting +}; + +void dump_descriptor_tree(uint8_t *descriptors, size_t length) +{ + usb_dp_parser_data_t data = { + .data = descriptors, + .size = length, + .arg = NULL + }; + + dump_tree(&parser, &data); +} /** @} Index: uspace/app/usbinfo/info.c =================================================================== --- uspace/app/usbinfo/info.c (revision 8426912a80865517c3d41d9b1d15bcf0ebe5ba4b) +++ uspace/app/usbinfo/info.c (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -112,4 +112,7 @@ full_config_descriptor, config_descriptor.total_length); + dump_descriptor_tree(full_config_descriptor, + config_descriptor.total_length); + return EOK; } Index: uspace/app/usbinfo/usbinfo.h =================================================================== --- uspace/app/usbinfo/usbinfo.h (revision 8426912a80865517c3d41d9b1d15bcf0ebe5ba4b) +++ uspace/app/usbinfo/usbinfo.h (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -50,4 +50,5 @@ usb_standard_configuration_descriptor_t *); int dump_device(int, usb_address_t); +void dump_descriptor_tree(uint8_t *, size_t); static inline void internal_error(int err) Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision 8426912a80865517c3d41d9b1d15bcf0ebe5ba4b) +++ uspace/lib/usb/Makefile (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -36,4 +36,5 @@ src/class.c \ src/debug.c \ + src/dp.c \ src/drvpsync.c \ src/hcdhubd.c \ Index: uspace/lib/usb/include/usb/dp.h =================================================================== --- uspace/lib/usb/include/usb/dp.h (revision d45096447dcb00560ce57b235a56b58dbaa30681) +++ uspace/lib/usb/include/usb/dp.h (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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 libusb + * @{ + */ +/** @file + * @brief USB descriptor parser. + */ +#ifndef LIBUSB_DP_H_ +#define LIBUSB_DP_H_ + +#include +#include +#include + +typedef struct { + int child; + int parent; +} usb_dp_descriptor_nesting_t; + +typedef struct { + usb_dp_descriptor_nesting_t *nesting; +} usb_dp_parser_t; + +typedef struct { + uint8_t *data; + size_t size; + void *arg; +} usb_dp_parser_data_t; + +uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *, + usb_dp_parser_data_t *, uint8_t *); +uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *, + usb_dp_parser_data_t *, uint8_t *, uint8_t *); + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/dp.c =================================================================== --- uspace/lib/usb/src/dp.c (revision d45096447dcb00560ce57b235a56b58dbaa30681) +++ uspace/lib/usb/src/dp.c (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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 libusb + * @{ + */ +/** + * @file + * @brief USB descriptor parser (implementation). + */ +#include +#include +#include +#include +#include +#include + +/** Tells whether pointer points inside descriptor data. + * + * @param data Parser data. + * @param ptr Pointer to be verified. + * @return Whether @ptr points inside data->data field. + */ +static bool is_valid_descriptor_pointer(usb_dp_parser_data_t *data, + uint8_t *ptr) +{ + if (ptr == NULL) { + return false; + } + + if (ptr < data->data) { + return false; + } + + if ((size_t)(ptr - data->data) >= data->size) { + return false; + } + + return true; +} + +/** Get next descriptor regardless of the nesting. + * + * @param data Parser data. + * @param current Pointer to current descriptor. + * @return Pointer to start of next descriptor. + * @retval NULL Invalid input or no next descriptor. + */ +static uint8_t *get_next_descriptor(usb_dp_parser_data_t *data, + uint8_t *current) +{ + assert(is_valid_descriptor_pointer(data, current)); + + uint8_t current_length = *current; + uint8_t *next = current + current_length; + + if (!is_valid_descriptor_pointer(data, next)) { + return NULL; + } + + return next; +} + +/** Get descriptor type. + * + * @see usb_descriptor_type_t + * + * @param data Parser data. + * @param start Pointer to start of the descriptor. + * @return Descriptor type. + * @retval -1 Invalid input. + */ +static int get_descriptor_type(usb_dp_parser_data_t *data, uint8_t *start) +{ + if (start == NULL) { + return -1; + } + + start++; + if (!is_valid_descriptor_pointer(data, start)) { + return -1; + } else { + return (int) (*start); + } +} + +/** Tells whether descriptors could be nested. + * + * @param parser Parser. + * @param child Child descriptor type. + * @param parent Parent descriptor type. + * @return Whether @p child could be child of @p parent. + */ +static bool is_nested_descriptor_type(usb_dp_parser_t *parser, + int child, int parent) +{ + usb_dp_descriptor_nesting_t *nesting = parser->nesting; + while ((nesting->child > 0) && (nesting->parent > 0)) { + if ((nesting->child == child) && (nesting->parent == parent)) { + return true; + } + nesting++; + } + return false; +} + +/** Tells whether descriptors could be nested. + * + * @param parser Parser. + * @param data Parser data. + * @param child Pointer to child descriptor. + * @param parent Pointer to parent descriptor. + * @return Whether @p child could be child of @p parent. + */ +static bool is_nested_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *child, uint8_t *parent) +{ + return is_nested_descriptor_type(parser, + get_descriptor_type(data, child), + get_descriptor_type(data, parent)); +} + +/** Find first nested descriptor of given parent. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to the beginning of parent descriptor. + * @return Pointer to the beginning of the first nested (child) descriptor. + * @retval NULL No child descriptor found. + * @retval NULL Invalid input. + */ +uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent) +{ + if (!is_valid_descriptor_pointer(data, parent)) { + return NULL; + } + + uint8_t *next = get_next_descriptor(data, parent); + if (next == NULL) { + return NULL; + } + + if (is_nested_descriptor(parser, data, next, parent)) { + return next; + } else { + return NULL; + } +} + +/** Skip all nested descriptors. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to the beginning of parent descriptor. + * @return Pointer to first non-child descriptor. + * @retval NULL No next descriptor. + * @retval NULL Invalid input. + */ +static uint8_t *skip_nested_descriptors(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent) +{ + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, parent); + if (child == NULL) { + return get_next_descriptor(data, parent); + } + uint8_t *next_child = skip_nested_descriptors(parser, data, child); + while (is_nested_descriptor(parser, data, next_child, parent)) { + next_child = skip_nested_descriptors(parser, data, next_child); + } + + return next_child; +} + +/** Get sibling descriptor. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to common parent descriptor. + * @param sibling Left sibling. + * @return Pointer to first right sibling of @p sibling. + * @retval NULL No sibling exist. + * @retval NULL Invalid input. + */ +uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent, uint8_t *sibling) +{ + if (!is_valid_descriptor_pointer(data, parent) + || !is_valid_descriptor_pointer(data, sibling)) { + return NULL; + } + + uint8_t *possible_sibling = skip_nested_descriptors(parser, data, sibling); + if (possible_sibling == NULL) { + return NULL; + } + + int parent_type = get_descriptor_type(data, parent); + int possible_sibling_type = get_descriptor_type(data, possible_sibling); + if (is_nested_descriptor_type(parser, possible_sibling_type, parent_type)) { + return possible_sibling; + } else { + return NULL; + } +} + + +/** @} + */ Index: uspace/lib/usb/src/recognise.c =================================================================== --- uspace/lib/usb/src/recognise.c (revision 8426912a80865517c3d41d9b1d15bcf0ebe5ba4b) +++ uspace/lib/usb/src/recognise.c (revision d45096447dcb00560ce57b235a56b58dbaa30681) @@ -346,4 +346,6 @@ usb_address_t address, devman_handle_t *child_handle) { + static size_t device_name_index = 0; + device_t *child = NULL; char *child_name = NULL; @@ -357,7 +359,8 @@ /* - * TODO: some better child naming - */ - rc = asprintf(&child_name, "usb%p", child); + * TODO: Once the device driver framework support persistent + * naming etc., something more descriptive could be created. + */ + rc = asprintf(&child_name, "usbdev%02zu", device_name_index); if (rc < 0) { goto failure; @@ -381,4 +384,6 @@ } + device_name_index++; + return EOK;