Changeset c21e6a5 in mainline for uspace/lib/usbhost/src

Timestamp:

2018-02-05T00:54:08Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

af16ebe

Parents:

65c059f

git-author:

Ondřej Hlavatý <aearsis@…> (2018-02-05 00:27:40)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-02-05 00:54:08)

Message:

usbhost: prepare buffers for transfers in library

Location:

uspace/lib/usbhost/src

Files:

• endpoint.c (modified) (3 diffs)
• usb_transfer_batch.c (modified) (2 diffs)

uspace/lib/usbhost/src/endpoint.c

@@ -74 +74 @@
 
         ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe;
+        ep->transfer_buffer_policy = DMA_POLICY_STRICT;
 }
 
@@ -215 +216 @@
  * @param name Communication identifier (for nicer output).
  */
-int endpoint_send_batch(endpoint_t *ep, usb_target_t target,
+errno_t endpoint_send_batch(endpoint_t *ep, usb_target_t target,
     usb_direction_t direction, char *data, size_t size, uint64_t setup_data,
     usbhc_iface_transfer_callback_t on_complete, void *arg, const char *name)
@@ -258 +259 @@
 
         batch->target = target;
-        batch->buffer = data;
-        batch->buffer_size = size;
         batch->setup.packed = setup_data;
         batch->dir = direction;
+        batch->buffer_size = size;
+
+        errno_t err;
+        if ((err = usb_transfer_batch_prepare_buffer(batch, data))) {
+                usb_log_warning("Failed to prepare buffer for batch: %s", str_error(err));
+                usb_transfer_batch_destroy(batch);
+                return err;
+        }
+
         batch->on_complete = on_complete;
         batch->on_complete_data = arg;

uspace/lib/usbhost/src/usb_transfer_batch.c

@@ -104 +104 @@
 
 /**
+ * Prepare a DMA buffer according to endpoint policy.
+ *
+ * If the buffer is suitable to be used directly, it is. Otherwise, a bounce
+ * buffer is created.
+ */
+errno_t usb_transfer_batch_prepare_buffer(
+    usb_transfer_batch_t *batch, char *buf)
+{
+        const dma_policy_t policy = batch->ep->transfer_buffer_policy;
+
+        /* Empty transfers do not need a buffer */
+        if (batch->buffer_size == 0)
+                return EOK;
+
+        if (dma_buffer_check_policy(buf, batch->buffer_size, policy)) {
+                /* Mark this case with invalid address */
+                batch->original_buffer = NULL;
+
+                /* Fill the buffer with virtual address and lock it for DMA */
+                return dma_buffer_lock(&batch->dma_buffer, buf, batch->buffer_size);
+        }
+        else {
+                usb_log_debug("Batch(%p): Buffer cannot be used directly, "
+                    "falling back to bounce buffer!", batch);
+                const errno_t err = dma_buffer_alloc_policy(&batch->dma_buffer,
+                    batch->buffer_size, policy);
+
+                /* Copy the data out */
+                if (!err && batch->dir == USB_DIRECTION_OUT)
+                        memcpy(batch->dma_buffer.virt, buf, batch->buffer_size);
+
+                /* Store the buffer to store the data back before finishing */
+                batch->original_buffer = buf;
+
+                return err;
+        }
+}
+
+/**
  * Finish a transfer batch: call handler, destroy batch, release endpoint.
  *
@@ -116 +155 @@
             batch, USB_TRANSFER_BATCH_ARGS(*batch));
 
+        if (batch->error == EOK && batch->buffer_size > 0) {
+                if (batch->original_buffer == NULL) {
+                        /* Unlock the buffer for DMA */
+                        dma_buffer_unlock(&batch->dma_buffer,
+                            batch->buffer_size);
+                }
+                else {
+                        /* We we're forced to use bounce buffer, copy it back */
+                        if (batch->dir == USB_DIRECTION_IN)
+                                memcpy(batch->original_buffer,
+                                    batch->dma_buffer.virt,
+                                    batch->transferred_size);
+
+                        dma_buffer_free(&batch->dma_buffer);
+                }
+        }
+
         if (batch->on_complete) {
                 const int err = batch->on_complete(batch->on_complete_data, batch->error, batch->transferred_size);
                 if (err)
-                        usb_log_warning("batch %p failed to complete: %s",
+                        usb_log_warning("Batch %p failed to complete: %s",
                             batch, str_error(err));
         }