Changeset 6f04905 in mainline

Timestamp:

2010-12-04T16:58:31Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

ad104e0

Parents:

36c410e

Message:

Add address reservation to USBHC interface in DDF

Any USB driver that needs to assign new USB address shall ask its HC
for it. When using default USB address (address 0), it must inform
HC about it as HC is the only element able to provide serialization.

Location:

uspace/lib

Files:

• drv/generic/remote_usbhc.c (modified) (3 diffs)
• drv/include/usbhc_iface.h (modified) (2 diffs)
• usb/include/usb/usbdrv.h (modified) (1 diff)
• usb/src/usbdrv.c (modified) (1 diff)

uspace/lib/drv/generic/remote_usbhc.c

@@ -52 +52 @@
 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+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_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 //static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
 
@@ -57 +61 @@
 static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
         remote_usbhc_get_address,
+
         remote_usbhc_get_buffer,
+
+        remote_usbhc_reserve_default_address,
+        remote_usbhc_release_default_address,
+
+        remote_usbhc_request_address,
+        remote_usbhc_release_address,
+
         remote_usbhc_interrupt_out,
         remote_usbhc_interrupt_in,
+
         remote_usbhc_control_write_setup,
         remote_usbhc_control_write_data,
         remote_usbhc_control_write_status,
+
         remote_usbhc_control_read_setup,
         remote_usbhc_control_read_data,
@@ -134 +148 @@
         free(trans->buffer);
         free(trans);
+}
+
+void remote_usbhc_reserve_default_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->reserve_default_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int rc = usb_iface->reserve_default_address(device);
+
+        ipc_answer_0(callid, rc);
+}
+
+void remote_usbhc_release_default_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->release_default_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int rc = usb_iface->release_default_address(device);
+
+        ipc_answer_0(callid, rc);
+}
+
+void remote_usbhc_request_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->request_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address;
+        int rc = usb_iface->request_address(device, &address);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+        } else {
+                ipc_answer_1(callid, EOK, (ipcarg_t) address);
+        }
+}
+
+void remote_usbhc_release_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->release_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
+
+        int rc = usb_iface->release_address(device, address);
+
+        ipc_answer_0(callid, rc);
 }
 

uspace/lib/drv/include/usbhc_iface.h

@@ -111 +111 @@
 
 
+        /** Reserve usage of default address.
+         * This call informs the host controller that the caller will be
+         * using default USB address. It is duty of the HC driver to ensure
+         * that only single entity will have it reserved.
+         * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS.
+         * The caller can start using the address after receiving EOK
+         * answer.
+         */
+        IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS,
+
+        /** Release usage of default address.
+         * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS
+         */
+        IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS,
+
+        /** Asks for address assignment by host controller.
+         * Answer:
+         * - ELIMIT - host controller run out of address
+         * - EOK - address assigned
+         * Answer arguments:
+         * - assigned address
+         *
+         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
+         */
+        IPC_M_USBHC_REQUEST_ADDRESS,
+
+        /** Release address in use.
+         * Arguments:
+         * - address to be released
+         * Answer:
+         * - ENOENT - address not in use
+         * - EPERM - trying to release default USB address
+         */
+        IPC_M_USBHC_RELEASE_ADDRESS,
+
+
         /** Send interrupt data to device.
          * See explanation at usb_iface_funcs_t (OUT transaction).
@@ -183 +219 @@
 typedef struct {
         int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
+
+        int (*reserve_default_address)(device_t *);
+        int (*release_default_address)(device_t *);
+        int (*request_address)(device_t *, usb_address_t *);
+        int (*release_address)(device_t *, usb_address_t);
 
         usbhc_iface_transfer_out_t interrupt_out;

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

@@ -41 +41 @@
 int usb_drv_hc_connect(device_t *, unsigned int);
 
+int usb_drv_reserve_default_address(int);
+int usb_drv_release_default_address(int);
+usb_address_t usb_drv_request_address(int);
+int usb_drv_release_address(int, usb_address_t);
+
 usb_address_t usb_drv_get_my_address(int, device_t *);
 

uspace/lib/usb/src/usbdrv.c

@@ -100 +100 @@
 }
 
+/** Tell HC to reserve default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_reserve_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
+}
+
+/** Tell HC to release default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_release_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
+}
+
+/** Ask HC for free address assignment.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Assigned USB address or negative error code.
+ */
+usb_address_t usb_drv_request_address(int phone)
+{
+        ipcarg_t address;
+        int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address);
+        if (rc != EOK) {
+                return rc;
+        } else {
+                return (usb_address_t) address;
+        }
+}
+
+/** Inform HC about address release.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be released.
+ * @return Error code.
+ */
+int usb_drv_release_address(int phone, usb_address_t address)
+{
+        return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address);
+}
+
 /** Send data to HCD.
  *