Changeset 91db50ac in mainline for uspace/lib/usb/usbdrv.c

Timestamp:

2010-11-19T21:50:46Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

7034be15

Parents:

63b4f90

Message:

USB driver to HC communication uses DDF interfaces

Started work on using interfaces on the background of communication
between HC and USB driver. However, for driver developers, this will
be hidden completely.

File:

• uspace/lib/usb/usbdrv.c (modified) (2 diffs)

uspace/lib/usb/usbdrv.c

@@ -34 +34 @@
  */
 #include "usbdrv.h"
+#include <usb_iface.h>
 #include <errno.h>
 
+/** Information about pending transaction on HC. */
+typedef struct {
+        /** Phone to host controller driver. */
+        int phone;
+        /** Data buffer. */
+        void *buffer;
+        /** Buffer size. */
+        size_t size;
+        /** Storage for actual number of bytes transferred. */
+        size_t *size_transferred;
+        /** Initial call replay data. */
+        ipc_call_t reply;
+        /** Initial call identifier. */
+        aid_t request;
+} transfer_info_t;
+
 /** Connect to host controller the device is physically attached to.
- * This function sets the phone_parent property in the device_t struct.
  *
  * @param handle Device handle.
  * @param flags Connection flags (blocking connection).
- * @return Error code.
+ * @return Phone to corresponding HC or error code.
  */
 int usb_drv_hc_connect(device_t *dev, unsigned int flags)
@@ -51 +67 @@
 }
 
+/** Send data to HCD.
+ *
+ * @param phone Phone to HC.
+ * @param method Method used for calling.
+ * @param endpoint Device endpoint.
+ * @param buffer Data buffer (NULL to skip data transfer phase).
+ * @param size Buffer size (must be zero when @p buffer is NULL).
+ * @param handle Storage for transaction handle (cannot be NULL).
+ * @return Error status.
+ * @retval EINVAL Invalid parameter.
+ * @retval ENOMEM Not enough memory to complete the operation.
+ */
+static int async_send_buffer(int phone, int method,
+    usb_endpoint_t endpoint,
+    void *buffer, size_t size,
+    usb_handle_t *handle)
+{
+        if (phone < 0) {
+                return EINVAL;
+        }
+
+        if ((buffer == NULL) && (size > 0)) {
+                return EINVAL;
+        }
+
+        if (handle == NULL) {
+                return EINVAL;
+        }
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->size_transferred = NULL;
+        transfer->buffer = NULL;
+        transfer->size = 0;
+        transfer->phone = phone;
+
+        int rc;
+
+        transfer->request = async_send_3(phone,
+            DEV_IFACE_ID(USB_DEV_IFACE),
+            method,
+            endpoint,
+            size,
+            &transfer->reply);
+
+        if (size > 0) {
+                rc = async_data_write_start(phone, buffer, size);
+                if (rc != EOK) {
+                        async_wait_for(transfer->request, NULL);
+                        return rc;
+                }
+        }
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
+}
+
+/** Prepare data retrieval.
+ *
+ * @param phone Opened phone to HCD.
+ * @param method Method used for calling.
+ * @param endpoint Device endpoint.
+ * @param buffer Buffer where to store retrieved data
+ *      (NULL to skip data transfer phase).
+ * @param size Buffer size (must be zero when @p buffer is NULL).
+ * @param actual_size Storage where actual number of bytes transferred will
+ *      be stored.
+ * @param handle Storage for transaction handle (cannot be NULL).
+ * @return Error status.
+ * @retval EINVAL Invalid parameter.
+ * @retval ENOMEM Not enough memory to complete the operation.
+ */
+static int async_recv_buffer(int phone, int method,
+    usb_endpoint_t endpoint,
+    void *buffer, size_t size, size_t *actual_size,
+    usb_handle_t *handle)
+{
+        if (phone < 0) {
+                return EINVAL;
+        }
+
+        if ((buffer == NULL) && (size > 0)) {
+                return EINVAL;
+        }
+
+        if (handle == NULL) {
+                return EINVAL;
+        }
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->size_transferred = actual_size;
+        transfer->buffer = buffer;
+        transfer->size = size;
+        transfer->phone = phone;
+
+        transfer->request = async_send_3(phone,
+            DEV_IFACE_ID(USB_DEV_IFACE),
+            method,
+            endpoint,
+            size,
+            &transfer->reply);
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
+}
+
+/** Read buffer from HCD.
+ *
+ * @param phone Opened phone to HCD.
+ * @param hash Buffer hash (obtained after completing IN transaction).
+ * @param buffer Buffer where to store data data.
+ * @param size Buffer size.
+ * @param actual_size Storage where actual number of bytes transferred will
+ *      be stored.
+ * @return Error status.
+ */
+static int read_buffer_in(int phone, ipcarg_t hash,
+    void *buffer, size_t size, size_t *actual_size)
+{
+        ipc_call_t answer_data;
+        ipcarg_t answer_rc;
+        aid_t req;
+        int rc;
+
+        req = async_send_2(phone,
+            DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_BUFFER,
+            hash,
+            &answer_data);
+
+        rc = async_data_read_start(phone, buffer, size);
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return EINVAL;
+        }
+
+        async_wait_for(req, &answer_rc);
+        rc = (int)answer_rc;
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        *actual_size = IPC_GET_ARG1(answer_data);
+
+        return EOK;
+}
+
+/** Blocks caller until given USB transaction is finished.
+ * After the transaction is finished, the user can access all output data
+ * given to initial call function.
+ *
+ * @param handle Transaction handle.
+ * @return Error status.
+ * @retval EOK No error.
+ * @retval EBADMEM Invalid handle.
+ * @retval ENOENT Data buffer associated with transaction does not exist.
+ */
+int usb_drv_async_wait_for(usb_handle_t handle)
+{
+        if (handle == 0) {
+                return EBADMEM;
+        }
+
+        int rc = EOK;
+
+        transfer_info_t *transfer = (transfer_info_t *) handle;
+
+        ipcarg_t answer_rc;
+        async_wait_for(transfer->request, &answer_rc);
+
+        if (answer_rc != EOK) {
+                rc = (int) answer_rc;
+                goto leave;
+        }
+
+        /*
+         * If the buffer is not NULL, we must accept some data.
+         */
+        if ((transfer->buffer != NULL) && (transfer->size > 0)) {
+                /*
+                 * The buffer hash identifies the data on the server
+                 * side.
+                 * We will use it when actually reading-in the data.
+                 */
+                ipcarg_t buffer_hash = IPC_GET_ARG1(transfer->reply);
+                if (buffer_hash == 0) {
+                        rc = ENOENT;
+                        goto leave;
+                }
+
+                size_t actual_size;
+                rc = read_buffer_in(transfer->phone, buffer_hash,
+                    transfer->buffer, transfer->size, &actual_size);
+
+                if (rc != EOK) {
+                        goto leave;
+                }
+
+                if (transfer->size_transferred) {
+                        *(transfer->size_transferred) = actual_size;
+                }
+        }
+
+leave:
+        free(transfer);
+
+        return rc;
+}
+
+/** Send interrupt data to device. */
+int usb_drv_async_interrupt_out(int phone, usb_endpoint_t endpoint,
+    void *buffer, size_t size,
+    usb_handle_t *handle)
+{
+        return async_send_buffer(phone,
+            IPC_M_USB_INTERRUPT_OUT,
+            endpoint,
+            buffer, size,
+            handle);
+}
+
+/** Request interrupt data from device. */
+int usb_drv_async_interrupt_in(int phone, usb_endpoint_t endpoint,
+    void *buffer, size_t size, size_t *actual_size,
+    usb_handle_t *handle)
+{
+        return async_recv_buffer(phone,
+            IPC_M_USB_INTERRUPT_IN,
+            endpoint,
+            buffer, size, actual_size,
+            handle);
+}
 
 /**