Changes in / [deb4ba7:92b41f33] in mainline

Location:

uspace/lib

Files:

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

uspace/lib/drv/generic/remote_usbhc.c

@@ -55 +55 @@
 static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 //static void remote_usbhc(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
@@ -73 +75 @@
 
         remote_usbhc_control_write,
-        remote_usbhc_control_read
+        remote_usbhc_control_read,
+
+        remote_usbhc_register_endpoint,
+        remote_usbhc_unregister_endpoint
 };
 
@@ -522 +527 @@
 
 
+void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->register_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+#define INIT_FROM_HIGH_DATA(type, var, arg_no) \
+        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / 256
+#define INIT_FROM_LOW_DATA(type, var, arg_no) \
+        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % 256
+
+        INIT_FROM_HIGH_DATA(usb_address_t, address, 1);
+        INIT_FROM_LOW_DATA(usb_endpoint_t, endpoint, 1);
+        INIT_FROM_HIGH_DATA(usb_transfer_type_t, transfer_type, 2);
+        INIT_FROM_LOW_DATA(usb_direction_t, direction, 2);
+
+#undef INIT_FROM_HIGH_DATA
+#undef INIT_FROM_LOW_DATA
+
+        size_t max_packet_size = (size_t) DEV_IPC_GET_ARG3(*call);
+        unsigned int interval  = (unsigned int) DEV_IPC_GET_ARG4(*call);
+
+        int rc = usb_iface->register_endpoint(fun, address, endpoint,
+            transfer_type, direction, max_packet_size, interval);
+
+        async_answer_0(callid, rc);
+}
+
+
+void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->unregister_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
+        usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG2(*call);
+        usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG3(*call);
+
+        int rc = usb_iface->unregister_endpoint(fun,
+            address, endpoint, direction);
+
+        async_answer_0(callid, rc);
+}
+
 
 /**

uspace/lib/drv/include/usbhc_iface.h

@@ -167 +167 @@
         IPC_M_USBHC_CONTROL_READ,
 
-        /* IPC_M_USB_ */
+        /** Register endpoint attributes at host controller.
+         * This is used to reserve portion of USB bandwidth.
+         * Parameters:
+         * - USB address + endpoint number (ADDR * 256 + EP)
+         * - transfer type + direction (TYPE * 256 + DIR)
+         * - maximum packet size
+         * - interval (in milliseconds)
+         * Answer:
+         * - EOK - reservation successful
+         * - ELIMIT - not enough bandwidth to satisfy the request
+         */
+        IPC_M_USBHC_REGISTER_ENDPOINT,
+
+        /** Revert endpoint registration.
+         * Parameters:
+         * - USB address
+         * - endpoint number
+         * - data direction
+         * Answer:
+         * - EOK - endpoint unregistered
+         * - ENOENT - unknown endpoint
+         */
+        IPC_M_USBHC_UNREGISTER_ENDPOINT
 } usbhc_iface_funcs_t;
 
@@ -200 +222 @@
         int (*release_address)(ddf_fun_t *, usb_address_t);
 
+        int (*register_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
+            usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
+        int (*unregister_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
+            usb_direction_t);
+
         usbhc_iface_transfer_out_t interrupt_out;
         usbhc_iface_transfer_in_t interrupt_in;

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

@@ -131 +131 @@
 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, uint8_t *, size_t, usb_device_connection_t *);
-
+int usb_endpoint_pipe_register(usb_endpoint_pipe_t *, unsigned int,
+    usb_hc_connection_t *);
+int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *, usb_hc_connection_t *);
 
 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *);

uspace/lib/usb/src/devdrv.c

@@ -155 +155 @@
         }
 
+        /* Register the endpoints. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
+        if (rc != EOK) {
+                usb_log_error(
+                    "Failed initializing connection to host controller: %s.\n",
+                    str_error(rc));
+                goto rollback;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                usb_log_error("Failed to connect to host controller: %s.\n",
+                    str_error(rc));
+                goto rollback;
+        }
+        for (i = 0; i < pipe_count; i++) {
+                if (dev->pipes[i].present) {
+                        rc = usb_endpoint_pipe_register(dev->pipes[i].pipe,
+                            dev->pipes[i].descriptor->poll_interval,
+                            &hc_conn);
+                        /* Ignore error when operation not supported by HC. */
+                        if ((rc != EOK) && (rc != ENOTSUP)) {
+                                /* FIXME: what shall we do? */
+                                dev->pipes[i].present = false;
+                                free(dev->pipes[i].pipe);
+                                dev->pipes[i].pipe = NULL;
+                        }
+                }
+        }
+        /* Ignoring errors here. */
+        usb_hc_connection_close(&hc_conn);
+
         return EOK;
 

uspace/lib/usb/src/pipesinit.c

@@ -38 +38 @@
 #include <usb/dp.h>
 #include <usb/request.h>
+#include <usbhc_iface.h>
 #include <errno.h>
 #include <assert.h>
@@ -393 +394 @@
 }
 
+/** Register endpoint with the host controller.
+ *
+ * @param pipe Pipe to be registered.
+ * @param interval Polling interval.
+ * @param hc_connection Connection to the host controller (must be opened).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_register(usb_endpoint_pipe_t *pipe,
+    unsigned int interval,
+    usb_hc_connection_t *hc_connection)
+{
+        assert(pipe);
+        assert(hc_connection);
+
+        if (!usb_hc_connection_is_opened(hc_connection)) {
+                return EBADF;
+        }
+
+#define _PACK(high, low) ((high) * 256 + (low))
+
+        return async_req_5_0(hc_connection->hc_phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT,
+            _PACK(pipe->wire->address, pipe->endpoint_no),
+            _PACK(pipe->transfer_type, pipe->direction),
+            pipe->max_packet_size, interval);
+
+#undef _PACK
+}
+
+/** Revert endpoint registration with the host controller.
+ *
+ * @param pipe Pipe to be unregistered.
+ * @param hc_connection Connection to the host controller (must be opened).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *pipe,
+    usb_hc_connection_t *hc_connection)
+{
+        assert(pipe);
+        assert(hc_connection);
+
+        if (!usb_hc_connection_is_opened(hc_connection)) {
+                return EBADF;
+        }
+
+        return async_req_4_0(hc_connection->hc_phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_UNREGISTER_ENDPOINT,
+            pipe->wire->address, pipe->endpoint_no, pipe->direction);
+}
+
 /**
  * @}