Changes in uspace/drv/uhci-hcd/batch.c [81dce9f:a963a68] in mainline

File:

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

uspace/drv/uhci-hcd/batch.c

@@ -42 +42 @@
 #include "uhci_hc.h"
 #include "utils/malloc32.h"
-#include "uhci_struct/transfer_descriptor.h"
 
 #define DEFAULT_ERROR_COUNT 3
-
-typedef struct uhci_batch {
-        qh_t *qh;
-        td_t *tds;
-        size_t packets;
-        device_keeper_t *manager;
-} uhci_batch_t;
 
 static void batch_control(batch_t *instance,
     usb_packet_id data_stage, usb_packet_id status_stage);
 static void batch_data(batch_t *instance, usb_packet_id pid);
+static void batch_call_in(batch_t *instance);
+static void batch_call_out(batch_t *instance);
 static void batch_call_in_and_dispose(batch_t *instance);
 static void batch_call_out_and_dispose(batch_t *instance);
@@ -84 +78 @@
 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,
+    usb_speed_t speed, char *buffer, size_t size,
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
@@ -106 +100 @@
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        batch_init(instance, target, transfer_type, speed, max_packet_size,
-            buffer, NULL, buffer_size, NULL, setup_size, func_in,
-            func_out, arg, fun, 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));
-        data->manager = manager;
-        instance->private_data = data;
-
-        data->packets = (buffer_size + max_packet_size - 1) / max_packet_size;
+        bzero(instance, sizeof(batch_t));
+
+        instance->qh = malloc32(sizeof(qh_t));
+        CHECK_NULL_DISPOSE_RETURN(instance->qh,
+            "Failed to allocate batch queue head.\n");
+        qh_init(instance->qh);
+
+        instance->packets = (size + max_packet_size - 1) / max_packet_size;
         if (transfer_type == USB_TRANSFER_CONTROL) {
-                data->packets += 2;
-        }
-
-        data->tds = malloc32(sizeof(td_t) * data->packets);
+                instance->packets += 2;
+        }
+
+        instance->tds = malloc32(sizeof(td_t) * instance->packets);
         CHECK_NULL_DISPOSE_RETURN(
-            data->tds, "Failed to allocate transfer descriptors.\n");
-        bzero(data->tds, sizeof(td_t) * data->packets);
-
-        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);
+            instance->tds, "Failed to allocate transfer descriptors.\n");
+        bzero(instance->tds, sizeof(td_t) * instance->packets);
+
+        if (size > 0) {
+                instance->transport_buffer = malloc32(size);
                 CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
                     "Failed to allocate device accessible buffer.\n");
@@ -147 +130 @@
         }
 
+
+        link_initialize(&instance->link);
+
+        instance->max_packet_size = max_packet_size;
+        instance->target = target;
+        instance->transfer_type = transfer_type;
+        instance->buffer = buffer;
+        instance->buffer_size = size;
+        instance->setup_size = setup_size;
+        instance->fun = fun;
+        instance->arg = arg;
+        instance->speed = speed;
+        instance->manager = manager;
+        instance->callback_out = func_out;
+        instance->callback_in = func_in;
+
+        qh_set_element_td(instance->qh, addr_to_phys(instance->tds));
+
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
@@ -152 +153 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Mark batch as failed and continue with next step.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ */
+void batch_abort(batch_t *instance)
+{
+        assert(instance);
+        instance->error = EIO;
+        instance->next_step(instance);
+}
+/*----------------------------------------------------------------------------*/
 /** Check batch TDs for activity.
  *
@@ -164 +177 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-
         usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
-            instance, data->packets);
+            instance, instance->packets);
         instance->transfered_size = 0;
         size_t i = 0;
-        for (;i < data->packets; ++i) {
-                if (td_is_active(&data->tds[i])) {
+        for (;i < instance->packets; ++i) {
+                if (td_is_active(&instance->tds[i])) {
                         return false;
                 }
 
-                instance->error = td_status(&data->tds[i]);
+                instance->error = td_status(&instance->tds[i]);
                 if (instance->error != EOK) {
                         usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
-                            instance, i, data->tds[i].status);
-                        td_print_status(&data->tds[i]);
-
-                        device_keeper_set_toggle(data->manager,
-                            instance->target, td_toggle(&data->tds[i]));
+                            instance, i, instance->tds[i].status);
+                        td_print_status(&instance->tds[i]);
+
+                        device_keeper_set_toggle(instance->manager,
+                            instance->target, td_toggle(&instance->tds[i]));
                         if (i > 0)
                                 goto substract_ret;
@@ -189 +199 @@
                 }
 
-                instance->transfered_size += td_act_size(&data->tds[i]);
-                if (td_is_short(&data->tds[i]))
+                instance->transfered_size += td_act_size(&instance->tds[i]);
+                if (td_is_short(&instance->tds[i]))
                         goto substract_ret;
         }
@@ -302 +312 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-
         const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = device_keeper_get_toggle(data->manager, instance->target);
+        int toggle =
+            device_keeper_get_toggle(instance->manager, instance->target);
         assert(toggle == 0 || toggle == 1);
 
@@ -312 +320 @@
         size_t remain_size = instance->buffer_size;
         while (remain_size > 0) {
-                char *trans_data =
+                char *data =
                     instance->transport_buffer + instance->buffer_size
                     - remain_size;
@@ -320 +328 @@
                     remain_size : instance->max_packet_size;
 
-                td_t *next_packet = (packet + 1 < data->packets)
-                    ? &data->tds[packet + 1] : NULL;
-
-                assert(packet < data->packets);
+                td_t *next_packet = (packet + 1 < instance->packets)
+                    ? &instance->tds[packet + 1] : NULL;
+
+                assert(packet < instance->packets);
                 assert(packet_size <= remain_size);
 
                 td_init(
-                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
-                    toggle, false, low_speed, instance->target, pid, trans_data,
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, pid, data,
                     next_packet);
 
@@ -336 +344 @@
                 ++packet;
         }
-        td_set_ioc(&data->tds[packet - 1]);
-        device_keeper_set_toggle(data->manager, instance->target, toggle);
+        td_set_ioc(&instance->tds[packet - 1]);
+        device_keeper_set_toggle(instance->manager, instance->target, toggle);
 }
 /*----------------------------------------------------------------------------*/
@@ -355 +363 @@
 {
         assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-        assert(data->packets >= 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, toggle, false,
-            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
-            &data->tds[1]);
+        td_init(instance->tds, DEFAULT_ERROR_COUNT,
+            instance->setup_size, toggle, false, low_speed, instance->target,
+            USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
 
         /* data stage */
@@ -371 +375 @@
         size_t remain_size = instance->buffer_size;
         while (remain_size > 0) {
-                char *control_data =
+                char *data =
                     instance->transport_buffer + instance->buffer_size
                     - remain_size;
@@ -382 +386 @@
 
                 td_init(
-                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
                     toggle, false, low_speed, instance->target, data_stage,
-                    control_data, &data->tds[packet + 1]);
+                    data, &instance->tds[packet + 1]);
 
                 ++packet;
-                assert(packet < data->packets);
+                assert(packet < instance->packets);
                 assert(packet_size <= remain_size);
                 remain_size -= packet_size;
@@ -393 +397 @@
 
         /* status stage */
-        assert(packet == data->packets - 1);
-
-        td_init(
-            &data->tds[packet], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-            instance->target, status_stage, NULL, NULL);
-        td_set_ioc(&data->tds[packet]);
-
+        assert(packet == instance->packets - 1);
+        td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
+            0, 1, false, low_speed, instance->target, status_stage, NULL, NULL);
+
+        td_set_ioc(&instance->tds[packet]);
         usb_log_debug2("Control last TD status: %x.\n",
-            data->tds[packet].status);
-}
-/*----------------------------------------------------------------------------*/
-qh_t * batch_qh(batch_t *instance)
-{
-        assert(instance);
-        uhci_batch_t *data = instance->private_data;
-        assert(data);
-        return data->qh;
+            instance->tds[packet].status);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare data, get error status and call callback in.
+ *
+ * @param[in] instance Batch structure to use.
+ * Copies data from transport buffer, and calls callback with appropriate
+ * parameters.
+ */
+void batch_call_in(batch_t *instance)
+{
+        assert(instance);
+        assert(instance->callback_in);
+
+        /* We are data in, we need data */
+        memcpy(instance->buffer, instance->transport_buffer,
+            instance->buffer_size);
+
+        int err = instance->error;
+        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
+            instance, instance->transfer_type, str_error(err), err,
+            instance->transfered_size);
+
+        instance->callback_in(
+            instance->fun, err, instance->transfered_size, instance->arg);
+}
+/*----------------------------------------------------------------------------*/
+/** Get error status and call callback out.
+ *
+ * @param[in] instance Batch structure to use.
+ */
+void batch_call_out(batch_t *instance)
+{
+        assert(instance);
+        assert(instance->callback_out);
+
+        int err = instance->error;
+        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
+            instance, instance->transfer_type, str_error(err), err);
+        instance->callback_out(instance->fun,
+            err, instance->arg);
 }
 /*----------------------------------------------------------------------------*/
@@ -441 +475 @@
 {
         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->tds);
+        free32(instance->qh);
         free32(instance->setup_buffer);
         free32(instance->transport_buffer);
-        free(data);
         free(instance);
 }