Changes in uspace/drv/uhci-hcd/batch.c [f706355:06c552c] 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 transfer structure
+ * @brief UHCI driver USB transaction structure
  */
 #include <errno.h>
@@ -45 +45 @@
 #define DEFAULT_ERROR_COUNT 3
 
-typedef struct uhci_transfer_batch {
+typedef struct uhci_batch {
         qh_t *qh;
         td_t *tds;
-        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);
-}
-/*----------------------------------------------------------------------------*/
+        size_t transfers;
+} uhci_batch_t;
 
 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] ep Communication target
+ * @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] 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 transfer completion
- * @param[in] func_out function to call on outbound transfer completion
+ * @param[in] func_in function to call on inbound transaction completion
+ * @param[in] func_out function to call on outbound transaction completion
  * @param[in] arg additional parameter to func_in or func_out
- * @return Valid pointer if all structures were successfully created,
+ * @param[in] ep Pointer to endpoint toggle management structure.
+ * @return Valid pointer if all substructures were successfully created,
  * NULL otherwise.
  *
- * 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.
+ * 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, endpoint_t *ep,
@@ -95 +92 @@
         if (ptr == NULL) { \
                 usb_log_error(message); \
-                if (uhci_data) { \
-                        uhci_transfer_batch_dispose(uhci_data); \
+                if (instance) { \
+                        batch_dispose(instance); \
                 } \
                 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");
-        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_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
+            ep->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(data, "Failed to allocate batch data.\n");
+        bzero(data, sizeof(uhci_batch_t));
+        instance->private_data = data;
+
+        data->transfers =
+            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
+        if (ep->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);
+        }
+
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
@@ -153 +154 @@
  *
  * 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 TD
+ * processed). Stop with true if an error is found. Return true if the last TS
  * is reached.
  */
@@ -159 +160 @@
 {
         assert(instance);
-        uhci_transfer_batch_t *data = instance->private_data;
+        uhci_batch_t *data = instance->private_data;
         assert(data);
 
         usb_log_debug2("Batch(%p) checking %d transfer(s) for completion.\n",
-            instance, data->td_count);
+            instance, data->transfers);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->td_count; ++i) {
+        for (;i < data->transfers; ++i) {
                 if (td_is_active(&data->tds[i])) {
                         return false;
@@ -176 +177 @@
                             instance, i, data->tds[i].status);
                         td_print_status(&data->tds[i]);
-
                         assert(instance->ep != NULL);
+
                         endpoint_toggle_set(instance->ep,
                             td_toggle(&data->tds[i]));
@@ -194 +195 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control write transfer.
- *
- * @param[in] instance Batch structure to use.
- *
- * Uses generic control function with pids OUT and IN.
+/** Prepares control write transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses genercir control function with pids OUT and IN.
  */
 void batch_control_write(usb_transfer_batch_t *instance)
@@ -204 +205 @@
         assert(instance);
         /* We are data out, we are supposed to provide data */
-        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
+        memcpy(instance->transport_buffer, instance->buffer,
+            instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
-        instance->next_step = usb_transfer_batch_call_out_and_dispose;
+        instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepares control read transfer.
+/** Prepares control read transaction.
  *
  * @param[in] instance Batch structure to use.
@@ -220 +222 @@
         assert(instance);
         batch_control(instance, USB_PID_IN, USB_PID_OUT);
-        instance->next_step = usb_transfer_batch_call_in_and_dispose;
+        instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt in transfer.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transfer with PID_IN.
+/** Prepare interrupt in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction 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 = usb_transfer_batch_call_in_and_dispose;
+        instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare interrupt out transfer.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transfer with PID_OUT.
+/** Prepare interrupt out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction 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->data_buffer, instance->buffer, instance->buffer_size);
+        memcpy(instance->transport_buffer, instance->buffer,
+            instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = usb_transfer_batch_call_out_and_dispose;
+        instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk in transfer.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transfer with PID_IN.
+/** Prepare bulk in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_IN.
  */
 void batch_bulk_in(usb_transfer_batch_t *instance)
@@ -264 +269 @@
         assert(instance);
         batch_data(instance, USB_PID_IN);
-        instance->next_step = usb_transfer_batch_call_in_and_dispose;
+        instance->direction = USB_DIRECTION_IN;
+        instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** Prepare bulk out transfer.
- *
- * @param[in] instance Batch structure to use.
- *
- * Data transfer with PID_OUT.
+/** Prepare bulk out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction 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->data_buffer, instance->buffer, instance->buffer_size);
+        memcpy(instance->transport_buffer, instance->buffer,
+            instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
-        instance->next_step = usb_transfer_batch_call_out_and_dispose;
+        instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
 }
 /*----------------------------------------------------------------------------*/
-/** 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.
+/** 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.
  * The last transfer is marked with IOC flag.
  */
@@ -295 +303 @@
 {
         assert(instance);
-        uhci_transfer_batch_t *data = instance->private_data;
+        uhci_batch_t *data = instance->private_data;
         assert(data);
 
-        const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
         int toggle = endpoint_toggle_get(instance->ep);
         assert(toggle == 0 || toggle == 1);
 
-        size_t td = 0;
+        size_t transfer = 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->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);
+                    (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);
+                assert(packet_size <= remain_size);
+
                 td_init(
-                    &data->tds[td], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, target, pid, buffer, next_td);
-
-                ++td;
+                    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, pid, trans_data,
+                    next_transfer);
+
+
                 toggle = 1 - toggle;
-                buffer += packet_size;
-                assert(packet_size <= remain_size);
                 remain_size -= packet_size;
-        }
-        td_set_ioc(&data->tds[td - 1]);
+                ++transfer;
+        }
+        td_set_ioc(&data->tds[transfer - 1]);
         endpoint_toggle_set(instance->ep, toggle);
 }
 /*----------------------------------------------------------------------------*/
-/** 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.
+/** 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.
  *
  * Setup stage with toggle 0 and USB_PID_SETUP.
@@ -347 +356 @@
 {
         assert(instance);
-        uhci_transfer_batch_t *data = instance->private_data;
+        uhci_batch_t *data = instance->private_data;
         assert(data);
-        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 };
-
+        assert(data->transfers >= 2);
+
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        int toggle = 0;
         /* setup stage */
         td_init(
-            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, 0, false,
-            low_speed, target, USB_PID_SETUP, instance->setup_buffer,
+            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
+            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
             &data->tds[1]);
 
         /* data stage */
-        size_t td = 1;
-        unsigned toggle = 1;
+        size_t transfer = 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;
+
+                toggle = 1 - toggle;
+
                 const size_t packet_size =
-                    (instance->ep->max_packet_size > remain_size) ?
-                    remain_size : instance->ep->max_packet_size;
+                    (instance->max_packet_size > remain_size) ?
+                    remain_size : instance->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;
-                buffer += packet_size;
-                assert(td < data->td_count);
+                    &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);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -385 +394 @@
 
         /* status stage */
-        assert(td == data->td_count - 1);
+        assert(transfer == data->transfers - 1);
 
         td_init(
-            &data->tds[td], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-            target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[td]);
+            &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
+            instance->target, status_stage, NULL, NULL);
+        td_set_ioc(&data->tds[transfer]);
 
         usb_log_debug2("Control last TD status: %x.\n",
-            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.
- */
+            data->tds[transfer].status);
+}
+/*----------------------------------------------------------------------------*/
 qh_t * batch_qh(usb_transfer_batch_t *instance)
 {
         assert(instance);
-        uhci_transfer_batch_t *data = instance->private_data;
+        uhci_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);
+}
 /**
  * @}