Changeset 9efad54 in mainline for uspace/lib/drv/generic/remote_usbhc.c

Timestamp:

2018-01-06T21:15:48Z (6 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

56257ba

Parents:

c901632

Message:

usb: move endpoint descriptor parsing to HC

This better separates responsibilities. Now the device driver does not
care about the contents of an endpoint descriptor, and HC can parse the
values according to device's actual speed.

Currently, it is device driver's responsibility to fetch endpoint
descriptors, map them and register pipes - sending the endpoint
descriptor back to HC. HC then parses it, and fills the pipe
description, which then sends back to device driver. We shall probably
fetch the endpoint descriptor from inside the HC (also fixing the USB
spec violation of communication with EP0).

File:

• uspace/lib/drv/generic/remote_usbhc.c (modified) (6 diffs)

uspace/lib/drv/generic/remote_usbhc.c

@@ -116 +116 @@
 }
 
-int static_assert[sizeof(sysarg_t) >= 4 ? 1 : -1];
-typedef union {
-        uint8_t arr[sizeof(sysarg_t)];
-        sysarg_t arg;
-} pack8_t;
-
-int usbhc_register_endpoint(async_exch_t *exch,
-        usb_endpoint_desc_t *endpoint_desc)
-{
-        if (!exch)
-                return EBADMEM;
+int usbhc_register_endpoint(async_exch_t *exch, usb_pipe_desc_t *pipe_desc,
+    const usb_endpoint_descriptors_t *desc)
+{
+        if (!exch)
+                return EBADMEM;
+
+        if (!desc)
+                return EINVAL;
 
         aid_t opening_request = async_send_1(exch,
@@ -135 +132 @@
         }
 
-        const int ret = async_data_write_start(exch, (void *) endpoint_desc,
-                sizeof(usb_endpoint_desc_t));
-
+        int ret = async_data_write_start(exch, desc, sizeof(*desc));
         if (ret != EOK) {
                 async_forget(opening_request);
@@ -147 +142 @@
         async_wait_for(opening_request, &opening_request_rc);
 
-        return (int) opening_request_rc;
-}
-
-int usbhc_unregister_endpoint(async_exch_t *exch,
-        usb_endpoint_desc_t *endpoint_desc)
+        if (opening_request_rc)
+                return (int) opening_request_rc;
+
+        usb_pipe_desc_t dest;
+        ret = async_data_read_start(exch, &dest, sizeof(dest));
+        if (ret != EOK) {
+                return ret;
+        }
+
+        if (pipe_desc)
+                *pipe_desc = dest;
+
+        return EOK;
+}
+
+int usbhc_unregister_endpoint(async_exch_t *exch, const usb_pipe_desc_t *pipe_desc)
 {
         if (!exch)
@@ -163 +169 @@
         }
 
-        const int ret = async_data_write_start(exch, endpoint_desc,
-                sizeof(usb_endpoint_desc_t));
+        const int ret = async_data_write_start(exch, pipe_desc, sizeof(*pipe_desc));
         if (ret != EOK) {
                 async_forget(opening_request);
@@ -368 +373 @@
         }
 
-        void *buffer = NULL;
-        size_t size = 0;
-        int rc = async_data_write_accept(&buffer, false,
-                sizeof(usb_endpoint_desc_t), sizeof(usb_endpoint_desc_t), 0, &size);
-
-        if (rc != EOK) {
-                free(buffer);
-                async_answer_0(callid, rc);
-                return;
-        }
-
-        usb_endpoint_desc_t *endpoint_desc = (usb_endpoint_desc_t *) buffer;
-        rc = usbhc_iface->register_endpoint(fun, endpoint_desc);
-
-        free(buffer);
+        usb_endpoint_descriptors_t ep_desc;
+        ipc_callid_t data_callid;
+        size_t len;
+
+        if (!async_data_write_receive(&data_callid, &len)
+            || len != sizeof(ep_desc)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        async_data_write_finalize(data_callid, &ep_desc, sizeof(ep_desc));
+
+        usb_pipe_desc_t pipe_desc;
+
+        const int rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
         async_answer_0(callid, rc);
+
+        if (!async_data_read_receive(&data_callid, &len)
+            || len != sizeof(pipe_desc)) {
+                return;
+        }
+        async_data_read_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
 }
 
@@ -400 +410 @@
         }
 
-        void *buffer = NULL;
-        size_t size = 0;
-        int rc = async_data_write_accept(&buffer, false,
-                sizeof(usb_endpoint_desc_t), sizeof(usb_endpoint_desc_t), 0, &size);
-
-        if (rc != EOK) {
-                free(buffer);
-                async_answer_0(callid, rc);
-                return;
-        }
-
-        usb_endpoint_desc_t *endpoint_desc = (usb_endpoint_desc_t *) buffer;
-        usbhc_iface->unregister_endpoint(fun, endpoint_desc);
-
-        free(buffer);
+        usb_pipe_desc_t pipe_desc;
+        ipc_callid_t data_callid;
+        size_t len;
+
+        if (!async_data_write_receive(&data_callid, &len)
+            || len != sizeof(pipe_desc)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        async_data_write_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+
+        const int rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
         async_answer_0(callid, rc);
 }