Changes in / [54b141a:e28d228] in mainline

Location:

uspace

Files:

• drv/usbhub/utils.c (modified) (1 diff)
• drv/vhc/addrmgm.c (modified) (4 diffs)
• drv/vhc/conn.h (modified) (1 diff)
• drv/vhc/connhost.c (modified) (2 diffs)
• lib/drv/generic/remote_usbhc.c (modified) (3 diffs)
• lib/drv/include/usbhc_iface.h (modified) (2 diffs)
• lib/usb/include/usb/usbdrv.h (modified) (1 diff)
• lib/usb/src/usbdrv.c (modified) (1 diff)

uspace/drv/usbhub/utils.c

@@ -186 +186 @@
                  */
 
+                /*
+                 * WARNING: sample code, will not work out of the box.
+                 * And does not contain code for checking for errors.
+                 */
+#if 0
+                /*
+                 * Before opening the port, we must acquire the default
+                 * address.
+                 */
+                usb_drv_reserve_default_address(hc);
+
+                usb_address_t new_device_address = usb_drv_request_address(hc);
+
+                // TODO: open the port
+
+                // TODO: send request for setting address to new_device_address
+
+                /*
+                 * Once new address is set, we can release the default
+                 * address.
+                 */
+                usb_drv_release_default_address(hc);
+
+                /*
+                 * Obtain descriptors and create match ids for devman.
+                 */
+
+                // TODO: get device descriptors
+
+                // TODO: create match ids
+
+                // TODO: add child device
+
+                // child_device_register sets the device handle
+                // TODO: store it here
+                devman_handle_t new_device_handle = 0;
+
+                /*
+                 * Inform the HC that the new device has devman handle
+                 * assigned.
+                 */
+                usb_drv_bind_address(hc, new_device_address, new_device_handle);
+
+                /*
+                 * That's all.
+                 */
+#endif
+
 
                 /*

uspace/drv/vhc/addrmgm.c

@@ -49 +49 @@
 typedef struct {
         usb_address_t address;
+        devman_handle_t devman_handle;
         bool available;
 } address_info_t;
@@ -69 +70 @@
                 dev_address[i].address = i + 1;
                 dev_address[i].available = true;
+                dev_address[i].devman_handle = 0;
         }
 
@@ -120 +122 @@
 }
 
+int bind_address(device_t *dev, usb_address_t address, devman_handle_t handle)
+{
+        if (address == DEFAULT_ADDRESS) {
+                return EPERM;
+        }
+
+        int rc = EPERM;
+
+        fibril_mutex_lock(&address_guard);
+        usb_address_t i;
+        for (i = 0; i < ADDRESS_COUNT; i++) {
+                if (dev_address[i].address == address) {
+                        if (dev_address[i].available) {
+                                rc = ENOENT;
+                                break;
+                        }
+
+                        dev_address[i].devman_handle = handle;
+                        rc = EOK;
+                        break;
+                }
+        }
+        fibril_mutex_unlock(&address_guard);
+
+        return rc;
+}
+
+int tell_address(device_t *dev, devman_handle_t handle, usb_address_t *address)
+{
+        int rc = ENOENT;
+
+        fibril_mutex_lock(&address_guard);
+        usb_address_t i;
+        for (i = 0; i < ADDRESS_COUNT; i++) {
+                if (dev_address[i].devman_handle == handle) {
+                        *address = dev_address[i].address;
+                        rc = EOK;
+                        break;
+                }
+        }
+        fibril_mutex_unlock(&address_guard);
+
+        return rc;
+}
+
 int release_address(device_t *dev, usb_address_t address)
 {
@@ -138 +185 @@
 
                         dev_address[i].available = true;
+                        dev_address[i].devman_handle = 0;
                         rc = EOK;
                         break;

uspace/drv/vhc/conn.h

@@ -52 +52 @@
 int request_address(device_t *, usb_address_t *);
 int release_address(device_t *, usb_address_t);
+int bind_address(device_t *, usb_address_t, devman_handle_t);
 
+int tell_address(device_t *, devman_handle_t, usb_address_t *);
 
 void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);

uspace/drv/vhc/connhost.c

@@ -148 +148 @@
 
 
-static int get_address(device_t *dev, devman_handle_t handle,
-    usb_address_t *address)
-{
-        return ENOTSUP;
-}
-
 static int interrupt_out(device_t *dev, usb_target_t target,
     void *data, size_t size,
@@ -226 +220 @@
 
 usbhc_iface_t vhc_iface = {
-        .tell_address = get_address,
+        .tell_address = tell_address,
 
         .reserve_default_address = reserve_default_address,
         .release_default_address = release_default_address,
         .request_address = request_address,
+        .bind_address = bind_address,
         .release_address = release_address,
 

uspace/lib/drv/generic/remote_usbhc.c

@@ -55 +55 @@
 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_bind_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 //static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -68 +69 @@
 
         remote_usbhc_request_address,
+        remote_usbhc_bind_address,
         remote_usbhc_release_address,
 
@@ -197 +199 @@
                 ipc_answer_1(callid, EOK, (ipcarg_t) address);
         }
+}
+
+void remote_usbhc_bind_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->bind_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
+        devman_handle_t handle = (devman_handle_t) IPC_GET_ARG2(*call);
+
+        int rc = usb_iface->bind_address(device, address, handle);
+
+        ipc_answer_0(callid, rc);
 }
 

uspace/lib/drv/include/usbhc_iface.h

@@ -137 +137 @@
         IPC_M_USBHC_REQUEST_ADDRESS,
 
+        /** Bind USB address with devman handle.
+         * Parameters:
+         * - USB address
+         * - devman handle
+         * Answer:
+         * - EOK - address binded
+         * - ENOENT - address is not in use
+         */
+        IPC_M_USBHC_BIND_ADDRESS,
+
         /** Release address in use.
          * Arguments:
@@ -223 +233 @@
         int (*release_default_address)(device_t *);
         int (*request_address)(device_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/usbdrv.h

@@ -44 +44 @@
 int usb_drv_release_default_address(int);
 usb_address_t usb_drv_request_address(int);
+int usb_drv_bind_address(int, usb_address_t, devman_handle_t);
 int usb_drv_release_address(int, usb_address_t);
 

uspace/lib/usb/src/usbdrv.c

@@ -136 +136 @@
 }
 
+/** Inform HC about binding address with devman handle.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be binded.
+ * @param handle Devman handle of the device.
+ * @return Error code.
+ */
+int usb_drv_bind_address(int phone, usb_address_t address,
+    devman_handle_t handle)
+{
+        int rc = async_req_2_0(phone, IPC_M_USBHC_BIND_ADDRESS,
+            address, handle);
+
+        return rc;
+}
+
 /** Inform HC about address release.
  *