Changes in uspace/drv/uhci-hcd/batch.c [4ca18ae:f706355] in mainline

File:

• uspace/drv/uhci-hcd/batch.c (modified) (13 diffs)

uspace/drv/uhci-hcd/batch.c

@@ -30 +30 @@
  */
 /** @file
- * @brief UHCI driver USB transaction structure
+ * @brief UHCI driver USB transfer structure
  */
 #include <errno.h>
@@ -45 +45 @@
 #define DEFAULT_ERROR_COUNT 3
 
-typedef struct uhci_batch {
+typedef struct uhci_transfer_batch {
         qh_t *qh;
         td_t *tds;
-        size_t transfers;
-} uhci_batch_t;
+        void *device_buffer;
+        size_t td_count;
+} uhci_transfer_batch_t;
+/*----------------------------------------------------------------------------*/
+static void uhci_transfer_batch_dispose(void *uhci_batch)
+{
+        uhci_transfer_batch_t *instance = uhci_batch;
+        assert(instance);
+        free32(instance->device_buffer);
+        free(instance);
+}
+/*----------------------------------------------------------------------------*/
 
 static void batch_control(usb_transfer_batch_t *instance,
     usb_packet_id data_stage, usb_packet_id status_stage);
 static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
-static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
-static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
-
 
 /** Allocate memory and initialize internal data structure.
  *
  * @param[in] fun DDF function to pass to callback.
- * @param[in] target Device and endpoint target of the transaction.
- * @param[in] transfer_type Interrupt, Control or Bulk.
- * @param[in] max_packet_size maximum allowed size of data transfers.
- * @param[in] speed Speed of the transaction.
+ * @param[in] ep Communication target
  * @param[in] buffer Data source/destination.
  * @param[in] size Size of the buffer.
  * @param[in] setup_buffer Setup data source (if not NULL)
  * @param[in] setup_size Size of setup_buffer (should be always 8)
- * @param[in] func_in function to call on inbound transaction completion
- * @param[in] func_out function to call on outbound transaction completion
+ * @param[in] func_in function to call on inbound transfer completion
+ * @param[in] func_out function to call on outbound transfer completion
  * @param[in] arg additional parameter to func_in or func_out
- * @param[in] ep Pointer to endpoint toggle management structure.
- * @return Valid pointer if all substructures were successfully created,
+ * @return Valid pointer if all structures were successfully created,
  * NULL otherwise.
  *
- * Determines the number of needed transfers (TDs). Prepares a transport buffer
- * (that is accessible by the hardware). Initializes parameters needed for the
- * transaction and callback.
- */
-usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
-    usb_transfer_type_t transfer_type, size_t max_packet_size,
-    usb_speed_t speed, char *buffer, size_t buffer_size,
-    char* setup_buffer, size_t setup_size,
+ * Determines the number of needed transfer descriptors (TDs).
+ * Prepares a transport buffer (that is accessible by the hardware).
+ * Initializes parameters needed for the transfer and callback.
+ */
+usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
+    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out, void *arg, endpoint_t *ep
-    )
-{
+    usbhc_iface_transfer_out_callback_t func_out, void *arg)
+{
+        assert(ep);
         assert(func_in == NULL || func_out == NULL);
         assert(func_in != NULL || func_out != NULL);
@@ -94 +95 @@
         if (ptr == NULL) { \
                 usb_log_error(message); \
-                if (instance) { \
-                        batch_dispose(instance); \
+                if (uhci_data) { \
+                        uhci_transfer_batch_dispose(uhci_data); \
                 } \
                 return NULL; \
         } else (void)0
 
+        uhci_transfer_batch_t *uhci_data =
+            malloc(sizeof(uhci_transfer_batch_t));
+        CHECK_NULL_DISPOSE_RETURN(uhci_data,
+            "Failed to allocate UHCI batch.\n");
+        bzero(uhci_data, sizeof(uhci_transfer_batch_t));
+
+        uhci_data->td_count =
+            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
+        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+                uhci_data->td_count += 2;
+        }
+
+        assert((sizeof(td_t) % 16) == 0);
+        const size_t total_size = (sizeof(td_t) * uhci_data->td_count)
+            + sizeof(qh_t) + setup_size + buffer_size;
+        uhci_data->device_buffer = malloc32(total_size);
+        CHECK_NULL_DISPOSE_RETURN(uhci_data->device_buffer,
+            "Failed to allocate UHCI buffer.\n");
+        bzero(uhci_data->device_buffer, total_size);
+
+        uhci_data->tds = uhci_data->device_buffer;
+        uhci_data->qh =
+            (uhci_data->device_buffer + (sizeof(td_t) * uhci_data->td_count));
+
+        qh_init(uhci_data->qh);
+        qh_set_element_td(uhci_data->qh, uhci_data->tds);
+
         usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        usb_transfer_batch_init(instance, target,
-            transfer_type, speed, max_packet_size,
-            buffer, NULL, buffer_size, NULL, setup_size, func_in,
-            func_out, arg, fun, ep, NULL);
-
-
-        uhci_batch_t *data = malloc(sizeof(uhci_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(instance,
-            "Failed to allocate batch instance.\n");
-        bzero(data, sizeof(uhci_batch_t));
-        instance->private_data = data;
-
-        data->transfers = (buffer_size + max_packet_size - 1) / max_packet_size;
-        if (transfer_type == USB_TRANSFER_CONTROL) {
-                data->transfers += 2;
-        }
-
-        data->tds = malloc32(sizeof(td_t) * data->transfers);
-        CHECK_NULL_DISPOSE_RETURN(
-            data->tds, "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->transfers);
-
-        data->qh = malloc32(sizeof(qh_t));
-        CHECK_NULL_DISPOSE_RETURN(data->qh,
-            "Failed to allocate batch queue head.\n");
-        qh_init(data->qh);
-        qh_set_element_td(data->qh, addr_to_phys(data->tds));
-
-        if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
-                    "Failed to allocate device accessible buffer.\n");
-        }
-
-        if (setup_size > 0) {
-                instance->setup_buffer = malloc32(setup_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
-                    "Failed to allocate device accessible setup buffer.\n");
-                memcpy(instance->setup_buffer, setup_buffer, setup_size);
-        }
-
+        void *setup =
+            uhci_data->device_buffer + (sizeof(td_t) * uhci_data->td_count)
+            + sizeof(qh_t);
+        void *data_buffer = setup + setup_size;
+        usb_target_t target =
+            { .address = ep->address, .endpoint = ep->endpoint };
+        usb_transfer_batch_init(instance, ep, buffer, data_buffer, buffer_size,
+            setup, setup_size, func_in, func_out, arg, fun,
+            uhci_data, uhci_transfer_batch_dispose);
+
+        memcpy(instance->setup_buffer, setup_buffer, setup_size);
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
@@ -155 +153 @@
  *
  * Walk all TDs. Stop with false if there is an active one (it is to be
- * processed). Stop with true if an error is found. Return true if the last TS
+ * processed). Stop with true if an error is found. Return true if the last TD
  * is reached.
  */
@@ -161 +159 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
 
         usb_log_debug2("Batch(%p) checking %d transfer(s) for completion.\n",
-            instance, data->transfers);
+            instance, data->td_count);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->transfers; ++i) {
+        for (;i < data->td_count; ++i) {
                 if (td_is_active(&data->tds[i])) {
                         return false;
@@ -178 +176 @@
                             instance, i, data->tds[i].status);
                         td_print_status(&data->tds[i]);
-                        if (instance->ep != NULL)
-                                endpoint_toggle_set(instance->ep,
-                                    td_toggle(&data->tds[i]));
+
+                        assert(instance->ep != NULL);
+                        endpoint_toggle_set(instance->ep,
+                            td_toggle(&data->tds[i]));
                         if (i > 0)
                                 goto substract_ret;
@@ -195 +194 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control write transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Uses genercir control function with pids OUT and IN.
+/** Prepares control write transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses generic control function with pids OUT and IN.
  */
 void batch_control_write(usb_transfer_batch_t *instance)
@@ -205 +204 @@
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control read transaction.
+/** Prepares control read transfer.
  *
  * @param[in] instance Batch structure to use.
@@ -222 +220 @@
         assert(instance);
         batch_control(instance, USB_PID_IN, USB_PID_OUT);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare interrupt in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_interrupt_in(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
         batch_data(instance, USB_PID_IN);
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare interrupt out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_interrupt_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk in transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_IN.
+/** Prepare bulk in transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_IN.
  */
 void batch_bulk_in(usb_transfer_batch_t *instance)
@@ -269 +264 @@
         assert(instance);
         batch_data(instance, USB_PID_IN);
-        instance->direction = USB_DIRECTION_IN;
-        instance->next_step = batch_call_in_and_dispose;
+        instance->next_step = usb_transfer_batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk out transaction.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transaction with PID_OUT.
+/** Prepare bulk out transfer.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transfer with PID_OUT.
  */
 void batch_bulk_out(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer,
-            instance->buffer_size);
+        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = batch_call_out_and_dispose;
+        instance->next_step = usb_transfer_batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic data transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] pid Pid to use for data transfers.
- *
- * Packets with alternating toggle bit and supplied pid value.
+/** Prepare generic data transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] pid Pid to use for data transactions.
+ *
+ * Transactions with alternating toggle bit and supplied pid value.
  * The last transfer is marked with IOC flag.
  */
@@ -303 +295 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
 
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
         int toggle = endpoint_toggle_get(instance->ep);
         assert(toggle == 0 || toggle == 1);
 
-        size_t transfer = 0;
+        size_t td = 0;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *trans_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
                 const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_t *next_transfer = (transfer + 1 < data->transfers)
-                    ? &data->tds[transfer + 1] : NULL;
-
-                assert(transfer < data->transfers);
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_t *next_td = (td + 1 < data->td_count)
+                    ? &data->tds[td + 1] : NULL;
+
+
+                usb_target_t target =
+                    { instance->ep->address, instance->ep->endpoint };
+
+                assert(td < data->td_count);
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, pid, buffer, next_td);
+
+                ++td;
+                toggle = 1 - toggle;
+                buffer += packet_size;
                 assert(packet_size <= remain_size);
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, pid, trans_data,
-                    next_transfer);
-
-
-                toggle = 1 - toggle;
                 remain_size -= packet_size;
-                ++transfer;
         }
-        td_set_ioc(&data->tds[transfer - 1]);
+        td_set_ioc(&data->tds[td - 1]);
         endpoint_toggle_set(instance->ep, toggle);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare generic control transaction
- *
- * @param[in] instance Batch structure to use.
- * @param[in] data_stage Pid to use for data transfers.
- * @param[in] status_stage Pid to use for data transfers.
+/** Prepare generic control transfer
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data_stage Pid to use for data tds.
+ * @param[in] status_stage Pid to use for data tds.
  *
  * Setup stage with toggle 0 and USB_PID_SETUP.
@@ -356 +347 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
-        assert(data->transfers >= 2);
-
-        const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = 0;
+        assert(data->td_count >= 2);
+
+        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
+        const usb_target_t target =
+            { instance->ep->address, instance->ep->endpoint };
+
         /* setup stage */
         td_init(
-            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
-            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
+            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, 0, false,
+            low_speed, target, USB_PID_SETUP, instance->setup_buffer,
             &data->tds[1]);
 
         /* data stage */
-        size_t transfer = 1;
+        size_t td = 1;
+        unsigned toggle = 1;
         size_t remain_size = instance->buffer_size;
+        char *buffer = instance->data_buffer;
         while (remain_size > 0) {
-                char *control_data =
-                    instance->transport_buffer + instance->buffer_size
-                    - remain_size;
-
+                const size_t packet_size =
+                    (instance->ep->max_packet_size > remain_size) ?
+                    remain_size : instance->ep->max_packet_size;
+
+                td_init(
+                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, target, data_stage,
+                    buffer, &data->tds[td + 1]);
+
+                ++td;
                 toggle = 1 - toggle;
-
-                const size_t packet_size =
-                    (instance->max_packet_size > remain_size) ?
-                    remain_size : instance->max_packet_size;
-
-                td_init(
-                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, data_stage,
-                    control_data, &data->tds[transfer + 1]);
-
-                ++transfer;
-                assert(transfer < data->transfers);
+                buffer += packet_size;
+                assert(td < data->td_count);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -394 +385 @@
 
         /* status stage */
-        assert(transfer == data->transfers - 1);
+        assert(td == data->td_count - 1);
 
         td_init(
-            &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-            instance->target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[transfer]);
+            &data->tds[td], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
+            target, status_stage, NULL, NULL);
+        td_set_ioc(&data->tds[td]);
 
         usb_log_debug2("Control last TD status: %x.\n",
-            data->tds[transfer].status);
-}
-/*----------------------------------------------------------------------------*/
+            data->tds[td].status);
+}
+/*----------------------------------------------------------------------------*/
+/** Provides access to QH data structure.
+ * @param[in] instance Batch pointer to use.
+ * @return Pointer to the QH used by the batch.
+ */
 qh_t * batch_qh(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
+        uhci_transfer_batch_t *data = instance->private_data;
         assert(data);
         return data->qh;
 }
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_in(instance);
-        batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly disposes of batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_out(instance);
-        batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Correctly dispose all used data structures.
- *
- * @param[in] instance Batch structure to use.
- */
-void batch_dispose(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
-        /* free32 is NULL safe */
-        free32(data->tds);
-        free32(data->qh);
-        free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(data);
-        free(instance);
-}
 /**
  * @}