Changeset ca56afa in mainline for uspace/lib/usb/src

Timestamp:

2011-02-25T09:46:23Z (15 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

d493ac17

Parents:

15b0432 (diff), a80849c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge with /usb/development

Location:

uspace/lib/usb/src

Files:

• ddfiface.c (modified) (6 diffs)
• hub.c (modified) (3 diffs)
• pipes.c (modified) (9 diffs)
• pipesio.c (modified) (4 diffs)
• recognise.c (modified) (10 diffs)
• request.c (modified) (3 diffs)
• usbdevice.c (modified) (3 diffs)

uspace/lib/usb/src/ddfiface.c

@@ -34 +34 @@
  */
 #include <ipc/devman.h>
+#include <devman.h>
+#include <async.h>
 #include <usb/ddfiface.h>
+#include <usb/debug.h>
 #include <errno.h>
+#include <assert.h>
 
 /** DDF interface for USB device, implementation for typical hub. */
@@ -56 +60 @@
  * @return Error code.
  */
-int usb_iface_get_hc_handle_hub_impl(device_t *device, devman_handle_t *handle)
+int usb_iface_get_hc_handle_hub_impl(ddf_fun_t *fun, devman_handle_t *handle)
 {
-        assert(device);
-        return usb_hc_find(device->handle, handle);
+        assert(fun);
+        return usb_hc_find(fun->handle, handle);
 }
 
@@ -69 +73 @@
  * @return Error code.
  */
-int usb_iface_get_hc_handle_hub_child_impl(device_t *device,
+int usb_iface_get_hc_handle_hub_child_impl(ddf_fun_t *fun,
     devman_handle_t *handle)
 {
-        assert(device);
-        device_t *parent = device->parent;
+        assert(fun != NULL);
 
-        /* Default error, device does not support this operation. */
-        int rc = ENOTSUP;
-
-        if (parent && parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
-                usb_iface_t *usb_iface
-                    = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
-                assert(usb_iface != NULL);
-
-                if (usb_iface->get_hc_handle) {
-                        rc = usb_iface->get_hc_handle(parent, handle);
-                }
+        int parent_phone = devman_parent_device_connect(fun->handle,
+            IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
         }
 
-        return rc;
+        sysarg_t hc_handle;
+        int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &hc_handle);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        *handle = hc_handle;
+
+        return EOK;
 }
 
@@ -97 +103 @@
  * @return Always EOK.
  */
-int usb_iface_get_hc_handle_hc_impl(device_t *device, devman_handle_t *handle)
+int usb_iface_get_hc_handle_hc_impl(ddf_fun_t *fun, devman_handle_t *handle)
 {
-        assert(device);
+        assert(fun);
 
         if (handle != NULL) {
-                *handle = device->handle;
+                *handle = fun->handle;
         }
 
@@ -115 +121 @@
  * @return Error code.
  */
-int usb_iface_get_address_hub_impl(device_t *device, devman_handle_t handle,
+int usb_iface_get_address_hub_impl(ddf_fun_t *fun, devman_handle_t handle,
     usb_address_t *address)
 {
-        assert(device);
-        int parent_phone = devman_parent_device_connect(device->handle,
+        assert(fun);
+        int parent_phone = devman_parent_device_connect(fun->handle,
             IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
@@ -150 +156 @@
  * @return Error code.
  */
-int usb_iface_get_address_hub_child_impl(device_t *device,
+int usb_iface_get_address_hub_child_impl(ddf_fun_t *fun,
     devman_handle_t handle, usb_address_t *address)
 {
-        assert(device);
-        device_t *parent = device->parent;
-
-        /* Default error, device does not support this operation. */
-        int rc = ENOTSUP;
-
-        if (parent && parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
-                usb_iface_t *usb_iface
-                    = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
-                assert(usb_iface != NULL);
-
-                if (usb_iface->get_address) {
-                        rc = usb_iface->get_address(parent, handle, address);
-                }
+        if (handle == 0) {
+                handle = fun->handle;
         }
-
-        return rc;
+        return usb_iface_get_address_hub_impl(fun, handle, address);
 }
 

uspace/lib/usb/src/hub.c

@@ -39 +39 @@
 #include <usbhc_iface.h>
 #include <errno.h>
+#include <assert.h>
 
 /** Check that HC connection is alright.
@@ -172 +173 @@
  *      request or requests for descriptors when creating match ids).
  */
-int usb_hc_new_device_wrapper(device_t *parent, usb_hc_connection_t *connection,
+int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection,
     usb_speed_t dev_speed,
     int (*enable_port)(int port_no, void *arg), int port_no, void *arg,
-    usb_address_t *assigned_address, devman_handle_t *assigned_handle)
+    usb_address_t *assigned_address, devman_handle_t *assigned_handle,
+    ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
 {
         CHECK_CONNECTION(connection);
@@ -251 +253 @@
         devman_handle_t child_handle;
         rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle,
-            parent, &child_handle);
+            parent, &child_handle,
+            dev_ops, new_dev_data, new_fun);
         if (rc != EOK) {
                 rc = ESTALL;

uspace/lib/usb/src/pipes.c

@@ -35 +35 @@
 #include <usb/usb.h>
 #include <usb/pipes.h>
+#include <usb/debug.h>
 #include <usbhc_iface.h>
 #include <usb_iface.h>
+#include <devman.h>
 #include <errno.h>
 #include <assert.h>
@@ -46 +48 @@
  * @return USB address or error code.
  */
-static usb_address_t get_my_address(int phone, device_t *dev)
+static usb_address_t get_my_address(int phone, ddf_dev_t *dev)
 {
         sysarg_t address;
+
+
+        /*
+         * We are sending special value as a handle - zero - to get
+         * handle of the parent function (that handle was used
+         * when registering our device @p dev.
+         */
         int rc = async_req_2_1(phone, DEV_IFACE_ID(USB_DEV_IFACE),
             IPC_M_USB_GET_ADDRESS,
-            dev->handle, &address);
+            0, &address);
 
         if (rc != EOK) {
@@ -65 +74 @@
  * @return Interface number (negative code means any).
  */
-int usb_device_get_assigned_interface(device_t *device)
+int usb_device_get_assigned_interface(ddf_dev_t *device)
 {
         int parent_phone = devman_parent_device_connect(device->handle,
@@ -94 +103 @@
  */
 int usb_device_connection_initialize_from_device(
-    usb_device_connection_t *connection, device_t *device)
+    usb_device_connection_t *connection, ddf_dev_t *dev)
 {
         assert(connection);
-        assert(device);
+        assert(dev);
 
         int rc;
@@ -103 +112 @@
         usb_address_t my_address;
 
-        rc = usb_hc_find(device->handle, &hc_handle);
+        rc = usb_hc_find(dev->handle, &hc_handle);
         if (rc != EOK) {
                 return rc;
         }
 
-        int parent_phone = devman_parent_device_connect(device->handle,
+        int parent_phone = devman_parent_device_connect(dev->handle,
             IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
@@ -114 +123 @@
         }
 
-        my_address = get_my_address(parent_phone, device);
+        my_address = get_my_address(parent_phone, dev);
         if (my_address < 0) {
                 rc = my_address;
@@ -191 +200 @@
         assert(pipe);
 
-        if (pipe->hc_phone >= 0) {
+        if (usb_endpoint_pipe_is_session_started(pipe)) {
                 return EBUSY;
         }
@@ -217 +226 @@
         assert(pipe);
 
-        if (pipe->hc_phone < 0) {
+        if (!usb_endpoint_pipe_is_session_started(pipe)) {
                 return ENOENT;
         }
@@ -229 +238 @@
 
         return EOK;
+}
+
+/** Tell whether a session is started (open) on the endpoint pipe.
+ *
+ * The expected usage of this function is in assertions for some
+ * nested functions.
+ *
+ * @param pipe Endpoint pipe in question.
+ * @return Whether @p pipe has opened a session.
+ */
+bool usb_endpoint_pipe_is_session_started(usb_endpoint_pipe_t *pipe)
+{
+        return (pipe->hc_phone >= 0);
 }
 

uspace/lib/usb/src/pipesio.c

@@ -148 +148 @@
         }
 
-        if (pipe->hc_phone < 0) {
+        if (!usb_endpoint_pipe_is_session_started(pipe)) {
                 return EBADF;
         }
@@ -255 +255 @@
         }
 
-        if (pipe->hc_phone < 0) {
+        if (!usb_endpoint_pipe_is_session_started(pipe)) {
                 return EBADF;
         }
@@ -369 +369 @@
         }
 
-        if (pipe->hc_phone < 0) {
+        if (!usb_endpoint_pipe_is_session_started(pipe)) {
                 return EBADF;
         }
@@ -481 +481 @@
         }
 
-        if (pipe->hc_phone < 0) {
+        if (!usb_endpoint_pipe_is_session_started(pipe)) {
                 return EBADF;
         }

uspace/lib/usb/src/recognise.c

@@ -34 +34 @@
  */
 #include <sys/types.h>
+#include <fibril_synch.h>
 #include <usb/pipes.h>
 #include <usb/recognise.h>
@@ -41 +42 @@
 #include <stdio.h>
 #include <errno.h>
+#include <assert.h>
 
 static size_t device_name_index = 0;
 static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex);
 
-device_ops_t child_ops = {
+ddf_dev_ops_t child_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface_hub_child_impl
 };
@@ -308 +310 @@
         }
 
-        /*
-         * As a fallback, provide the simplest match id possible.
-         */
-        ADD_MATCHID_OR_RETURN(matches, 1, "usb&fallback");
-
         return EOK;
 }
@@ -326 +323 @@
 int usb_device_register_child_in_devman(usb_address_t address,
     devman_handle_t hc_handle,
-    device_t *parent, devman_handle_t *child_handle)
+    ddf_dev_t *parent, devman_handle_t *child_handle,
+    ddf_dev_ops_t *dev_ops, void *dev_data, ddf_fun_t **child_fun)
 {
         size_t this_device_name_index;
@@ -335 +333 @@
         fibril_mutex_unlock(&device_name_index_mutex);
 
-        device_t *child = NULL;
+        ddf_fun_t *child = NULL;
         char *child_name = NULL;
         int rc;
@@ -352 +350 @@
         }
 
-        child = create_device();
+        /*
+         * TODO: Once the device driver framework support persistent
+         * naming etc., something more descriptive could be created.
+         */
+        rc = asprintf(&child_name, "usbdev%02zu", this_device_name_index);
+        if (rc < 0) {
+                goto failure;
+        }
+
+        child = ddf_fun_create(parent, fun_inner, child_name);
         if (child == NULL) {
                 rc = ENOMEM;
@@ -358 +365 @@
         }
 
-        /*
-         * TODO: Once the device driver framework support persistent
-         * naming etc., something more descriptive could be created.
-         */
-        rc = asprintf(&child_name, "usbdev%02zu", this_device_name_index);
-        if (rc < 0) {
-                goto failure;
-        }
-        child->parent = parent;
-        child->name = child_name;
-        child->ops = &child_ops;
+        if (dev_ops != NULL) {
+                child->ops = dev_ops;
+        } else {
+                child->ops = &child_ops;
+        }
+
+        child->driver_data = dev_data;
 
         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
@@ -385 +388 @@
         }
 
-        rc = child_device_register(child, parent);
+        rc = ddf_fun_bind(child);
         if (rc != EOK) {
                 goto failure;
@@ -392 +395 @@
         if (child_handle != NULL) {
                 *child_handle = child->handle;
+        }
+
+        if (child_fun != NULL) {
+                *child_fun = child;
         }
 
@@ -400 +407 @@
                 child->name = NULL;
                 /* This takes care of match_id deallocation as well. */
-                delete_device(child);
+                ddf_fun_destroy(child);
         }
         if (child_name != NULL) {

uspace/lib/usb/src/request.c

@@ -35 +35 @@
 #include <usb/request.h>
 #include <errno.h>
+#include <assert.h>
 
 #define MAX_DATA_LENGTH ((size_t)(0xFFFF))
@@ -229 +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.
  *
@@ -354 +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;
+}
+
 /**
  * @}

uspace/lib/usb/src/usbdevice.c

@@ -37 +37 @@
 #include <usb_iface.h>
 #include <usb/usbdevice.h>
+#include <usb/debug.h>
 #include <errno.h>
+#include <assert.h>
 
 /** Find host controller handle that is ancestor of given device.
@@ -55 +57 @@
 
         devman_handle_t h;
+        usb_log_debug("asking for HC handle (my handle is %zu).\n", device_handle);
         int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
             IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
@@ -78 +81 @@
  */
 int usb_hc_connection_initialize_from_device(usb_hc_connection_t *connection,
-    device_t *device)
+    ddf_dev_t *device)
 {
         assert(connection);