Changes in / [0fd82c9:1614ce3] in mainline

Location:

uspace

Files:

• app/usbinfo/Makefile (modified) (1 diff)
• app/usbinfo/desctree.c (added)
• app/usbinfo/dev.c (added)
• app/usbinfo/dump.c (modified) (2 diffs)
• app/usbinfo/info.c (modified) (4 diffs)
• app/usbinfo/main.c (modified) (2 diffs)
• app/usbinfo/usbinfo.h (modified) (3 diffs)
• lib/c/Makefile (modified) (1 diff)
• lib/c/generic/l18n/langs.c (added)
• lib/c/include/l18n/langs.h (modified) (1 diff)
• lib/usb/include/usb/dp.h (modified) (1 diff)
• lib/usb/include/usb/pipes.h (modified) (1 diff)
• lib/usb/src/dp.c (modified) (1 diff)
• lib/usb/src/pipes.c (modified) (2 diffs)

uspace/app/usbinfo/Makefile

@@ -34 +34 @@
 
 SOURCES = \
+        desctree.c \
+        dev.c \
         dump.c \
         info.c \

uspace/app/usbinfo/dump.c

@@ -101 +101 @@
 }
 
-void dump_match_ids(match_id_list_t *matches)
+void dump_match_ids(match_id_list_t *matches, const char *line_prefix)
 {
-        printf("Match ids:\n");
         link_t *link;
         for (link = matches->ids.next;
@@ -110 +109 @@
                 match_id_t *match = list_get_instance(link, match_id_t, link);
 
-                printf(INDENT "%d %s\n", match->score, match->id);
+                printf("%s%3d %s\n", line_prefix, match->score, match->id);
         }
 }

uspace/app/usbinfo/info.c

@@ -40 +40 @@
 #include <usb/recognise.h>
 #include <usb/request.h>
+#include <usb/classes/classes.h>
+#include <usb/classes/hid.h>
 #include "usbinfo.h"
 
-int dump_device(devman_handle_t hc_handle, usb_address_t address)
-{
-        int rc;
-        usb_device_connection_t wire;
-        usb_endpoint_pipe_t ctrl_pipe;
-
-        /*
-         * Initialize pipes.
-         */
-        rc = usb_device_connection_initialize(&wire, hc_handle, address);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to create connection to the device: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe, &wire);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to create default control pipe: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": probing default control pipe failed: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to start session on control pipe: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-
-        /*
-         * Dump information about possible match ids.
-         */
-        match_id_list_t match_id_list;
-        init_match_ids(&match_id_list);
-        rc = usb_device_create_match_ids(&ctrl_pipe, &match_id_list);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to fetch match ids of the device: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        dump_match_ids(&match_id_list);
-
-        /*
-         * Get device descriptor and dump it.
-         */
-        usb_standard_device_descriptor_t device_descriptor;
-        rc = usb_request_get_device_descriptor(&ctrl_pipe, &device_descriptor);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to fetch standard device descriptor: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        dump_usb_descriptor((uint8_t *)&device_descriptor, sizeof(device_descriptor));
-
-        /*
-         * Get first configuration descriptor and dump it.
-         */
-        usb_standard_configuration_descriptor_t config_descriptor;
-        int config_index = 0;
-        rc = usb_request_get_bare_configuration_descriptor(&ctrl_pipe,
-            config_index, &config_descriptor);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to fetch standard configuration descriptor: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        //dump_standard_configuration_descriptor(config_index, &config_descriptor);
-
-        void *full_config_descriptor = malloc(config_descriptor.total_length);
-        rc = usb_request_get_full_configuration_descriptor(&ctrl_pipe,
-            config_index,
-            full_config_descriptor, config_descriptor.total_length, NULL);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to fetch full configuration descriptor: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-
-        dump_descriptor_tree(full_config_descriptor,
-            config_descriptor.total_length);
-
-        /*
-         * Get supported languages of STRING descriptors.
-         */
+void dump_short_device_identification(usbinfo_device_t *dev)
+{
+        printf("%sDevice 0x%04x by vendor 0x%04x\n", get_indent(0),
+            (int) dev->device_descriptor.product_id,
+            (int) dev->device_descriptor.vendor_id);
+}
+
+static void dump_match_ids_from_interface(uint8_t *descriptor, size_t depth,
+    void *arg)
+{
+        if (depth != 1) {
+                return;
+        }
+        size_t descr_size = descriptor[0];
+        if (descr_size < sizeof(usb_standard_interface_descriptor_t)) {
+                return;
+        }
+        int descr_type = descriptor[1];
+        if (descr_type != USB_DESCTYPE_INTERFACE) {
+                return;
+        }
+
+        usbinfo_device_t *dev = (usbinfo_device_t *) arg;
+
+        usb_standard_interface_descriptor_t *iface
+            = (usb_standard_interface_descriptor_t *) descriptor;
+
+        printf("%sInterface #%d match ids (%s, 0x%02x, 0x%02x)\n",
+            get_indent(0),
+            (int) iface->interface_number,
+            usb_str_class(iface->interface_class),
+            (int) iface->interface_subclass,
+            (int) iface->interface_protocol);
+
+        match_id_list_t matches;
+        init_match_ids(&matches);
+        usb_device_create_match_ids_from_interface(&dev->device_descriptor,
+            iface, &matches);
+        dump_match_ids(&matches, get_indent(1));
+        clean_match_ids(&matches);
+}
+
+void dump_device_match_ids(usbinfo_device_t *dev)
+{
+        match_id_list_t matches;
+        init_match_ids(&matches);
+        usb_device_create_match_ids_from_device_descriptor(
+            &dev->device_descriptor, &matches);
+        printf("%sDevice match ids (0x%04x by 0x%04x, %s)\n", get_indent(0),
+            (int) dev->device_descriptor.product_id,
+            (int) dev->device_descriptor.vendor_id,
+            usb_str_class(dev->device_descriptor.device_class));
+        dump_match_ids(&matches, get_indent(1));
+        clean_match_ids(&matches);
+
+        usb_dp_walk_simple(dev->full_configuration_descriptor,
+            dev->full_configuration_descriptor_size,
+            usb_dp_standard_descriptor_nesting,
+            dump_match_ids_from_interface,
+            dev);
+}
+
+static void dump_descriptor_tree_brief_device(const char *prefix,
+    usb_standard_device_descriptor_t *descriptor)
+{
+        printf("%sDevice (0x%04x by 0x%04x, %s)\n", prefix,
+            (int) descriptor->product_id,
+            (int) descriptor->vendor_id,
+            usb_str_class(descriptor->device_class));
+}
+
+static void dump_descriptor_tree_brief_configuration(const char *prefix,
+    usb_standard_configuration_descriptor_t *descriptor)
+{
+        printf("%sConfiguration #%d\n", prefix,
+            (int) descriptor->configuration_number);
+}
+
+static void dump_descriptor_tree_brief_interface(const char *prefix,
+    usb_standard_interface_descriptor_t *descriptor)
+{
+        printf("%sInterface #%d (%s, 0x%02x, 0x%02x)\n", prefix,
+            (int) descriptor->interface_number,
+            usb_str_class(descriptor->interface_class),
+            (int) descriptor->interface_subclass,
+            (int) descriptor->interface_protocol);
+}
+
+static void dump_descriptor_tree_brief_endpoint(const char *prefix,
+    usb_standard_endpoint_descriptor_t *descriptor)
+{
+        usb_endpoint_t endpoint_no = descriptor->endpoint_address & 0xF;
+        usb_transfer_type_t transfer = descriptor->attributes & 0x3;
+        usb_direction_t direction = descriptor->endpoint_address & 0x80
+            ? USB_DIRECTION_IN : USB_DIRECTION_OUT;
+        printf("%sEndpoint #%d (%s %s, %zu)\n", prefix,
+            endpoint_no, usb_str_transfer_type(transfer),
+            direction == USB_DIRECTION_IN ? "in" : "out",
+            (size_t) descriptor->max_packet_size);
+}
+
+static void dump_descriptor_tree_brief_hid(const char *prefix,
+    usb_standard_hid_descriptor_t *descriptor)
+{
+        printf("%sHID (country %d, %d descriptors)\n", prefix,
+            (int) descriptor->country_code,
+            (int) descriptor->class_desc_count);
+}
+
+
+static void dump_descriptor_tree_brief_callback(uint8_t *descriptor,
+    size_t depth, void *arg)
+{
+        const char *indent = get_indent(depth + 1);
+
+        int descr_type = -1;
+        size_t descr_size = descriptor[0];
+        if (descr_size > 0) {
+                descr_type = descriptor[1];
+        }
+
+        switch (descr_type) {
+
+#define _BRANCH(type_enum, descriptor_type, callback) \
+        case type_enum: \
+                if (descr_size >= sizeof(descriptor_type)) { \
+                        callback(indent, (descriptor_type *) descriptor); \
+                } else { \
+                        descr_type = -1; \
+                } \
+                break;
+
+                _BRANCH(USB_DESCTYPE_DEVICE,
+                    usb_standard_device_descriptor_t,
+                    dump_descriptor_tree_brief_device);
+                _BRANCH(USB_DESCTYPE_CONFIGURATION,
+                    usb_standard_configuration_descriptor_t,
+                    dump_descriptor_tree_brief_configuration);
+                _BRANCH(USB_DESCTYPE_INTERFACE,
+                    usb_standard_interface_descriptor_t,
+                    dump_descriptor_tree_brief_interface);
+                _BRANCH(USB_DESCTYPE_ENDPOINT,
+                    usb_standard_endpoint_descriptor_t,
+                    dump_descriptor_tree_brief_endpoint);
+                _BRANCH(USB_DESCTYPE_HID,
+                    usb_standard_hid_descriptor_t,
+                    dump_descriptor_tree_brief_hid);
+
+                default:
+                        break;
+        }
+
+        if (descr_type == -1) {
+                printf("%sInvalid descriptor.\n", indent);
+        }
+}
+
+void dump_descriptor_tree_brief(usbinfo_device_t *dev)
+{
+        dump_descriptor_tree_brief_callback((uint8_t *)&dev->device_descriptor,
+            (size_t) -1, NULL);
+        usb_dp_walk_simple(dev->full_configuration_descriptor,
+            dev->full_configuration_descriptor_size,
+            usb_dp_standard_descriptor_nesting,
+            dump_descriptor_tree_brief_callback,
+            NULL);
+}
+
+void dump_strings(usbinfo_device_t *dev)
+{
+        /* Get supported languages. */
         l18_win_locales_t *langs;
         size_t langs_count;
-        rc = usb_request_get_supported_languages(&ctrl_pipe,
+        int rc = usb_request_get_supported_languages(&dev->ctrl_pipe,
             &langs, &langs_count);
         if (rc != EOK) {
@@ -147 +223 @@
                     NAME ": failed to get list of supported languages: %s.\n",
                     str_error(rc));
-                goto skip_strings;
-        }
-
-        printf("String languages (%zu):", langs_count);
+                return;
+        }
+
+        printf("%sString languages (%zu):", get_indent(0), langs_count);
         size_t i;
         for (i = 0; i < langs_count; i++) {
@@ -157 +233 @@
         printf(".\n");
 
-        /*
-         * Dump all strings in all available langages;
-         */
+        /* Get all strings and dump them. */
         for (i = 0; i < langs_count; i++) {
                 l18_win_locales_t lang = langs[i];
 
-                printf("%sStrings for language 0x%04x:\n", get_indent(0),
-                    (int) lang);
-
+                printf("%sStrings in %s:\n", get_indent(0),
+                    str_l18_win_locale(lang));
                 /*
-                 * Try all indexes - we will see what pops-up ;-).
-                 * However, to speed things up, we will stop after
-                 * encountering several broken (or nonexistent ones)
-                 * descriptors in line.
+                 * Try only the first 15 strings
+                 * (typically, device will not have much more anyway).
                  */
                 size_t idx;
-                size_t failed_count = 0;
-                for (idx = 1; idx < 0xFF; idx++) {
+                for (idx = 1; idx < 0x0F; idx++) {
                         char *string;
-                        rc = usb_request_get_string(&ctrl_pipe, idx, lang,
+                        rc = usb_request_get_string(&dev->ctrl_pipe, idx, lang,
                             &string);
                         if (rc != EOK) {
-                                failed_count++;
-                                if (failed_count > 3) {
-                                        break;
-                                }
                                 continue;
                         }
@@ -188 +254 @@
                             idx, string);
                         free(string);
-                        failed_count = 0; /* Reset failed counter. */
                 }
         }
-
-
-skip_strings:
-
-        rc = EOK;
-
-leave:
-        /* Ignoring errors here. */
-        usb_endpoint_pipe_end_session(&ctrl_pipe);
-
-        return rc;
 }
 

uspace/app/usbinfo/main.c

@@ -43 +43 @@
 #include <devman.h>
 #include <devmap.h>
+#include <usb/usbdevice.h>
+#include <usb/pipes.h>
 #include "usbinfo.h"
 
-enum {
-        ACTION_HELP = 256,
-        ACTION_DEVICE_ADDRESS,
-        ACTION_HOST_CONTROLLER,
-        ACTION_DEVICE,
-};
+static bool resolve_hc_handle_and_dev_addr(const char *devpath,
+    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
+{
+        int rc;
+
+        /* Hack for QEMU to save-up on typing ;-). */
+        if (str_cmp(devpath, "qemu") == 0) {
+                devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1";
+        }
+
+        char *path = str_dup(devpath);
+        if (path == NULL) {
+                return ENOMEM;
+        }
+
+        devman_handle_t hc = 0;
+        bool hc_found = false;
+        usb_address_t addr = 0;
+        bool addr_found = false;
+
+        /* Remove suffixes and hope that we will encounter device node. */
+        while (str_length(path) > 0) {
+                /* Get device handle first. */
+                devman_handle_t dev_handle;
+                rc = devman_device_get_handle(path, &dev_handle, 0);
+                if (rc != EOK) {
+                        free(path);
+                        return false;
+                }
+
+                /* Try to find its host controller. */
+                if (!hc_found) {
+                        rc = usb_hc_find(dev_handle, &hc);
+                        if (rc == EOK) {
+                                hc_found = true;
+                        }
+                }
+                /* Try to get its address. */
+                if (!addr_found) {
+                        addr = usb_device_get_assigned_address(dev_handle);
+                        if (addr >= 0) {
+                                addr_found = true;
+                        }
+                }
+
+                /* Speed-up. */
+                if (hc_found && addr_found) {
+                        break;
+                }
+
+                /* Remove the last suffix. */
+                char *slash_pos = str_rchr(path, '/');
+                if (slash_pos != NULL) {
+                        *slash_pos = 0;
+                }
+        }
+
+        free(path);
+
+        if (hc_found && addr_found) {
+                if (out_hc_handle != NULL) {
+                        *out_hc_handle = hc;
+                }
+                if (out_device_address != NULL) {
+                        *out_device_address = addr;
+                }
+                return true;
+        } else {
+                return false;
+        }
+}
+
+static void print_usage(char *app_name)
+{
+#define _INDENT "      "
+#define _OPTION(opt, description) \
+        printf(_INDENT opt "\n" _INDENT _INDENT description "\n")
+
+        printf(NAME ": query USB devices for descriptors\n\n");
+        printf("Usage: %s [options] device [device [device [ ... ]]]\n",
+            app_name);
+        printf(_INDENT "The device is a devman path to the device.\n");
+
+        _OPTION("-h --help", "Print this help and exit.");
+        _OPTION("-i --identification", "Brief device identification.");
+        _OPTION("-m --match-ids", "Print match ids generated for the device.");
+        _OPTION("-t --descriptor-tree", "Print descriptor tree.");
+        _OPTION("-s --strings", "Try to print all string descriptors.");
+
+        printf("\n");
+        printf("If no option is specified, `-i' is considered default.\n");
+        printf("\n");
+
+#undef _OPTION
+#undef _INDENT
+}
 
 static struct option long_options[] = {
-        {"help", no_argument, NULL, ACTION_HELP},
-        {"address", required_argument, NULL, ACTION_DEVICE_ADDRESS},
-        {"host-controller", required_argument, NULL, ACTION_HOST_CONTROLLER},
-        {"device", required_argument, NULL, ACTION_DEVICE},
+        {"help", no_argument, NULL, 'h'},
+        {"identification", no_argument, NULL, 'i'},
+        {"match-ids", no_argument, NULL, 'm'},
+        {"descriptor-tree", no_argument, NULL, 't'},
+        {"strings", no_argument, NULL, 's'},
         {0, 0, NULL, 0}
 };
-static const char *short_options = "ha:t:d:";
-
-static void print_usage(char *app_name)
-{
-#define INDENT "      "
-        printf(NAME ": query USB devices for descriptors\n\n");
-        printf("Usage: %s [options]\n", app_name);
-        printf(" -h --help\n" INDENT \
-            "Display this help.\n");
-        printf(" -tID --host-controller ID\n" INDENT \
-            "Set host controller (ID can be path or class number)\n");
-        printf(" -aADDR --address ADDR\n" INDENT \
-            "Set device address\n");
-        printf("\n");
-#undef INDENT
-}
-
-static int get_host_controller_handle(const char *path,
-    devman_handle_t *hc_handle)
-{
-        int rc;
-
-        if (str_cmp(path, "uhci") == 0) {
-                path = "/hw/pci0/00:01.2/uhci-hc";
-        }
-
-        devman_handle_t handle;
-        rc = devman_device_get_handle(path, &handle, 0);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed getting handle of `devman::/%s'.\n",
-                    path);
-                return rc;
-        }
-        *hc_handle = handle;
-
-        return EOK;
-}
-
-static int get_device_address(const char *str_address, usb_address_t *address)
-{
-        usb_address_t addr = (usb_address_t) strtol(str_address, NULL, 0);
-        if ((addr < 0) || (addr >= USB11_ADDRESS_MAX)) {
-                fprintf(stderr, NAME ": USB address out of range.\n");
-                return ERANGE;
-        }
-
-        *address = addr;
-        return EOK;
-}
-
+static const char *short_options = "himts";
+
+static usbinfo_action_t actions[] = {
+        {
+                .opt = 'i',
+                .action = dump_short_device_identification,
+                .active = false
+        },
+        {
+                .opt = 'm',
+                .action = dump_device_match_ids,
+                .active = false
+        },
+        {
+                .opt = 't',
+                .action = dump_descriptor_tree_brief,
+                .active = false
+        },
+        {
+                .opt = 's',
+                .action = dump_strings,
+                .active = false
+        },
+        {
+                .opt = 0
+        }
+};
 
 int main(int argc, char *argv[])
 {
-        devman_handle_t hc_handle = (devman_handle_t) -1;
-        usb_address_t device_address = (usb_address_t) -1;
-
         if (argc <= 1) {
                 print_usage(argv[0]);
@@ -121 +187 @@
         }
 
-        int i;
+        /*
+         * Process command-line options. They determine what shall be
+         * done with the device.
+         */
+        int opt;
         do {
-                i = getopt_long(argc, argv, short_options, long_options, NULL);
-                switch (i) {
+                opt = getopt_long(argc, argv,
+                    short_options, long_options, NULL);
+                switch (opt) {
                         case -1:
                                 break;
-
                         case '?':
                                 print_usage(argv[0]);
-                                return -1;
-
+                                return 1;
                         case 'h':
-                        case ACTION_HELP:
                                 print_usage(argv[0]);
                                 return 0;
-
-                        case 'a':
-                        case ACTION_DEVICE_ADDRESS: {
-                                int rc = get_device_address(optarg,
-                                    &device_address);
-                                if (rc != EOK) {
-                                        return rc;
+                        default: {
+                                int idx = 0;
+                                while (actions[idx].opt != 0) {
+                                        if (actions[idx].opt == opt) {
+                                                actions[idx].active = true;
+                                                break;
+                                        }
+                                        idx++;
                                 }
                                 break;
                         }
-
-                        case 't':
-                        case ACTION_HOST_CONTROLLER: {
-                                int rc = get_host_controller_handle(optarg,
-                                   &hc_handle);
-                                if (rc != EOK) {
-                                        return rc;
-                                }
-                                break;
-                        }
-
-                        case 'd':
-                        case ACTION_DEVICE:
-                                break;
-
-                        default:
-                                break;
-                }
-
-        } while (i != -1);
-
-        if ((hc_handle == (devman_handle_t) -1)
-            || (device_address == (usb_address_t) -1)) {
-                fprintf(stderr, NAME ": no target specified.\n");
-                return EINVAL;
-        }
-
-        dump_device(hc_handle, device_address);
+                }
+        } while (opt > 0);
+
+        /* Set the default action. */
+        int idx = 0;
+        bool something_active = false;
+        while (actions[idx].opt != 0) {
+                if (actions[idx].active) {
+                        something_active = true;
+                        break;
+                }
+                idx++;
+        }
+        if (!something_active) {
+                actions[0].active = true;
+        }
+
+        /*
+         * Go through all devices given on the command line and run the
+         * specified actions.
+         */
+        int i;
+        for (i = optind; i < argc; i++) {
+                char *devpath = argv[i];
+
+                /* The initialization is here only to make compiler happy. */
+                devman_handle_t hc_handle = 0;
+                usb_address_t dev_addr = 0;
+                bool found = resolve_hc_handle_and_dev_addr(devpath,
+                    &hc_handle, &dev_addr);
+                if (!found) {
+                        fprintf(stderr, NAME ": device `%s' not found "
+                            "or not of USB kind, skipping.\n",
+                            devpath);
+                        continue;
+                }
+
+                usbinfo_device_t *dev = prepare_device(hc_handle, dev_addr);
+                if (dev == NULL) {
+                        continue;
+                }
+
+                /* Run actions the user specified. */
+                printf("%s\n", devpath);
+
+                int action = 0;
+                while (actions[action].opt != 0) {
+                        if (actions[action].active) {
+                                actions[action].action(dev);
+                        }
+                        action++;
+                }
+
+                /* Destroy the control pipe (close the session etc.). */
+                destroy_device(dev);
+        }
 
         return 0;

uspace/app/usbinfo/usbinfo.h

@@ -38 +38 @@
 #include <usb/usb.h>
 #include <usb/descriptor.h>
+#include <usb/pipes.h>
 #include <usb/debug.h>
+#include <usb/dp.h>
 #include <ipc/devman.h>
+
+typedef struct {
+        usb_endpoint_pipe_t ctrl_pipe;
+        usb_device_connection_t wire;
+        usb_standard_device_descriptor_t device_descriptor;
+        uint8_t *full_configuration_descriptor;
+        size_t full_configuration_descriptor_size;
+} usbinfo_device_t;
+
+typedef struct {
+        int opt;
+        void (*action)(usbinfo_device_t *dev);
+        bool active;
+} usbinfo_action_t;
 
 
@@ -46 +62 @@
 void dump_buffer(const char *, size_t, const uint8_t *, size_t);
 const char *get_indent(size_t);
-void dump_match_ids(match_id_list_t *matches);
+void dump_match_ids(match_id_list_t *, const char *);
 void dump_usb_descriptor(uint8_t *, size_t);
-int dump_device(devman_handle_t, usb_address_t);
 void dump_descriptor_tree(uint8_t *, size_t);
 
@@ -56 +71 @@
 }
 
+usbinfo_device_t *prepare_device(devman_handle_t, usb_address_t);
+void destroy_device(usbinfo_device_t *);
+
+typedef void (*dump_descriptor_in_tree_t)(uint8_t *, size_t, void *);
+void browse_descriptor_tree(uint8_t *, size_t, usb_dp_descriptor_nesting_t *,
+    dump_descriptor_in_tree_t, size_t, void *);
+
+
+void dump_short_device_identification(usbinfo_device_t *);
+void dump_device_match_ids(usbinfo_device_t *);
+void dump_descriptor_tree_brief(usbinfo_device_t *);
+void dump_strings(usbinfo_device_t *);
+
+
 #endif
 /**

uspace/lib/c/Makefile

@@ -65 +65 @@
         generic/str.c \
         generic/str_error.c \
+        generic/l18n/langs.c \
         generic/fibril.c \
         generic/fibril_synch.c \

uspace/lib/c/include/l18n/langs.h

@@ -57 +57 @@
 } l18_win_locales_t;
 
+const char *str_l18_win_locale(l18_win_locales_t);
+
 #endif
 

uspace/lib/usb/include/usb/dp.h

@@ -77 +77 @@
     usb_dp_parser_data_t *, uint8_t *, uint8_t *);
 
+void usb_dp_walk_simple(uint8_t *, size_t, usb_dp_descriptor_nesting_t *,
+    void (*)(uint8_t *, size_t, void *), void *);
+
 #endif
 /**

uspace/lib/usb/include/usb/pipes.h

@@ -123 +123 @@
 
 int usb_device_get_assigned_interface(ddf_dev_t *);
+usb_address_t usb_device_get_assigned_address(devman_handle_t);
 
 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *,

uspace/lib/usb/src/dp.c

@@ -258 +258 @@
 }
 
+/** Browser of the descriptor tree.
+ *
+ * @see usb_dp_walk_simple
+ *
+ * @param parser Descriptor parser.
+ * @param data Data for descriptor parser.
+ * @param root Pointer to current root of the tree.
+ * @param depth Current nesting depth.
+ * @param callback Callback for each found descriptor.
+ * @param arg Custom (user) argument.
+ */
+static void usb_dp_browse_simple_internal(usb_dp_parser_t *parser,
+    usb_dp_parser_data_t *data, uint8_t *root, size_t depth,
+    void (*callback)(uint8_t *, size_t, void *), void *arg)
+{
+        if (root == NULL) {
+                return;
+        }
+        callback(root, depth, arg);
+        uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root);
+        do {
+                usb_dp_browse_simple_internal(parser, data, child, depth + 1,
+                    callback, arg);
+                child = usb_dp_get_sibling_descriptor(parser, data,
+                    root, child);
+        } while (child != NULL);
+}
+
+/** Browse flatten descriptor tree.
+ *
+ * The callback is called with following arguments: pointer to the start
+ * of the descriptor (somewhere inside @p descriptors), depth of the nesting
+ * (starting from 0 for the first descriptor) and the custom argument.
+ * Note that the size of the descriptor is not passed because it can
+ * be read from the first byte of the descriptor.
+ *
+ * @param descriptors Descriptor data.
+ * @param descriptors_size Size of descriptor data (in bytes).
+ * @param descriptor_nesting Possible descriptor nesting.
+ * @param callback Callback for each found descriptor.
+ * @param arg Custom (user) argument.
+ */
+void usb_dp_walk_simple(uint8_t *descriptors, size_t descriptors_size,
+    usb_dp_descriptor_nesting_t *descriptor_nesting,
+    void (*callback)(uint8_t *, size_t, void *), void *arg)
+{
+        if ((descriptors == NULL) || (descriptors_size == 0)
+            || (descriptor_nesting == NULL) || (callback == NULL)) {
+                return;
+        }
+
+        usb_dp_parser_data_t data = {
+                .data = descriptors,
+                .size = descriptors_size,
+                .arg = NULL
+        };
+
+        usb_dp_parser_t parser = {
+                .nesting = descriptor_nesting
+        };
+
+        usb_dp_browse_simple_internal(&parser, &data, descriptors,
+            0, callback, arg);
+}
 
 /** @}

uspace/lib/usb/src/pipes.c

@@ -52 +52 @@
         sysarg_t address;
 
-
         /*
          * We are sending special value as a handle - zero - to get
@@ -94 +93 @@
 
         return (int) iface_no;
+}
+
+/** Tell USB address assigned to given device.
+ *
+ * @param dev_handle Devman handle of the USB device in question.
+ * @return USB address or negative error code.
+ */
+usb_address_t usb_device_get_assigned_address(devman_handle_t dev_handle)
+{
+        int parent_phone = devman_parent_device_connect(dev_handle,
+            IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
+        }
+
+        sysarg_t address;
+
+        int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_ADDRESS,
+            dev_handle, &address);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        async_hangup(parent_phone);
+
+        return (usb_address_t) address;
 }