Changes in uspace/lib/usb/src/pipes.c [d714945:25971d2] in mainline

File:

• uspace/lib/usb/src/pipes.c (modified) (4 diffs)

uspace/lib/usb/src/pipes.c

@@ -31 +31 @@
  */
 /** @file
- * USB endpoint pipes miscellaneous functions.
+ * Communication between device drivers and host controller driver.
+ *
+ * Note on synchronousness of the operations: there is ABSOLUTELY NO
+ * guarantee that a call to particular function will not trigger a fibril
+ * switch.
+ * The initialization functions may actually involve contacting some other
+ * task, starting/ending a session might involve asynchronous IPC and since
+ * the transfer functions uses IPC, asynchronous nature of them is obvious.
+ * The pseudo synchronous versions for the transfers internally call the
+ * asynchronous ones and so fibril switch is possible in them as well.
  */
 #include <usb/usb.h>
@@ -39 +48 @@
 #include <usb/usbdrv.h>
 
+#define _PREPARE_TARGET(varname, pipe) \
+        usb_target_t varname = { \
+                .address = (pipe)->wire->address, \
+                .endpoint = (pipe)->endpoint_no \
+        }
+
 /** Initialize connection to USB device.
  *
@@ -102 +117 @@
 }
 
-/** Initialize connection to USB device on default address.
- *
- * @param dev_connection Device connection structure to be initialized.
- * @param hc_connection Initialized connection to host controller.
- * @return Error code.
- */
-int usb_device_connection_initialize_on_default_address(
-    usb_device_connection_t *dev_connection,
-    usb_hc_connection_t *hc_connection)
-{
-        assert(dev_connection);
-
-        if (hc_connection == NULL) {
-                return EBADMEM;
-        }
-
-        return usb_device_connection_initialize(dev_connection,
-            hc_connection->hc_handle, (usb_address_t) 0);
+/** Initialize USB endpoint pipe.
+ *
+ * @param pipe Endpoint pipe to be initialized.
+ * @param connection Connection to the USB device backing this pipe (the wire).
+ * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
+ * @param transfer_type Transfer type (e.g. interrupt or bulk).
+ * @param max_packet_size Maximum packet size in bytes.
+ * @param direction Endpoint direction (in/out).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
+    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
+    usb_transfer_type_t transfer_type, size_t max_packet_size,
+    usb_direction_t direction)
+{
+        assert(pipe);
+        assert(connection);
+
+        pipe->wire = connection;
+        pipe->hc_phone = -1;
+        pipe->endpoint_no = endpoint_no;
+        pipe->transfer_type = transfer_type;
+        pipe->max_packet_size = max_packet_size;
+        pipe->direction = direction;
+
+        return EOK;
+}
+
+
+/** Initialize USB endpoint pipe as the default zero control pipe.
+ *
+ * @param pipe Endpoint pipe to be initialized.
+ * @param connection Connection to the USB device backing this pipe (the wire).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
+    usb_device_connection_t *connection)
+{
+        assert(pipe);
+        assert(connection);
+
+        int rc = usb_endpoint_pipe_initialize(pipe, connection,
+            0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH);
+
+        return rc;
 }
 
@@ -182 +224 @@
 }
 
+
+/** Request a read (in) transfer on an endpoint pipe.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[out] buffer Buffer where to store the data.
+ * @param[in] size Size of the buffer (in bytes).
+ * @param[out] size_transfered Number of bytes that were actually transfered.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,
+    void *buffer, size_t size, size_t *size_transfered)
+{
+        assert(pipe);
+
+        int rc;
+        usb_handle_t handle;
+
+        rc = usb_endpoint_pipe_async_read(pipe, buffer, size, size_transfered,
+            &handle);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        rc = usb_endpoint_pipe_wait_for(pipe, handle);
+        return rc;
+}
+
+/** Request a write (out) transfer on an endpoint pipe.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] buffer Buffer with data to transfer.
+ * @param[in] size Size of the buffer (in bytes).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,
+    void *buffer, size_t size)
+{
+        assert(pipe);
+
+        int rc;
+        usb_handle_t handle;
+
+        rc = usb_endpoint_pipe_async_write(pipe, buffer, size, &handle);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        rc = usb_endpoint_pipe_wait_for(pipe, handle);
+        return rc;
+}
+
+
+/** Request a control read transfer on an endpoint pipe.
+ *
+ * This function encapsulates all three stages of a control transfer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] setup_buffer Buffer with the setup packet.
+ * @param[in] setup_buffer_size Size of the setup packet (in bytes).
+ * @param[out] data_buffer Buffer for incoming data.
+ * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
+ * @param[out] data_transfered_size Number of bytes that were actually
+ *                                  transfered during the DATA stage.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
+{
+        assert(pipe);
+
+        int rc;
+        usb_handle_t handle;
+
+        rc = usb_endpoint_pipe_async_control_read(pipe,
+            setup_buffer, setup_buffer_size,
+            data_buffer, data_buffer_size, data_transfered_size,
+            &handle);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        rc = usb_endpoint_pipe_wait_for(pipe, handle);
+        return rc;
+}
+
+
+/** Request a control write transfer on an endpoint pipe.
+ *
+ * This function encapsulates all three stages of a control transfer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] setup_buffer Buffer with the setup packet.
+ * @param[in] setup_buffer_size Size of the setup packet (in bytes).
+ * @param[in] data_buffer Buffer with data to be sent.
+ * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size)
+{
+        assert(pipe);
+
+        int rc;
+        usb_handle_t handle;
+
+        rc = usb_endpoint_pipe_async_control_write(pipe,
+            setup_buffer, setup_buffer_size,
+            data_buffer, data_buffer_size,
+            &handle);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        rc = usb_endpoint_pipe_wait_for(pipe, handle);
+        return rc;
+}
+
+
+/** Request a read (in) transfer on an endpoint pipe (asynchronous version).
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[out] buffer Buffer where to store the data.
+ * @param[in] size Size of the buffer (in bytes).
+ * @param[out] size_transfered Number of bytes that were actually transfered.
+ * @param[out] handle Handle of the transfer.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *pipe,
+    void *buffer, size_t size, size_t *size_transfered,
+    usb_handle_t *handle)
+{
+        assert(pipe);
+
+        if (pipe->hc_phone < 0) {
+                return EBADF;
+        }
+
+        if (pipe->direction != USB_DIRECTION_IN) {
+                return EBADF;
+        }
+
+        int rc;
+        _PREPARE_TARGET(target, pipe);
+
+        switch (pipe->transfer_type) {
+                case USB_TRANSFER_INTERRUPT:
+                        rc = usb_drv_async_interrupt_in(pipe->hc_phone, target,
+                            buffer, size, size_transfered, handle);
+                        break;
+                case USB_TRANSFER_CONTROL:
+                        rc = EBADF;
+                        break;
+                default:
+                        rc = ENOTSUP;
+                        break;
+        }
+
+        return rc;
+}
+
+
+/** Request a write (out) transfer on an endpoint pipe (asynchronous version).
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] buffer Buffer with data to transfer.
+ * @param[in] size Size of the buffer (in bytes).
+ * @param[out] handle Handle of the transfer.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *pipe,
+    void *buffer, size_t size,
+    usb_handle_t *handle)
+{
+        assert(pipe);
+
+        if (pipe->hc_phone < 0) {
+                return EBADF;
+        }
+
+        if (pipe->direction != USB_DIRECTION_OUT) {
+                return EBADF;
+        }
+
+        int rc;
+        _PREPARE_TARGET(target, pipe);
+
+        switch (pipe->transfer_type) {
+                case USB_TRANSFER_INTERRUPT:
+                        rc = usb_drv_async_interrupt_out(pipe->hc_phone, target,
+                            buffer, size, handle);
+                        break;
+                case USB_TRANSFER_CONTROL:
+                        rc = EBADF;
+                        break;
+                default:
+                        rc = ENOTSUP;
+                        break;
+        }
+
+        return rc;
+}
+
+
+/** Request a control read transfer on an endpoint pipe (asynchronous version).
+ *
+ * This function encapsulates all three stages of a control transfer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] setup_buffer Buffer with the setup packet.
+ * @param[in] setup_buffer_size Size of the setup packet (in bytes).
+ * @param[out] data_buffer Buffer for incoming data.
+ * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
+ * @param[out] data_transfered_size Number of bytes that were actually
+ *                                  transfered during the DATA stage.
+ * @param[out] handle Handle of the transfer.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *pipe,
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size,
+    usb_handle_t *handle)
+{
+        assert(pipe);
+
+        if (pipe->hc_phone < 0) {
+                return EBADF;
+        }
+
+        if ((pipe->direction != USB_DIRECTION_BOTH)
+            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
+                return EBADF;
+        }
+
+        int rc;
+        _PREPARE_TARGET(target, pipe);
+
+        rc = usb_drv_async_control_read(pipe->hc_phone, target,
+            setup_buffer, setup_buffer_size,
+            data_buffer, data_buffer_size, data_transfered_size,
+            handle);
+
+        return rc;
+}
+
+
+/** Request a control write transfer on an endpoint pipe (asynchronous version).
+ *
+ * This function encapsulates all three stages of a control transfer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] setup_buffer Buffer with the setup packet.
+ * @param[in] setup_buffer_size Size of the setup packet (in bytes).
+ * @param[in] data_buffer Buffer with data to be sent.
+ * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
+ * @param[out] handle Handle of the transfer.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *pipe,
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size,
+    usb_handle_t *handle)
+{
+        assert(pipe);
+
+        if (pipe->hc_phone < 0) {
+                return EBADF;
+        }
+
+        if ((pipe->direction != USB_DIRECTION_BOTH)
+            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
+                return EBADF;
+        }
+
+        int rc;
+        _PREPARE_TARGET(target, pipe);
+
+        rc = usb_drv_async_control_write(pipe->hc_phone, target,
+            setup_buffer, setup_buffer_size,
+            data_buffer, data_buffer_size,
+            handle);
+
+        return rc;
+}
+
+/** Wait for transfer completion.
+ *
+ * The function blocks the caller fibril until the transfer associated
+ * with given @p handle is completed.
+ *
+ * @param[in] pipe Pipe the transfer executed on.
+ * @param[in] handle Transfer handle.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *pipe, usb_handle_t handle)
+{
+        return usb_drv_async_wait_for(handle);
+}
+
+
 /**
  * @}