Changeset bd575647 in mainline

Timestamp:

2011-12-11T16:30:42Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

7d5ef94

Parents:

2c202c5

Message:

libusbdev: Use shared hc_connection for pipes.

Location:

uspace/lib/usbdev

Files:

• Makefile (modified) (1 diff)
• include/usb/dev/driver.h (modified) (1 diff)
• include/usb/dev/pipes.h (modified) (6 diffs)
• src/devdrv.c (modified) (5 diffs)
• src/hub.c (modified) (7 diffs)
• src/pipepriv.c (modified) (1 diff)
• src/pipepriv.h (modified) (1 diff)
• src/pipes.c (modified) (4 diffs)
• src/pipesinit.c (modified) (3 diffs)
• src/pipesio.c (modified) (2 diffs)

uspace/lib/usbdev/Makefile

@@ -40 +40 @@
         src/dp.c \
         src/hub.c \
-        src/pipepriv.c \
-        src/pipepriv.h \
         src/pipes.c \
         src/pipesinit.c \

uspace/lib/usbdev/include/usb/dev/driver.h

@@ -72 +72 @@
 /** USB device structure. */
 typedef struct {
+        usb_hc_connection_t hc_conn;
         /** Connection backing the pipes.
          * Typically, you will not need to use this attribute at all.

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

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 /** @addtogroup libusbdev
  * @{
@@ -38 +37 @@
 #include <sys/types.h>
 #include <usb/usb.h>
-#include <usb/hc.h>
+#include <usb/dev.h>
 #include <usb/descriptor.h>
 #include <ipc/devman.h>
@@ -44 +43 @@
 #include <fibril_synch.h>
 #include <async.h>
-
-/** Abstraction of a physical connection to the device.
- * This type is an abstraction of the USB wire that connects the host and
- * the function (device).
- */
-typedef struct {
-        /** Handle of the host controller device is connected to. */
-        devman_handle_t hc_handle;
-        /** Address of the device. */
-        usb_address_t address;
-} usb_device_connection_t;
 
 /** Abstraction of a logical connection to USB device endpoint.
@@ -85 +73 @@
         /** Maximum packet size for the endpoint. */
         size_t max_packet_size;
-
-        /** Session to the host controller.
-         * NULL when no session is active.
-         * It is an error to access this member without @c hc_sess_mutex
-         * being locked.
-         * If call over the phone is to be made, it must be preceeded by
-         * call to pipe_add_ref() [internal libusb function].
-         */
-        async_sess_t *hc_sess;
-
-        /** Guard for serialization of requests over the session. */
-        fibril_mutex_t hc_sess_mutex;
-
-        /** Number of active transfers over the pipe. */
-        int refcount;
-        /** Number of failed attempts to open the HC phone.
-         * When user requests usb_pipe_start_long_transfer() and the operation
-         * fails, there is no way to report this to the user.
-         * That the soft reference counter is increased to record the attempt.
-         * When the user then request e.g. usb_pipe_read(), it will try to
-         * add reference as well.
-         * If that fails, it is reported to the user. If it is okay, the
-         * real reference counter is incremented.
-         * The problem might arise when ending the long transfer (since
-         * the number of references would be only 1, but logically it shall be
-         * two).
-         * Decrementing the soft counter first shall solve this.
-         */
-        int refcount_soft;
 
         /** Whether to automatically reset halt on the endpoint.
@@ -156 +115 @@
 } usb_endpoint_mapping_t;
 
-int usb_device_connection_initialize_on_default_address(
-    usb_device_connection_t *, usb_hc_connection_t *);
-int usb_device_connection_initialize_from_device(usb_device_connection_t *,
-    const ddf_dev_t *);
-int usb_device_connection_initialize(usb_device_connection_t *,
-    devman_handle_t, usb_address_t);
 
 int usb_device_get_assigned_interface(const ddf_dev_t *);
@@ -169 +122 @@
 int usb_pipe_initialize_default_control(usb_pipe_t *,
     usb_device_connection_t *);
+
 int usb_pipe_probe_default_control(usb_pipe_t *);
 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, const uint8_t *, size_t, usb_device_connection_t *);
-int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
-int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);
+int usb_pipe_register(usb_pipe_t *, unsigned);
+int usb_pipe_unregister(usb_pipe_t *);
 
 void usb_pipe_start_long_transfer(usb_pipe_t *);

uspace/lib/usbdev/src/devdrv.c

@@ -373 +373 @@
         }
 
-        /* Register the endpoints with HC. */
-        usb_hc_connection_t hc_conn;
-        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev);
-        if (rc != EOK) {
-                goto rollback_free_only;
-        }
-
-        rc = usb_hc_connection_open(&hc_conn);
-        if (rc != EOK) {
-                goto rollback_free_only;
-        }
-
         for (i = 0; i < pipe_count; i++) {
                 if (pipes[i].present) {
                         rc = usb_pipe_register(&pipes[i].pipe,
-                            pipes[i].descriptor->poll_interval, &hc_conn);
+                            pipes[i].descriptor->poll_interval);
                         if (rc != EOK) {
                                 goto rollback_unregister_endpoints;
@@ -394 +382 @@
                 }
         }
-
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("%s: Failed to close connection.\n",
-                    __FUNCTION__);
 
         *pipes_ptr = pipes;
@@ -415 +399 @@
         for (i = 0; i < pipe_count; i++) {
                 if (pipes[i].present) {
-                        usb_pipe_unregister(&pipes[i].pipe, &hc_conn);
+                        usb_pipe_unregister(&pipes[i].pipe);
                 }
         }
-
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_device_create_pipes(): "
-                    "Failed to close connection.\n");
 
         /*
@@ -470 +450 @@
                     i, pipes[i].present ? "" : "not ");
                 if (pipes[i].present)
-                        usb_pipe_unregister(&pipes[i].pipe, &hc_conn);
-        }
-
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_device_destroy_pipes(): "
-                    "Failed to close connection.\n");
+                        usb_pipe_unregister(&pipes[i].pipe);
+        }
 
         free(pipes);
@@ -505 +481 @@
         usb_dev->pipes = NULL;
 
+        usb_hc_connection_initialize_from_device(&usb_dev->hc_conn, ddf_dev);
+        const usb_address_t address =
+            usb_get_address_by_handle(ddf_dev->handle);
         /* Initialize backing wire and control pipe. */
-        int rc = usb_device_connection_initialize_from_device(
-            &usb_dev->wire, ddf_dev);
+        int rc = usb_device_connection_initialize(
+            &usb_dev->wire, &usb_dev->hc_conn, address);
         if (rc != EOK) {
                 *errstr_ptr = "device connection initialization";

uspace/lib/usbdev/src/hub.c

@@ -63 +63 @@
         } while (false)
 
-/** Ask host controller for free address assignment.
- *
- * @param connection Opened connection to host controller.
- * @param preferred Preferred SUB address.
- * @param strict Fail if the preferred address is not avialable.
- * @param speed Speed of the new device (device that will be assigned
- *    the returned address).
- * @return Assigned USB address or negative error code.
- */
-usb_address_t usb_hc_request_address(usb_hc_connection_t *connection,
-    usb_address_t preferred, bool strict, usb_speed_t speed)
-{
-        CHECK_CONNECTION(connection);
-
-        async_exch_t *exch = async_exchange_begin(connection->hc_sess);
-        if (!exch)
-                return (usb_address_t)ENOMEM;
-
-        usb_address_t address = preferred;
-        const int ret = usbhc_request_address(exch, &address, strict, speed);
-
-        async_exchange_end(exch);
-        return ret == EOK ? address : ret;
-}
 
 /** Inform host controller about new device.
@@ -97 +73 @@
     const usb_hub_attached_device_t *attached_device)
 {
-        CHECK_CONNECTION(connection);
+//      CHECK_CONNECTION(connection);
         if (attached_device == NULL || attached_device->fun == NULL)
                 return EINVAL;
@@ -120 +96 @@
     usb_address_t address)
 {
-        CHECK_CONNECTION(connection);
+//      CHECK_CONNECTION(connection);
 
         async_exch_t *exch = async_exchange_begin(connection->hc_sess);
@@ -166 +142 @@
 
         /* TODO: prevent others from accessing the wire now. */
-        if (usb_pipe_unregister(pipe, hc_conn) != EOK) {
+        if (usb_pipe_unregister(pipe) != EOK) {
                 usb_log_warning(
                     "Failed to unregister the old pipe on address change.\n");
@@ -172 +148 @@
         /* The address is already changed so set it in the wire */
         pipe->wire->address = new_address;
-        rc = usb_pipe_register(pipe, 0, hc_conn);
+        rc = usb_pipe_register(pipe, 0);
         if (rc != EOK)
                 return EADDRNOTAVAIL;
@@ -288 +264 @@
 
         /* Register control pipe on default address. */
-        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
+        rc = usb_pipe_register(&ctrl_pipe, 0);
         if (rc != EOK) {
                 rc = ENOTCONN;
@@ -385 +361 @@
 leave_release_free_address:
         /* This might be either 0:0 or dev_addr:0 */
-        if (usb_pipe_unregister(&ctrl_pipe, &hc_conn) != EOK)
+        if (usb_pipe_unregister(&ctrl_pipe) != EOK)
                 usb_log_warning("%s: Failed to unregister default pipe.\n",
                     __FUNCTION__);

uspace/lib/usbdev/src/pipepriv.c

@@ -90 +90 @@
                 /* Need to open the phone by ourselves. */
                 async_sess_t *sess =
-                    devman_device_connect(EXCHANGE_SERIALIZE, pipe->wire->hc_handle, 0);
+                    devman_device_connect(EXCHANGE_SERIALIZE, pipe->wire->hc_connection->hc_handle, 0);
                 if (!sess) {
                         if (hide_failure) {

uspace/lib/usbdev/src/pipepriv.h

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 /** @addtogroup libusbdev
  * @{

uspace/lib/usbdev/src/pipes.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -26 +27 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 /** @addtogroup libusbdev
  * @{
@@ -33 +33 @@
  * USB endpoint pipes miscellaneous functions.
  */
-#include <usb/usb.h>
+#include <usb_iface.h>
 #include <usb/dev/pipes.h>
-#include <usb/debug.h>
-#include <usb/hc.h>
-#include <usbhc_iface.h>
-#include <usb_iface.h>
-#include <devman.h>
+#include <usb/dev.h>
 #include <errno.h>
 #include <assert.h>
 #include "pipepriv.h"
-
-#define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */
-
-/** Tell USB address assigned to given device.
- *
- * @param sess Session to parent device.
- * @param dev Device in question.
- * @return USB address or error code.
- */
-static usb_address_t get_my_address(async_sess_t *sess, const ddf_dev_t *dev)
-{
-        assert(sess);
-        async_exch_t *exch = async_exchange_begin(sess);
-        if (!exch)
-                return ENOMEM;
-
-        usb_address_t address;
-        const int ret = usb_get_my_address(exch, &address);
-
-        async_exchange_end(exch);
-
-        return (ret == EOK) ? address : ret;
-}
 
 /** Tell USB interface assigned to given device.
@@ -91 +64 @@
 
         return ret == EOK ? iface_no : ret;
-}
-
-/** Initialize connection to USB device.
- *
- * @param connection Connection structure to be initialized.
- * @param dev Generic device backing the USB device.
- * @return Error code.
- */
-int usb_device_connection_initialize_from_device(
-    usb_device_connection_t *connection, const ddf_dev_t *dev)
-{
-        assert(connection);
-        assert(dev);
-        
-        int rc;
-        devman_handle_t hc_handle;
-        usb_address_t my_address;
-        
-        rc = usb_hc_find(dev->handle, &hc_handle);
-        if (rc != EOK)
-                return rc;
-        
-        async_sess_t *parent_sess =
-            devman_parent_device_connect(EXCHANGE_ATOMIC, dev->handle,
-            IPC_FLAG_BLOCKING);
-        if (!parent_sess)
-                return ENOMEM;
-        
-        /*
-         * Asking for "my" address may require several attempts.
-         * That is because following scenario may happen:
-         *  - parent driver (i.e. driver of parent device) announces new device
-         *    and devman launches current driver
-         *  - parent driver is preempted and thus does not send address-handle
-         *    binding to HC driver
-         *  - this driver gets here and wants the binding
-         *  - the HC does not know the binding yet and thus it answers ENOENT
-         *  So, we need to wait for the HC to learn the binding.
-         */
-        
-        do {
-                my_address = get_my_address(parent_sess, dev);
-                
-                if (my_address == ENOENT) {
-                        /* Be nice, let other fibrils run and try again. */
-                        async_usleep(IPC_AGAIN_DELAY);
-                } else if (my_address < 0) {
-                        /* Some other problem, no sense trying again. */
-                        rc = my_address;
-                        goto leave;
-                }
-        
-        } while (my_address < 0);
-        
-        rc = usb_device_connection_initialize(connection,
-            hc_handle, my_address);
-        
-leave:
-        async_hangup(parent_sess);
-        return rc;
-}
-
-/** Initialize connection to USB device.
- *
- * @param connection Connection structure to be initialized.
- * @param host_controller_handle Devman handle of host controller device is
- *      connected to.
- * @param device_address Device USB address.
- * @return Error code.
- */
-int usb_device_connection_initialize(usb_device_connection_t *connection,
-    devman_handle_t host_controller_handle, usb_address_t device_address)
-{
-        assert(connection);
-
-        if ((device_address < 0) || (device_address >= USB11_ADDRESS_MAX)) {
-                return EINVAL;
-        }
-
-        connection->hc_handle = host_controller_handle;
-        connection->address = device_address;
-
-        return EOK;
-}
-
-/** Initialize connection to USB device on default address.
- *
- * @param dev_connection Device connection structure to be initialized.
- * @param hc_connection Initialized connection to host controller.
- * @return Error code.
- */
-int usb_device_connection_initialize_on_default_address(
-    usb_device_connection_t *dev_connection,
-    usb_hc_connection_t *hc_connection)
-{
-        assert(dev_connection);
-
-        if (hc_connection == NULL) {
-                return EBADMEM;
-        }
-
-        return usb_device_connection_initialize(dev_connection,
-            hc_connection->hc_handle, (usb_address_t) 0);
 }
 

uspace/lib/usbdev/src/pipesinit.c

@@ -349 +349 @@
         fibril_mutex_initialize(&pipe->guard);
         pipe->wire = connection;
-        pipe->hc_sess = NULL;
-        fibril_mutex_initialize(&pipe->hc_sess_mutex);
         pipe->endpoint_no = endpoint_no;
         pipe->transfer_type = transfer_type;
         pipe->max_packet_size = max_packet_size;
         pipe->direction = direction;
-        pipe->refcount = 0;
-        pipe->refcount_soft = 0;
         pipe->auto_reset_halt = false;
 
@@ -442 +438 @@
  * @return Error code.
  */
-int usb_pipe_register(usb_pipe_t *pipe, unsigned interval,
-    usb_hc_connection_t *hc_connection)
+int usb_pipe_register(usb_pipe_t *pipe, unsigned interval)
 {
         assert(pipe);
         assert(pipe->wire);
-        assert(hc_connection);
-
-        if (!usb_hc_connection_is_opened(hc_connection))
-                return EBADF;
-        async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess);
-        if (!exch)
-                return ENOMEM;
-        const int ret = usbhc_register_endpoint(exch,
-            pipe->wire->address, pipe->endpoint_no, pipe->transfer_type,
-            pipe->direction, pipe->max_packet_size, interval);
-
-        async_exchange_end(exch);
-        return ret;
+        assert(pipe->wire->hc_connection);
+
+        return usb_hc_register_endpoint(pipe->wire->hc_connection,
+           pipe->wire->address, pipe->endpoint_no, pipe->transfer_type,
+           pipe->direction, pipe->max_packet_size, interval);
 }
 
@@ -468 +455 @@
  * @return Error code.
  */
-int usb_pipe_unregister(usb_pipe_t *pipe,
-    usb_hc_connection_t *hc_connection)
+int usb_pipe_unregister(usb_pipe_t *pipe)
 {
         assert(pipe);
         assert(pipe->wire);
-        assert(hc_connection);
-
-        if (!usb_hc_connection_is_opened(hc_connection))
-                return EBADF;
-
-        async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess);
-        if (!exch)
-                return ENOMEM;
-        const int ret = usbhc_unregister_endpoint(exch,
+        assert(pipe->wire->hc_connection);
+
+        return usb_hc_unregister_endpoint(pipe->wire->hc_connection,
             pipe->wire->address, pipe->endpoint_no, pipe->direction);
-        async_exchange_end(exch);
-
-        return ret;
 }
 

uspace/lib/usbdev/src/pipesio.c

@@ -71 +71 @@
             return ENOTSUP;
 
-        int ret = pipe_add_ref(pipe, false);
-        if (ret != EOK) {
-                return ret;
-        }
-
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
-        if (!exch) {
-                pipe_end_transaction(pipe);
-                pipe_drop_ref(pipe);
-                return ENOMEM;
-        }
-
-        ret = usbhc_read(exch, pipe->wire->address, pipe->endpoint_no,
-            setup, buffer, size, size_transfered);
-        async_exchange_end(exch);
-        pipe_end_transaction(pipe);
-        pipe_drop_ref(pipe);
-        return ret;
+        return usb_hc_control_read(pipe->wire->hc_connection,
+            pipe->wire->address, pipe->endpoint_no, setup, buffer, size,
+            size_transfered);
 }
 
@@ -109 +92 @@
             return ENOTSUP;
 
-        int ret = pipe_add_ref(pipe, false);
-        if (ret != EOK) {
-                return ret;
-        }
-
-        /* Ensure serialization over the phone. */
-        pipe_start_transaction(pipe);
-        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
-        if (!exch) {
-                pipe_end_transaction(pipe);
-                pipe_drop_ref(pipe);
-                return ENOMEM;
-        }
-        ret = usbhc_write(exch, pipe->wire->address, pipe->endpoint_no,
-            setup, buffer, size);
-        async_exchange_end(exch);
-        pipe_end_transaction(pipe);
-        pipe_drop_ref(pipe);
-        return ret;
+        return usb_hc_control_write(pipe->wire->hc_connection,
+            pipe->wire->address, pipe->endpoint_no, setup, buffer, size);
 }