Index: uspace/lib/usb/src/dump.c =================================================================== --- uspace/lib/usb/src/dump.c (revision a1d12f4e5e4072fd2e04fe50804ee515788d3dae) +++ uspace/lib/usb/src/dump.c (revision a1d12f4e5e4072fd2e04fe50804ee515788d3dae) @@ -0,0 +1,286 @@ +/* + * 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 Descriptor dumping. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct { + int id; + void (*dump)(FILE *, const char *, const char *, + const uint8_t *, size_t); +} descriptor_dump_t; + +static void usb_dump_descriptor_device(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_configuration(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_interface(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_string(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_endpoint(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_hid(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_hub(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_generic(FILE *, const char *, const char *, + const uint8_t *, size_t); + +static descriptor_dump_t descriptor_dumpers[] = { + { USB_DESCTYPE_DEVICE, usb_dump_descriptor_device }, + { USB_DESCTYPE_CONFIGURATION, usb_dump_descriptor_configuration }, + { USB_DESCTYPE_STRING, usb_dump_descriptor_string }, + { USB_DESCTYPE_INTERFACE, usb_dump_descriptor_interface }, + { USB_DESCTYPE_ENDPOINT, usb_dump_descriptor_endpoint }, + { USB_DESCTYPE_HID, usb_dump_descriptor_hid }, + { USB_DESCTYPE_HUB, usb_dump_descriptor_hub }, + { -1, usb_dump_descriptor_generic }, + { -1, NULL } +}; + +/** Dumps standard USB descriptor. + * The @p line_suffix must contain the newline \\n character. + * When @p line_suffix or @p line_prefix is NULL, they are substitued with + * default values + * ( - for prefix and line termination for suffix). + * + * @param output Output file stream to dump descriptor to. + * @param line_prefix Prefix for each line of output. + * @param line_suffix Suffix of each line of output. + * @param descriptor Actual descriptor. + * @param descriptor_length Descriptor size. + */ +void usb_dump_standard_descriptor(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + if (descriptor_length < 2) { + return; + } + int type = descriptor[1]; + + descriptor_dump_t *dumper = descriptor_dumpers; + while (dumper->dump != NULL) { + if ((dumper->id == type) || (dumper->id < 0)) { + dumper->dump(output, line_prefix, line_suffix, + descriptor, descriptor_length); + return; + } + dumper++; + } +} + +/** Prints single line of USB descriptor dump. + * @warning This macro abuses heavily the naming conventions used + * by all dumping functions (i.e. names for output file stream (@c output) and + * line prefix and suffix (@c line_prefix and @c line_suffix respectively))- + * + * @param fmt Formatting string. + */ +#define PRINTLINE(fmt, ...) \ + fprintf(output, "%s" fmt "%s", \ + line_prefix ? line_prefix : " - ", \ + __VA_ARGS__, \ + line_suffix ? line_suffix : "\n") + +#define BCD_INT(a) (((unsigned int)(a)) / 256) +#define BCD_FRAC(a) (((unsigned int)(a)) % 256) + +#define BCD_FMT "%x.%x" +#define BCD_ARGS(a) BCD_INT((a)), BCD_FRAC((a)) + +static void usb_dump_descriptor_device(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_device_descriptor_t *d + = (usb_standard_device_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bcdUSB = %d (" BCD_FMT ")", d->usb_spec_version, + BCD_ARGS(d->usb_spec_version)); + PRINTLINE("bDeviceClass = 0x%02x", d->device_class); + PRINTLINE("bDeviceSubClass = 0x%02x", d->device_subclass); + PRINTLINE("bDeviceProtocol = 0x%02x", d->device_protocol); + PRINTLINE("bMaxPacketSize0 = %d", d->max_packet_size); + PRINTLINE("idVendor = %d", d->vendor_id); + PRINTLINE("idProduct = %d", d->product_id); + PRINTLINE("bcdDevice = %d", d->device_version); + PRINTLINE("iManufacturer = %d", d->str_manufacturer); + PRINTLINE("iProduct = %d", d->str_product); + PRINTLINE("iSerialNumber = %d", d->str_serial_number); + PRINTLINE("bNumConfigurations = %d", d->configuration_count); +} + +static void usb_dump_descriptor_configuration(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_configuration_descriptor_t *d + = (usb_standard_configuration_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + bool self_powered = d->attributes & 64; + bool remote_wakeup = d->attributes & 32; + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("wTotalLength = %d", d->total_length); + PRINTLINE("bNumInterfaces = %d", d->interface_count); + PRINTLINE("bConfigurationValue = %d", d->configuration_number); + PRINTLINE("iConfiguration = %d", d->str_configuration); + PRINTLINE("bmAttributes = %d [%s%s%s]", d->attributes, + self_powered ? "self-powered" : "", + (self_powered & remote_wakeup) ? ", " : "", + remote_wakeup ? "remote-wakeup" : ""); + PRINTLINE("MaxPower = %d (%dmA)", d->max_power, + 2 * d->max_power); +} + +static void usb_dump_descriptor_interface(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_interface_descriptor_t *d + = (usb_standard_interface_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bInterfaceNumber = %d", d->interface_number); + PRINTLINE("bAlternateSetting = %d", d->alternate_setting); + PRINTLINE("bNumEndpoints = %d", d->endpoint_count); + PRINTLINE("bInterfaceClass = %s", d->interface_class == 0 + ? "reserved (0)" : usb_str_class(d->interface_class)); + PRINTLINE("bInterfaceSubClass = %d", d->interface_subclass); + PRINTLINE("bInterfaceProtocol = %d", d->interface_protocol); + PRINTLINE("iInterface = %d", d->str_interface); +} + +static void usb_dump_descriptor_string(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ +} + +static void usb_dump_descriptor_endpoint(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_endpoint_descriptor_t *d + = (usb_standard_endpoint_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + int endpoint = d->endpoint_address & 15; + usb_direction_t direction = d->endpoint_address & 128 + ? USB_DIRECTION_IN : USB_DIRECTION_OUT; + usb_transfer_type_t transfer_type = d->attributes & 3; + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02X", d->descriptor_type); + PRINTLINE("bEndpointAddress = 0x%02X [%d, %s]", + d->endpoint_address, endpoint, + direction == USB_DIRECTION_IN ? "in" : "out"); + PRINTLINE("bmAttributes = %d [%s]", d->attributes, + usb_str_transfer_type(transfer_type)); + PRINTLINE("wMaxPacketSize = %d", d->max_packet_size); + PRINTLINE("bInterval = %dms", d->poll_interval); +} + +static void usb_dump_descriptor_hid(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_hid_descriptor_t *d + = (usb_standard_hid_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bcdHID = %d (" BCD_FMT ")", d->spec_release, + BCD_ARGS(d->spec_release)); + PRINTLINE("bCountryCode = %d", d->country_code); + PRINTLINE("bNumDescriptors = %d", d->class_desc_count); + PRINTLINE("bDescriptorType = %d", d->report_desc_info.type); + PRINTLINE("wDescriptorLength = %d", d->report_desc_info.length); + + /* Print info about report descriptors. */ + size_t i; + size_t count = (descriptor_length - sizeof(*d)) + / sizeof(usb_standard_hid_class_descriptor_info_t); + usb_standard_hid_class_descriptor_info_t *d2 + = (usb_standard_hid_class_descriptor_info_t *) + (descriptor + sizeof(*d)); + for (i = 0; i < count; i++, d2++) { + PRINTLINE("bDescriptorType = %d", d2->type); + PRINTLINE("wDescriptorLength = %d", d2->length); + } +} + +static void usb_dump_descriptor_hub(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ +} + +static void usb_dump_descriptor_generic(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ +} + + +/** + * @} + */