Changeset b6c7da6 in mainline

Timestamp:

2011-02-18T19:49:57Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

374552ef, 867e6735

Parents:

0c00dac (diff), 026d6e2 (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 speed sending during new device discovery

Location:

uspace

Files:

• drv/uhci-hcd/iface.c (modified) (2 diffs)
• drv/uhci-rhd/port.c (modified) (2 diffs)
• drv/vhc/connhost.c (modified) (2 diffs)
• lib/c/generic/str_error.c (modified) (1 diff)
• lib/c/include/errno.h (modified) (1 diff)
• lib/drv/generic/remote_usbhc.c (modified) (2 diffs)
• lib/drv/include/usbhc_iface.h (modified) (1 diff)
• lib/usb/include/usb/hub.h (modified) (2 diffs)
• lib/usb/include/usb/usb.h (modified) (1 diff)
• lib/usb/src/hub.c (modified) (6 diffs)

uspace/drv/uhci-hcd/iface.c

@@ -54 +54 @@
 }
 /*----------------------------------------------------------------------------*/
-static int reserve_default_address(device_t *dev, bool full_speed)
+static int reserve_default_address(device_t *dev, usb_speed_t speed)
 {
         assert(dev);
@@ -72 +72 @@
 }
 /*----------------------------------------------------------------------------*/
-static int request_address(device_t *dev, bool full_speed,
+static int request_address(device_t *dev, usb_speed_t speed,
     usb_address_t *address)
 {

uspace/drv/uhci-rhd/port.c

@@ -131 +131 @@
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
-static int uhci_port_new_device(uhci_port_t *port)
-{
-        assert(port);
-        assert(usb_hc_connection_is_opened(&port->hc_connection));
-
-        usb_log_info("Adding new device on port %d.\n", port->number);
-
-        /* get address of the future device */
-        const usb_address_t usb_address = usb_hc_request_address(
-            &port->hc_connection, true);
-
-        if (usb_address <= 0) {
-                usb_log_error("Recieved invalid address(%d).\n", usb_address);
-                return usb_address;
-        }
-        usb_log_debug("Sucessfully obtained address %d for port %d.\n",
-            usb_address, port->number);
-
-        /* get default address */
-        int ret = usb_hc_reserve_default_address(&port->hc_connection, true);
-        if (ret != EOK) {
-                usb_log_error("Failed to reserve default address on port %d.\n",
-                    port->number);
-                int ret2 = usb_hc_unregister_device(&port->hc_connection,
-                    usb_address);
-                if (ret2 != EOK) {
-                        usb_log_fatal("Failed to return requested address on port %d.\n",
-                           port->number);
-                        return ret2;
-                }
-                usb_log_debug("Successfully returned reserved address on port %d.\n",
-                        port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully obtained default address for port %d.\n",
-            port->number);
+
+/** Callback for enabling port during adding a new device.
+ *
+ * @param portno Port number (unused).
+ * @param arg Pointer to uhci_port_t of port with the new device.
+ * @return Error code.
+ */
+static int new_device_enable_port(int portno, void *arg)
+{
+        uhci_port_t *port = (uhci_port_t *) arg;
+
+        usb_log_debug("new_device_enable_port(%d)\n", port->number);
 
         /*
-         * the host then waits for at least 100 ms to allow completion of
+         * The host then waits for at least 100 ms to allow completion of
          * an insertion process and for power at the device to become stable.
          */
         async_usleep(100000);
 
-        /* enable port */
+        /* Enable the port. */
         uhci_port_set_enabled(port, true);
 
@@ -197 +172 @@
         }
 
-        /*
-         * Initialize connection to the device.
-         */
-        /* FIXME: check for errors. */
-        usb_device_connection_t new_dev_connection;
-        usb_endpoint_pipe_t new_dev_ctrl_pipe;
-        usb_device_connection_initialize_on_default_address(
-            &new_dev_connection, &port->hc_connection);
-        usb_endpoint_pipe_initialize_default_control(&new_dev_ctrl_pipe,
-            &new_dev_connection);
-
-        /*
-         * Assign new address to the device. This function updates
-         * the backing connection to still point to the same device.
-         */
-        /* FIXME: check for errors. */
-        usb_endpoint_pipe_start_session(&new_dev_ctrl_pipe);
-        ret = usb_request_set_address(&new_dev_ctrl_pipe, usb_address);
-        usb_endpoint_pipe_end_session(&new_dev_ctrl_pipe);
-
-        if (ret != EOK) { /* address assigning went wrong */
-                usb_log_error("Failed(%d) to assign address to the device.\n", ret);
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+static int uhci_port_new_device(uhci_port_t *port)
+{
+        assert(port);
+        assert(usb_hc_connection_is_opened(&port->hc_connection));
+
+        usb_log_info("Detected new device on port %u.\n", port->number);
+
+        usb_address_t dev_addr;
+        int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
+            USB_SPEED_FULL,
+            new_device_enable_port, port->number, port,
+            &dev_addr, &port->attached_device);
+        if (rc != EOK) {
+                usb_log_error("Failed adding new device on port %u: %s.\n",
+                    port->number, str_error(rc));
                 uhci_port_set_enabled(port, false);
-                int release = usb_hc_release_default_address(&port->hc_connection);
-                if (release != EOK) {
-                        usb_log_error("Failed to release default address on port %d.\n",
-                            port->number);
-                        return release;
-                }
-                usb_log_debug("Sucessfully released default address on port %d.\n",
-                    port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully assigned address %d for port %d.\n",
-            usb_address, port->number);
-
-        /* release default address */
-        ret = usb_hc_release_default_address(&port->hc_connection);
-        if (ret != EOK) {
-                usb_log_error("Failed to release default address on port %d.\n",
-                    port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully released default address on port %d.\n",
-            port->number);
-
-        /* communicate and possibly report to devman */
-        assert(port->attached_device == 0);
-
-        ret = usb_device_register_child_in_devman(new_dev_connection.address,
-            new_dev_connection.hc_handle, port->rh, &port->attached_device);
-
-        if (ret != EOK) { /* something went wrong */
-                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
-                uhci_port_set_enabled(port, false);
-                return ENOMEM;
-        }
-        usb_log_info("Sucessfully added device on port(%d) address(%d) handle %d.\n",
-                port->number, usb_address, port->attached_device);
-
-        /*
-         * Register the device in the host controller.
-         */
-        usb_hc_attached_device_t new_device = {
-                .address = new_dev_connection.address,
-                .handle = port->attached_device
-        };
-
-        ret = usb_hc_register_device(&port->hc_connection, &new_device);
-        // TODO: proper error check here
-        assert(ret == EOK);
-
-        return EOK;
-}
+                return rc;
+        }
+
+        usb_log_info("New device on port %u has address %d (handle %zu).\n",
+            port->number, dev_addr, port->attached_device);
+
+        return EOK;
+}
+
 /*----------------------------------------------------------------------------*/
 static int uhci_port_remove_device(uhci_port_t *port)

uspace/drv/vhc/connhost.c

@@ -390 +390 @@
 
 
-static int reserve_default_address(device_t *dev, bool ignored)
+static int reserve_default_address(device_t *dev, usb_speed_t ignored)
 {
         usb_address_keeping_reserve_default(&addresses);
@@ -402 +402 @@
 }
 
-static int request_address(device_t *dev, bool ignored, usb_address_t *address)
+static int request_address(device_t *dev, usb_speed_t ignored,
+    usb_address_t *address)
 {
         usb_address_t addr = usb_address_keeping_request(&addresses);

uspace/lib/c/generic/str_error.c

@@ -73 +73 @@
                 case EBADCHECKSUM:
                         return "Bad checksum";
+                case ESTALL:
+                        return "Operation stalled";
                 case EAGAIN:
                         return "Resource temporarily unavailable";

uspace/lib/c/include/errno.h

@@ -59 +59 @@
 #define EBADCHECKSUM  (-300)
 
+/** USB: stalled operation. */
+#define ESTALL (-301)
+
 /** An API function is called while another blocking function is in progress. */
 #define EINPROGRESS  (-10036)

uspace/lib/drv/generic/remote_usbhc.c

@@ -166 +166 @@
         }
         
-        bool full_speed = DEV_IPC_GET_ARG1(*call);
+        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
         
-        int rc = usb_iface->reserve_default_address(device, full_speed);
+        int rc = usb_iface->reserve_default_address(device, speed);
 
         async_answer_0(callid, rc);
@@ -198 +198 @@
         }
         
-        bool full_speed = DEV_IPC_GET_ARG1(*call);
+        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
 
         usb_address_t address;
-        int rc = usb_iface->request_address(device, full_speed, &address);
+        int rc = usb_iface->request_address(device, speed, &address);
         if (rc != EOK) {
                 async_answer_0(callid, rc);

uspace/lib/drv/include/usbhc_iface.h

@@ -232 +232 @@
         int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
 
-        int (*reserve_default_address)(device_t *, bool);
+        int (*reserve_default_address)(device_t *, usb_speed_t);
         int (*release_default_address)(device_t *);
-        int (*request_address)(device_t *, bool, usb_address_t *);
+        int (*request_address)(device_t *, usb_speed_t, usb_address_t *);
         int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
         int (*release_address)(device_t *, usb_address_t);

uspace/lib/usb/include/usb/hub.h

@@ -39 +39 @@
 #include <usb/usbdevice.h>
 
+int usb_hc_new_device_wrapper(device_t *, usb_hc_connection_t *, usb_speed_t,
+    int (*)(int, void *), int, void *, usb_address_t *, devman_handle_t *);
+
 /** Info about device attached to host controller.
  *
@@ -52 +55 @@
 } usb_hc_attached_device_t;
 
-int usb_hc_reserve_default_address(usb_hc_connection_t *, bool);
+int usb_hc_reserve_default_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_release_default_address(usb_hc_connection_t *);
 
-usb_address_t usb_hc_request_address(usb_hc_connection_t *, bool);
+usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_register_device(usb_hc_connection_t *,
     const usb_hc_attached_device_t *);

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

@@ -68 +68 @@
         USB_DIRECTION_BOTH
 } usb_direction_t;
+
+/** USB speeds. */
+typedef enum {
+        /** USB 1.1 low speed (1.5Mbits/s). */
+        USB_SPEED_LOW,
+        /** USB 1.1 full speed (12Mbits/s). */
+        USB_SPEED_FULL,
+        /** USB 2.0 high speed (480Mbits/s). */
+        USB_SPEED_HIGH
+} usb_speed_t;
 
 /** USB request type target. */

uspace/lib/usb/src/hub.c

@@ -34 +34 @@
  */
 #include <usb/hub.h>
+#include <usb/pipes.h>
+#include <usb/request.h>
+#include <usb/recognise.h>
 #include <usbhc_iface.h>
 #include <errno.h>
@@ -56 +59 @@
  */
 int usb_hc_reserve_default_address(usb_hc_connection_t *connection,
-    bool full_speed)
+    usb_speed_t speed)
 {
         CHECK_CONNECTION(connection);
@@ -62 +65 @@
         return async_req_2_0(connection->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, full_speed);
+            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, speed);
 }
 
@@ -85 +88 @@
  */
 usb_address_t usb_hc_request_address(usb_hc_connection_t *connection,
-    bool full_speed)
+    usb_speed_t speed)
 {
         CHECK_CONNECTION(connection);
@@ -92 +95 @@
         int rc = async_req_2_1(connection->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_REQUEST_ADDRESS, full_speed,
+            IPC_M_USBHC_REQUEST_ADDRESS, speed,
             &address);
         if (rc != EOK) {
@@ -138 +141 @@
 
 
+/** Wrapper for registering attached device to the hub.
+ *
+ * The @p enable_port function is expected to enable singalling on given
+ * port.
+ * The two arguments to it can have arbitrary meaning
+ * (the @p port_no is only a suggestion)
+ * and are not touched at all by this function
+ * (they are passed as is to the @p enable_port function).
+ *
+ * If the @p enable_port fails (i.e. does not return EOK), the device
+ * addition is cancelled.
+ * The return value is then returned (it is good idea to use different
+ * error codes than those listed as return codes by this function itself).
+ *
+ * @param parent Parent device (i.e. the hub device).
+ * @param connection Opened connection to host controller.
+ * @param dev_speed New device speed.
+ * @param enable_port Function for enabling signalling through the port the
+ *      device is attached to.
+ * @param port_no Port number (passed through to @p enable_port).
+ * @param arg Any data argument to @p enable_port.
+ * @param[out] assigned_address USB address of the device.
+ * @param[out] assigned_handle Devman handle of the new device.
+ * @return Error code.
+ * @retval ENOENT Connection to HC not opened.
+ * @retval EADDRNOTAVAIL Failed retrieving free address from host controller.
+ * @retval EBUSY Failed reserving default USB address.
+ * @retval ENOTCONN Problem connecting to the host controller via USB pipe.
+ * @retval ESTALL Problem communication with device (either SET_ADDRESS
+ *      request or requests for descriptors when creating match ids).
+ */
+int usb_hc_new_device_wrapper(device_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)
+{
+        CHECK_CONNECTION(connection);
+
+        /*
+         * Request new address.
+         */
+        usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed);
+        if (dev_addr < 0) {
+                return EADDRNOTAVAIL;
+        }
+
+        int rc;
+
+        /*
+         * Reserve the default address.
+         */
+        rc = usb_hc_reserve_default_address(connection, dev_speed);
+        if (rc != EOK) {
+                rc = EBUSY;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * Enable the port (i.e. allow signalling through this port).
+         */
+        rc = enable_port(port_no, arg);
+        if (rc != EOK) {
+                goto leave_release_default_address;
+        }
+
+        /*
+         * Change the address from default to the free one.
+         * We need to create a new control pipe for that.
+         */
+        usb_device_connection_t dev_conn;
+        rc = usb_device_connection_initialize_on_default_address(&dev_conn,
+            connection);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        usb_endpoint_pipe_t ctrl_pipe;
+        rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
+            &dev_conn);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
+        if (rc != EOK) {
+                rc = ESTALL;
+                goto leave_stop_session;
+        }
+
+        usb_endpoint_pipe_end_session(&ctrl_pipe);
+
+        /*
+         * Once the address is changed, we can return the default address.
+         */
+        usb_hc_release_default_address(connection);
+
+        /*
+         * It is time to register the device with devman.
+         */
+        /* FIXME: create device_register that will get opened ctrl pipe. */
+        devman_handle_t child_handle;
+        rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle,
+            parent, &child_handle);
+        if (rc != EOK) {
+                rc = ESTALL;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * And now inform the host controller about the handle.
+         */
+        usb_hc_attached_device_t new_device = {
+                .address = dev_addr,
+                .handle = child_handle
+        };
+        rc = usb_hc_register_device(connection, &new_device);
+        if (rc != EOK) {
+                rc = EDESTADDRREQ;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * And we are done.
+         */
+        if (assigned_address != NULL) {
+                *assigned_address = dev_addr;
+        }
+        if (assigned_handle != NULL) {
+                *assigned_handle = child_handle;
+        }
+
+        return EOK;
+
+
+
+        /*
+         * Error handling (like nested exceptions) starts here.
+         * Completely ignoring errors here.
+         */
+
+leave_stop_session:
+        usb_endpoint_pipe_end_session(&ctrl_pipe);
+
+leave_release_default_address:
+        usb_hc_release_default_address(connection);
+
+leave_release_free_address:
+        usb_hc_unregister_device(connection, dev_addr);
+
+        return rc;
+}
+
+
 /**
  * @}