Changes in uspace/drv/bus/usb/uhci/uhci_batch.c [58563585:5fd9c30] in mainline

File:

• uspace/drv/bus/usb/uhci/uhci_batch.c (modified) (17 diffs)

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -50 +50 @@
 #define DEFAULT_ERROR_COUNT 3
 
-/** Safely destructs uhci_transfer_batch_t structure.
+/** Transfer batch setup table. */
+static void (*const batch_setup[])(uhci_transfer_batch_t*);
+
+/** Destroys uhci_transfer_batch_t structure.
  *
  * @param[in] uhci_batch Instance to destroy.
  */
-static void uhci_transfer_batch_dispose(uhci_transfer_batch_t *uhci_batch)
-{
-        if (uhci_batch) {
-                usb_transfer_batch_destroy(uhci_batch->usb_batch);
-                free32(uhci_batch->device_buffer);
-                free(uhci_batch);
-        }
-}
-
-/** Finishes usb_transfer_batch and destroys the structure.
- *
- * @param[in] uhci_batch Instance to finish and destroy.
- */
-void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch)
+void uhci_transfer_batch_destroy(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(!link_in_use(&uhci_batch->link));
-        usb_transfer_batch_finish(uhci_batch->usb_batch,
-            uhci_transfer_batch_data_buffer(uhci_batch));
-        uhci_transfer_batch_dispose(uhci_batch);
-}
-
-/** Transfer batch setup table. */
-static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t);
+        free32(uhci_batch->device_buffer);
+        free(uhci_batch);
+}
 
 /** Allocate memory and initialize internal data structure.
@@ -85 +69 @@
  * @return Valid pointer if all structures were successfully created,
  * NULL otherwise.
+ */
+uhci_transfer_batch_t * uhci_transfer_batch_create(endpoint_t *ep)
+{
+        uhci_transfer_batch_t *uhci_batch =
+            calloc(1, sizeof(uhci_transfer_batch_t));
+        if (!uhci_batch) {
+                usb_log_error("Failed to allocate UHCI batch.\n");
+                return NULL;
+        }
+
+        usb_transfer_batch_init(&uhci_batch->base, ep);
+
+        link_initialize(&uhci_batch->link);
+        return uhci_batch;
+}
+
+/* Prepares batch for commiting.
  *
  * Determines the number of needed transfer descriptors (TDs).
@@ -90 +91 @@
  * Initializes parameters needed for the transfer and callback.
  */
-uhci_transfer_batch_t * uhci_transfer_batch_get(usb_transfer_batch_t *usb_batch)
+int uhci_transfer_batch_prepare(uhci_transfer_batch_t *uhci_batch)
 {
         static_assert((sizeof(td_t) % 16) == 0);
-#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
-        if (ptr == NULL) { \
-                usb_log_error(message); \
-                uhci_transfer_batch_dispose(uhci_batch); \
-                return NULL; \
-        } else (void)0
-
-        uhci_transfer_batch_t *uhci_batch =
-            calloc(1, sizeof(uhci_transfer_batch_t));
-        CHECK_NULL_DISPOSE_RETURN(uhci_batch,
-            "Failed to allocate UHCI batch.\n");
-        link_initialize(&uhci_batch->link);
-        uhci_batch->td_count =
-            (usb_batch->buffer_size + usb_batch->ep->max_packet_size - 1)
-            / usb_batch->ep->max_packet_size;
+
+        usb_transfer_batch_t *usb_batch = &uhci_batch->base;
+
+        uhci_batch->td_count = (usb_batch->buffer_size + usb_batch->ep->max_packet_size - 1)
+                / usb_batch->ep->max_packet_size;
+
         if (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
                 uhci_batch->td_count += 2;
         }
 
+        const size_t setup_size = (uhci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL)
+                ? USB_SETUP_PACKET_SIZE
+                : 0;
+
         const size_t total_size = (sizeof(td_t) * uhci_batch->td_count)
-            + sizeof(qh_t) + usb_batch->setup_size + usb_batch->buffer_size;
+            + sizeof(qh_t) + setup_size + usb_batch->buffer_size;
         uhci_batch->device_buffer = malloc32(total_size);
-        CHECK_NULL_DISPOSE_RETURN(uhci_batch->device_buffer,
-            "Failed to allocate UHCI buffer.\n");
+        if (!uhci_batch->device_buffer) {
+                usb_log_error("Failed to allocate UHCI buffer.\n");
+                return ENOMEM;
+        }
         memset(uhci_batch->device_buffer, 0, total_size);
 
@@ -130 +128 @@
             + sizeof(qh_t);
         /* Copy SETUP packet data to the device buffer */
-        memcpy(dest, usb_batch->setup_buffer, usb_batch->setup_size);
-        dest += usb_batch->setup_size;
+        memcpy(dest, usb_batch->setup.buffer, setup_size);
+        dest += setup_size;
         /* Copy generic data unless they are provided by the device */
         if (usb_batch->ep->direction != USB_DIRECTION_IN) {
                 memcpy(dest, usb_batch->buffer, usb_batch->buffer_size);
         }
-        uhci_batch->usb_batch = usb_batch;
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
             " memory structures ready.\n", usb_batch,
             USB_TRANSFER_BATCH_ARGS(*usb_batch));
 
-        const usb_direction_t dir = usb_transfer_batch_direction(usb_batch);
-
         assert(batch_setup[usb_batch->ep->transfer_type]);
-        batch_setup[usb_batch->ep->transfer_type](uhci_batch, dir);
-
-        return uhci_batch;
+        batch_setup[usb_batch->ep->transfer_type](uhci_batch);
+
+        return EOK;
 }
 
@@ -158 +153 @@
  * is reached.
  */
-bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch)
+bool uhci_transfer_batch_check_completed(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
 
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
@@ -168 +162 @@
             USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
             uhci_batch->td_count);
-        uhci_batch->usb_batch->transfered_size = 0;
+        uhci_batch->base.transfered_size = 0;
 
         for (size_t i = 0;i < uhci_batch->td_count; ++i) {
@@ -175 +169 @@
                 }
 
-                uhci_batch->usb_batch->error = td_status(&uhci_batch->tds[i]);
-                if (uhci_batch->usb_batch->error != EOK) {
-                        assert(uhci_batch->usb_batch->ep != NULL);
+                uhci_batch->base.error = td_status(&uhci_batch->tds[i]);
+                if (uhci_batch->base.error != EOK) {
+                        assert(uhci_batch->base.ep != NULL);
 
                         usb_log_debug("Batch %p found error TD(%zu->%p):%"
@@ -184 +178 @@
                         td_print_status(&uhci_batch->tds[i]);
 
-                        endpoint_toggle_set(uhci_batch->usb_batch->ep,
+                        endpoint_toggle_set(uhci_batch->base.ep,
                             td_toggle(&uhci_batch->tds[i]));
                         if (i > 0)
@@ -191 +185 @@
                 }
 
-                uhci_batch->usb_batch->transfered_size
+                uhci_batch->base.transfered_size
                     += td_act_size(&uhci_batch->tds[i]);
                 if (td_is_short(&uhci_batch->tds[i]))
@@ -197 +191 @@
         }
 substract_ret:
-        uhci_batch->usb_batch->transfered_size
-            -= uhci_batch->usb_batch->setup_size;
+        if (uhci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL)
+                uhci_batch->base.transfered_size -= USB_SETUP_PACKET_SIZE;
         return true;
 }
@@ -216 +210 @@
  * The last transfer is marked with IOC flag.
  */
-static void batch_data(uhci_transfer_batch_t *uhci_batch, usb_direction_t dir)
+static void batch_data(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(uhci_batch->usb_batch->ep);
+
+        usb_direction_t dir = uhci_batch->base.dir;
         assert(dir == USB_DIRECTION_OUT || dir == USB_DIRECTION_IN);
 
@@ -226 +220 @@
         const usb_packet_id pid = direction_pids[dir];
         const bool low_speed =
-            uhci_batch->usb_batch->ep->speed == USB_SPEED_LOW;
-        const size_t mps = uhci_batch->usb_batch->ep->max_packet_size;
-        const usb_target_t target = {{
-            uhci_batch->usb_batch->ep->address,
-            uhci_batch->usb_batch->ep->endpoint }};
-
-        int toggle = endpoint_toggle_get(uhci_batch->usb_batch->ep);
+            uhci_batch->base.ep->speed == USB_SPEED_LOW;
+        const size_t mps = uhci_batch->base.ep->max_packet_size;
+        const usb_target_t target = uhci_batch->base.ep->target;
+
+        int toggle = endpoint_toggle_get(uhci_batch->base.ep);
         assert(toggle == 0 || toggle == 1);
 
         size_t td = 0;
-        size_t remain_size = uhci_batch->usb_batch->buffer_size;
+        size_t remain_size = uhci_batch->base.buffer_size;
         char *buffer = uhci_transfer_batch_data_buffer(uhci_batch);
 
@@ -256 +248 @@
         }
         td_set_ioc(&uhci_batch->tds[td - 1]);
-        endpoint_toggle_set(uhci_batch->usb_batch->ep, toggle);
+        endpoint_toggle_set(uhci_batch->base.ep, toggle);
         usb_log_debug2(
             "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
             uhci_batch->usb_batch,
-            usb_str_transfer_type(uhci_batch->usb_batch->ep->transfer_type),
-            usb_str_direction(uhci_batch->usb_batch->ep->direction),
+            usb_str_transfer_type(uhci_batch->base.ep->transfer_type),
+            usb_str_direction(uhci_batch->base.ep->direction),
             USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch));
 }
@@ -276 +268 @@
  * The last transfer is marked with IOC.
  */
-static void batch_control(uhci_transfer_batch_t *uhci_batch, usb_direction_t dir)
+static void batch_control(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
-        assert(uhci_batch->usb_batch);
-        assert(uhci_batch->usb_batch->ep);
+
+        usb_direction_t dir = uhci_batch->base.dir;
         assert(dir == USB_DIRECTION_OUT || dir == USB_DIRECTION_IN);
         assert(uhci_batch->td_count >= 2);
@@ -291 +283 @@
         const usb_packet_id status_stage_pid = status_stage_pids[dir];
         const bool low_speed =
-            uhci_batch->usb_batch->ep->speed == USB_SPEED_LOW;
-        const size_t mps = uhci_batch->usb_batch->ep->max_packet_size;
-        const usb_target_t target = {{
-            uhci_batch->usb_batch->ep->address,
-            uhci_batch->usb_batch->ep->endpoint }};
+            uhci_batch->base.ep->speed == USB_SPEED_LOW;
+        const size_t mps = uhci_batch->base.ep->max_packet_size;
+        const usb_target_t target = uhci_batch->base.ep->target;
 
         /* setup stage */
         td_init(
             &uhci_batch->tds[0], DEFAULT_ERROR_COUNT,
-            uhci_batch->usb_batch->setup_size, 0, false,
+            USB_SETUP_PACKET_SIZE, 0, false,
             low_speed, target, USB_PID_SETUP,
             uhci_transfer_batch_setup_buffer(uhci_batch), &uhci_batch->tds[1]);
@@ -307 +297 @@
         size_t td = 1;
         unsigned toggle = 1;
-        size_t remain_size = uhci_batch->usb_batch->buffer_size;
+        size_t remain_size = uhci_batch->base.buffer_size;
         char *buffer = uhci_transfer_batch_data_buffer(uhci_batch);
 
@@ -337 +327 @@
 }
 
-static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t) =
+static void (*const batch_setup[])(uhci_transfer_batch_t*) =
 {
         [USB_TRANSFER_CONTROL] = batch_control,