Changeset df6ded8 in mainline for uspace/lib/usbhost/src/usb_transfer_batch.c

Timestamp:

2018-02-28T16:37:50Z (7 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1b20da0

Parents:

f5e5f73 (diff), b2dca8de (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jakub Jermar <jakub@…> (2018-02-28 16:06:42)

git-committer:

Jakub Jermar <jakub@…> (2018-02-28 16:37:50)

Message:

Merge github.com:helenos-xhci-team/helenos

This commit merges support for USB 3 and generally refactors, fixes,
extends and cleans up the existing USB framework.

Notable additions and features:

• new host controller driver has been implemented to control various xHC models (among others, NEC Renesas uPD720200)
• isochronous data transfer mode
• support for explicit USB device removal
• USB tablet driver

File:

• uspace/lib/usbhost/src/usb_transfer_batch.c (modified) (2 diffs)

uspace/lib/usbhost/src/usb_transfer_batch.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -33 +34 @@
  */
 
-#include <usb/host/usb_transfer_batch.h>
-#include <usb/debug.h>
-
 #include <assert.h>
 #include <errno.h>
-#include <macros.h>
-#include <mem.h>
 #include <stdlib.h>
-#include <usbhc_iface.h>
-
-/** Allocate and initialize usb_transfer_batch structure.
- * @param ep endpoint used by the transfer batch.
- * @param buffer data to send/recieve.
- * @param buffer_size Size of data buffer.
- * @param setup_buffer Data to send in SETUP stage of control transfer.
- * @param func_in callback on IN transfer completion.
- * @param func_out callback on OUT transfer completion.
- * @param fun DDF function (passed to callback function).
- * @param arg Argument to pass to the callback function.
- * @param private_data driver specific per batch data.
- * @param private_data_dtor Function to properly destroy private_data.
- * @return Pointer to valid usb_transfer_batch_t structure, NULL on failure.
- */
-usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *ep, char *buffer,
-    size_t buffer_size,
-    uint64_t setup_buffer,
-    usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out,
-    void *arg)
-{
-        if (func_in == NULL && func_out == NULL)
-                return NULL;
-        if (func_in != NULL && func_out != NULL)
-                return NULL;
-
-        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
-        if (instance) {
-                instance->ep = ep;
-                instance->callback_in = func_in;
-                instance->callback_out = func_out;
-                instance->arg = arg;
-                instance->buffer = buffer;
-                instance->buffer_size = buffer_size;
-                instance->setup_size = 0;
-                instance->transfered_size = 0;
-                instance->error = EOK;
-                if (ep && ep->transfer_type == USB_TRANSFER_CONTROL) {
-                        memcpy(instance->setup_buffer, &setup_buffer,
-                            USB_SETUP_PACKET_SIZE);
-                        instance->setup_size = USB_SETUP_PACKET_SIZE;
+#include <str_error.h>
+#include <usb/debug.h>
+
+#include "endpoint.h"
+#include "bus.h"
+
+#include "usb_transfer_batch.h"
+
+/**
+ * Create a batch on a given endpoint.
+ *
+ * If the bus callback is not defined, it just creates a default batch.
+ */
+usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *ep)
+{
+        assert(ep);
+
+        bus_t *bus = endpoint_get_bus(ep);
+
+        if (!bus->ops->batch_create) {
+                usb_transfer_batch_t *batch = calloc(1, sizeof(usb_transfer_batch_t));
+                if (!batch)
+                        return NULL;
+                usb_transfer_batch_init(batch, ep);
+                return batch;
+        }
+
+        return bus->ops->batch_create(ep);
+}
+
+/**
+ * Initialize given batch structure.
+ */
+void usb_transfer_batch_init(usb_transfer_batch_t *batch, endpoint_t *ep)
+{
+        assert(ep);
+        /* Batch reference */
+        endpoint_add_ref(ep);
+        batch->ep = ep;
+}
+
+/**
+ * Destroy the batch. If there's no bus callback, just free it.
+ */
+void usb_transfer_batch_destroy(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(batch->ep);
+
+        bus_t *bus = endpoint_get_bus(batch->ep);
+        endpoint_t *ep = batch->ep;
+
+        if (bus->ops) {
+                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " destroying.",
+                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
+                bus->ops->batch_destroy(batch);
+        }
+        else {
+                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.",
+                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
+                free(batch);
+        }
+
+        /* Batch reference */
+        endpoint_del_ref(ep);
+}
+
+bool usb_transfer_batch_bounce_required(usb_transfer_batch_t *batch)
+{
+        if (!batch->size)
+                return false;
+
+        unsigned flags = batch->dma_buffer.policy & DMA_POLICY_FLAGS_MASK;
+        unsigned required_flags =
+            batch->ep->required_transfer_buffer_policy & DMA_POLICY_FLAGS_MASK;
+
+        if (required_flags & ~flags)
+                return true;
+
+        size_t chunk_mask = dma_policy_chunk_mask(batch->dma_buffer.policy);
+        size_t required_chunk_mask =
+             dma_policy_chunk_mask(batch->ep->required_transfer_buffer_policy);
+
+        /* If the chunks are at least as large as required, we're good */
+        if ((required_chunk_mask & ~chunk_mask) == 0)
+                return false;
+
+        size_t start_chunk = batch->offset & ~chunk_mask;
+        size_t end_chunk = (batch->offset + batch->size - 1) & ~chunk_mask;
+
+        /* The requested area crosses a chunk boundary */
+        if (start_chunk != end_chunk)
+                return true;
+
+        return false;
+}
+
+errno_t usb_transfer_batch_bounce(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(!batch->is_bounced);
+
+        dma_buffer_release(&batch->dma_buffer);
+
+        batch->original_buffer = batch->dma_buffer.virt + batch->offset;
+
+        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->size, batch->ep->transfer_buffer_policy);
+        if (err)
+                return err;
+
+        /* Copy the data out */
+        if (batch->dir == USB_DIRECTION_OUT)
+                memcpy(batch->dma_buffer.virt,
+                    batch->original_buffer,
+                    batch->size);
+
+        batch->is_bounced = true;
+        batch->offset = 0;
+
+        return err;
+}
+
+/**
+ * Finish a transfer batch: call handler, destroy batch, release endpoint.
+ *
+ * Call only after the batch have been scheduled && completed!
+ */
+void usb_transfer_batch_finish(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(batch->ep);
+
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch));
+
+        if (batch->error == EOK && batch->size > 0) {
+                if (batch->is_bounced) {
+                        /* 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 (instance->ep)
-                        endpoint_use(instance->ep);
-        }
-        return instance;
-}
-
-/** Correctly dispose all used data structures.
- *
- * @param[in] instance Batch structure to use.
- */
-void usb_transfer_batch_destroy(usb_transfer_batch_t *instance)
-{
-        if (!instance)
-                return;
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.\n",
-            instance, USB_TRANSFER_BATCH_ARGS(*instance));
-        if (instance->ep) {
-                endpoint_release(instance->ep);
-        }
-        free(instance);
-}
-
-/** Prepare data and call the right callback.
- *
- * @param[in] instance Batch structure to use.
- * @param[in] data Data to copy to the output buffer.
- * @param[in] size Size of @p data.
- * @param[in] error Error value to use.
- */
-void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,
-    const void *data, size_t size, errno_t error)
-{
-        assert(instance);
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.\n",
-            instance, USB_TRANSFER_BATCH_ARGS(*instance));
-
-        /* NOTE: Only one of these pointers should be set. */
-        if (instance->callback_out) {
-                instance->callback_out(error, instance->arg);
-        }
-
-        if (instance->callback_in) {
-                /* We care about the data and there are some to copy */
-                const size_t safe_size = min(size, instance->buffer_size);
-                if (data) {
-                        memcpy(instance->buffer, data, safe_size);
+                else {
+                        dma_buffer_release(&batch->dma_buffer);
                 }
-                instance->callback_in(error, safe_size, instance->arg);
-        }
-}
+        }
+
+        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",
+                            batch, str_error(err));
+        }
+
+        usb_transfer_batch_destroy(batch);
+}
+
 /**
  * @}