Changes in / [a9c674e0:a80849c] in mainline

Location:

uspace

Files:

• app/usbinfo/dump.c (modified) (1 diff)
• app/usbinfo/info.c (modified) (1 diff)
• app/usbinfo/usbinfo.h (modified) (1 diff)
• lib/c/generic/str_error.c (modified) (1 diff)
• lib/c/include/errno.h (modified) (1 diff)
• lib/c/include/l18n/langs.h (added)
• lib/usb/include/usb/request.h (modified) (3 diffs)
• lib/usb/src/recognise.c (modified) (1 diff)
• lib/usb/src/request.c (modified) (2 diffs)

uspace/app/usbinfo/dump.c

@@ -53 +53 @@
 
 
-static const char *get_indent(size_t level)
+const char *get_indent(size_t level)
 {
         static const char *indents[] = {

uspace/app/usbinfo/info.c

@@ -129 +129 @@
             config_descriptor.total_length);
 
+        /*
+         * Get supported languages of STRING descriptors.
+         */
+        l18_win_locales_t *langs;
+        size_t langs_count;
+        rc = usb_request_get_supported_languages(&ctrl_pipe,
+            &langs, &langs_count);
+        if (rc != EOK) {
+                fprintf(stderr,
+                    NAME ": failed to get list of supported languages: %s.\n",
+                    str_error(rc));
+                goto skip_strings;
+        }
+
+        printf("String languages (%zu):", langs_count);
+        size_t i;
+        for (i = 0; i < langs_count; i++) {
+                printf(" 0x%04x", (int) langs[i]);
+        }
+        printf(".\n");
+
+        /*
+         * Dump all strings in all available langages;
+         */
+        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);
+
+                /*
+                 * 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.
+                 */
+                size_t idx;
+                size_t failed_count = 0;
+                for (idx = 1; idx < 0xFF; idx++) {
+                        char *string;
+                        rc = usb_request_get_string(&ctrl_pipe, idx, lang,
+                            &string);
+                        if (rc != EOK) {
+                                failed_count++;
+                                if (failed_count > 3) {
+                                        break;
+                                }
+                                continue;
+                        }
+                        printf("%sString #%zu: \"%s\"\n", get_indent(1),
+                            idx, string);
+                        free(string);
+                        failed_count = 0; /* Reset failed counter. */
+                }
+        }
+
+
+skip_strings:
+
         rc = EOK;
+
 leave:
         /* Ignoring errors here. */

uspace/app/usbinfo/usbinfo.h

@@ -45 +45 @@
 
 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_usb_descriptor(uint8_t *, size_t);

uspace/lib/c/generic/str_error.c

@@ -77 +77 @@
                 case EAGAIN:
                         return "Resource temporarily unavailable";
+                case EEMPTY:
+                        return "Resource is empty";
                 default:
                         break;

uspace/lib/c/include/errno.h

@@ -62 +62 @@
 #define ESTALL (-301)
 
+/** Empty resource (no data). */
+#define EEMPTY (-302)
+
 /** An API function is called while another blocking function is in progress. */
 #define EINPROGRESS  (-10036)

uspace/lib/usb/include/usb/request.h

@@ -37 +37 @@
 
 #include <sys/types.h>
+#include <l18n/langs.h>
 #include <usb/usb.h>
 #include <usb/pipes.h>
@@ -96 +97 @@
 int usb_request_get_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
     uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
+int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t *, usb_request_type_t,
+    uint8_t, uint8_t, uint16_t, void **, size_t *);
 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *,
     usb_standard_device_descriptor_t *);
@@ -104 +107 @@
 int usb_request_set_configuration(usb_endpoint_pipe_t *, uint8_t);
 
+int usb_request_get_supported_languages(usb_endpoint_pipe_t *,
+    l18_win_locales_t **, size_t *);
+int usb_request_get_string(usb_endpoint_pipe_t *, size_t, l18_win_locales_t,
+    char **);
+
 #endif
 /**

uspace/lib/usb/src/recognise.c

@@ -310 +310 @@
         }
 
-        /*
-         * As a fallback, provide the simplest match id possible.
-         */
-        ADD_MATCHID_OR_RETURN(matches, 1, "usb&fallback");
-
         return EOK;
 }

uspace/lib/usb/src/request.c

@@ -230 +230 @@
 }
 
+/** Retrieve USB descriptor, allocate space for it.
+ *
+ * @param[in] pipe Control endpoint pipe (session must be already started).
+ * @param[in] request_type Request type (standard/class/vendor).
+ * @param[in] descriptor_type Descriptor type (device/configuration/HID/...).
+ * @param[in] descriptor_index Descriptor index.
+ * @param[in] language Language index.
+ * @param[out] buffer_ptr Where to store pointer to allocated buffer.
+ * @param[out] buffer_size Where to store the size of the descriptor.
+ * @return
+ */
+int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
+    usb_request_type_t request_type,
+    uint8_t descriptor_type, uint8_t descriptor_index,
+    uint16_t language,
+    void **buffer_ptr, size_t *buffer_size)
+{
+        if (buffer_ptr == NULL) {
+                return EBADMEM;
+        }
+
+        int rc;
+
+        /*
+         * Get only first byte to retrieve descriptor length.
+         */
+        uint8_t tmp_buffer[1];
+        size_t bytes_transfered;
+        rc = usb_request_get_descriptor(pipe, request_type,
+            descriptor_type, descriptor_index, language,
+            &tmp_buffer, 1, &bytes_transfered);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (bytes_transfered != 1) {
+                /* FIXME: some better error code? */
+                return ESTALL;
+        }
+
+        size_t size = tmp_buffer[0];
+        if (size == 0) {
+                /* FIXME: some better error code? */
+                return ESTALL;
+        }
+
+        /*
+         * Allocate buffer and get the descriptor again.
+         */
+        void *buffer = malloc(size);
+        if (buffer == NULL) {
+                return ENOMEM;
+        }
+
+        rc = usb_request_get_descriptor(pipe, request_type,
+            descriptor_type, descriptor_index, language,
+            buffer, size, &bytes_transfered);
+        if (rc != EOK) {
+                free(buffer);
+                return rc;
+        }
+        if (bytes_transfered != size) {
+                free(buffer);
+                /* FIXME: some better error code? */
+                return ESTALL;
+        }
+
+        *buffer_ptr = buffer;
+        if (buffer_size != NULL) {
+                *buffer_size = size;
+        }
+
+        return EOK;
+}
+
 /** Retrieve standard device descriptor of a USB device.
  *
@@ -355 +429 @@
 }
 
+/** Get list of supported languages by USB device.
+ *
+ * @param[in] pipe Control endpoint pipe (session must be already started).
+ * @param[out] languages_ptr Where to store pointer to allocated array of
+ *      supported languages.
+ * @param[out] languages_count Number of supported languages.
+ * @return Error code.
+ */
+int usb_request_get_supported_languages(usb_endpoint_pipe_t *pipe,
+    l18_win_locales_t **languages_ptr, size_t *languages_count)
+{
+        int rc;
+
+        if (languages_ptr == NULL) {
+                return EBADMEM;
+        }
+        if (languages_count == NULL) {
+                return EBADMEM;
+        }
+
+        uint8_t *string_descriptor = NULL;
+        size_t string_descriptor_size = 0;
+        rc = usb_request_get_descriptor_alloc(pipe,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
+            (void **) &string_descriptor, &string_descriptor_size);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (string_descriptor_size <= 2) {
+                free(string_descriptor);
+                return EEMPTY;
+        }
+        /* Substract first 2 bytes (length and descriptor type). */
+        string_descriptor_size -= 2;
+
+        /* Odd number of bytes - descriptor is broken? */
+        if ((string_descriptor_size % 2) != 0) {
+                /* FIXME: shall we return with error or silently ignore? */
+                free(string_descriptor);
+                return ESTALL;
+        }
+
+        size_t langs_count = string_descriptor_size / 2;
+        l18_win_locales_t *langs
+            = malloc(sizeof(l18_win_locales_t) * langs_count);
+        if (langs == NULL) {
+                free(string_descriptor);
+                return ENOMEM;
+        }
+
+        size_t i;
+        for (i = 0; i < langs_count; i++) {
+                /* Language code from the descriptor is in USB endianess. */
+                /* FIXME: is this really correct? */
+                uint16_t lang_code = (string_descriptor[2 + 2 * i + 1] << 8)
+                    + string_descriptor[2 + 2 * i];
+                langs[i] = uint16_usb2host(lang_code);
+        }
+
+        free(string_descriptor);
+
+        *languages_ptr = langs;
+        *languages_count =langs_count;
+
+        return EOK;
+}
+
+/** Get string (descriptor) from USB device.
+ *
+ * The string is returned in native encoding of the operating system.
+ * For HelenOS, that is UTF-8.
+ *
+ * @param[in] pipe Control endpoint pipe (session must be already started).
+ * @param[in] index String index (in native endianess).
+ * @param[in] lang String language (in native endianess).
+ * @param[out] string_ptr Where to store allocated string in native encoding.
+ * @return Error code.
+ */
+int usb_request_get_string(usb_endpoint_pipe_t *pipe,
+    size_t index, l18_win_locales_t lang, char **string_ptr)
+{
+        if (string_ptr == NULL) {
+                return EBADMEM;
+        }
+        /* Index is actually one byte value. */
+        if (index > 0xFF) {
+                return ERANGE;
+        }
+        /* Language is actually two byte value. */
+        if (lang > 0xFFFF) {
+                return ERANGE;
+        }
+
+        int rc;
+
+        /* Prepare dynamically allocated variables. */
+        uint8_t *string = NULL;
+        wchar_t *string_chars = NULL;
+
+        /* Get the actual descriptor. */
+        size_t string_size;
+        rc = usb_request_get_descriptor_alloc(pipe,
+            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
+            index, uint16_host2usb(lang),
+            (void **) &string, &string_size);
+        if (rc != EOK) {
+                goto leave;
+        }
+
+        if (string_size <= 2) {
+                rc =  EEMPTY;
+                goto leave;
+        }
+        /* Substract first 2 bytes (length and descriptor type). */
+        string_size -= 2;
+
+        /* Odd number of bytes - descriptor is broken? */
+        if ((string_size % 2) != 0) {
+                /* FIXME: shall we return with error or silently ignore? */
+                rc = ESTALL;
+                goto leave;
+        }
+
+        size_t string_char_count = string_size / 2;
+        string_chars = malloc(sizeof(wchar_t) * (string_char_count + 1));
+        if (string_chars == NULL) {
+                rc = ENOMEM;
+                goto leave;
+        }
+
+        /*
+         * Build a wide string.
+         * And do not forget to set NULL terminator (string descriptors
+         * do not have them).
+         */
+        size_t i;
+        for (i = 0; i < string_char_count; i++) {
+                uint16_t uni_char = (string[2 + 2 * i + 1] << 8)
+                    + string[2 + 2 * i];
+                string_chars[i] = uni_char;
+        }
+        string_chars[string_char_count] = 0;
+
+
+        /* Convert to normal string. */
+        char *str = wstr_to_astr(string_chars);
+        if (str == NULL) {
+                rc = ENOMEM;
+                goto leave;
+        }
+
+        *string_ptr = str;
+        rc = EOK;
+
+leave:
+        if (string != NULL) {
+                free(string);
+        }
+        if (string_chars != NULL) {
+                free(string_chars);
+        }
+
+        return rc;
+}
+
 /**
  * @}