Changes in uspace/drv/ohci/batch.c [f567bcf:f1be95c8] in mainline

File:

• uspace/drv/ohci/batch.c (modified) (9 diffs)

uspace/drv/ohci/batch.c

@@ -40 +40 @@
 #include "batch.h"
 #include "utils/malloc32.h"
-
+#include "hw_struct/endpoint_descriptor.h"
+#include "hw_struct/transfer_descriptor.h"
+
+typedef struct ohci_batch {
+        ed_t *ed;
+        td_t *tds;
+        size_t td_count;
+} ohci_batch_t;
+
+static void batch_control(usb_transfer_batch_t *instance,
+    usb_direction_t data_dir, usb_direction_t status_dir);
 static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
 static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
 
 #define DEFAULT_ERROR_COUNT 3
-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,
+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,
-                usb_device_keeper_t *manager
-                )
+    usbhc_iface_transfer_out_callback_t func_out, void *arg)
 {
 #define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
@@ -73 +72 @@
         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, NULL, NULL);
+        usb_target_t target =
+            { .address = ep->address, .endpoint = ep->endpoint };
+        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);
+
+        ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
+        CHECK_NULL_DISPOSE_RETURN(data, "Failed to allocate batch data.\n");
+        bzero(data, sizeof(ohci_batch_t));
+        instance->private_data = data;
+
+        /* we needs + 1 transfer descriptor as the last one won't be executed */
+        data->td_count = 1 +
+            ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
+        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+                data->td_count += 2;
+        }
+
+        data->tds = malloc32(sizeof(td_t) * data->td_count);
+        CHECK_NULL_DISPOSE_RETURN(data->tds,
+            "Failed to allocate transfer descriptors.\n");
+        bzero(data->tds, sizeof(td_t) * data->td_count);
+
+        data->ed = malloc32(sizeof(ed_t));
+        CHECK_NULL_DISPOSE_RETURN(data->ed,
+            "Failed to allocate endpoint descriptor.\n");
 
         if (buffer_size > 0) {
@@ -90 +112 @@
         }
 
-
         return instance;
 }
@@ -97 +118 @@
 {
         assert(instance);
+        ohci_batch_t *data = instance->private_data;
+        assert(data);
+        free32(data->ed);
+        free32(data->tds);
+        free32(instance->setup_buffer);
         free32(instance->transport_buffer);
-        free32(instance->setup_buffer);
+        free(data);
         free(instance);
+}
+/*----------------------------------------------------------------------------*/
+bool batch_is_complete(usb_transfer_batch_t *instance)
+{
+        assert(instance);
+        ohci_batch_t *data = instance->private_data;
+        assert(data);
+        size_t tds = data->td_count - 1;
+        usb_log_debug2("Batch(%p) checking %d td(s) for completion.\n",
+            instance, tds);
+        size_t i = 0;
+        for (; i < tds; ++i) {
+                if (!td_is_finished(&data->tds[i]))
+                        return false;
+                instance->error = td_error(&data->tds[i]);
+                /* FIXME: calculate real transfered size */
+                instance->transfered_size = instance->buffer_size;
+                if (instance->error != EOK) {
+                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
+                            instance, i, data->tds[i].status);
+                        return true;
+//                      endpoint_toggle_set(instance->ep,
+                }
+        }
+        return true;
 }
 /*----------------------------------------------------------------------------*/
@@ -109 +160 @@
             instance->buffer_size);
         instance->next_step = batch_call_out_and_dispose;
-        /* TODO: implement */
+        batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
 }
@@ -117 +168 @@
         assert(instance);
         instance->next_step = batch_call_in_and_dispose;
-        /* TODO: implement */
+        batch_control(instance, USB_DIRECTION_IN, USB_DIRECTION_OUT);
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
 }
@@ -124 +175 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_IN;
+        assert(instance->direction == USB_DIRECTION_IN);
         instance->next_step = batch_call_in_and_dispose;
         /* TODO: implement */
@@ -133 +184 @@
 {
         assert(instance);
-        instance->direction = USB_DIRECTION_OUT;
+        assert(instance->direction == USB_DIRECTION_OUT);
         /* We are data out, we are supposed to provide data */
         memcpy(instance->transport_buffer, instance->buffer,
@@ -160 +211 @@
 }
 /*----------------------------------------------------------------------------*/
+ed_t * batch_ed(usb_transfer_batch_t *instance)
+{
+        assert(instance);
+        ohci_batch_t *data = instance->private_data;
+        assert(data);
+        return data->ed;
+}
+/*----------------------------------------------------------------------------*/
+void batch_control(usb_transfer_batch_t *instance,
+    usb_direction_t data_dir, usb_direction_t status_dir)
+{
+        assert(instance);
+        ohci_batch_t *data = instance->private_data;
+        assert(data);
+        ed_init(data->ed, instance->ep);
+        ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
+        usb_log_debug("Created ED: %x:%x:%x:%x.\n", data->ed->status,
+            data->ed->td_tail, data->ed->td_head, data->ed->next);
+        int toggle = 0;
+        /* setup stage */
+        td_init(&data->tds[0], USB_DIRECTION_BOTH, instance->setup_buffer,
+                instance->setup_size, toggle);
+        td_set_next(&data->tds[0], &data->tds[1]);
+        usb_log_debug("Created SETUP TD: %x:%x:%x:%x.\n", data->tds[0].status,
+            data->tds[0].cbp, data->tds[0].next, data->tds[0].be);
+
+        /* data stage */
+        size_t td_current = 1;
+        size_t remain_size = instance->buffer_size;
+        char *transfer_buffer = instance->transport_buffer;
+        while (remain_size > 0) {
+                size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
+                    OHCI_TD_MAX_TRANSFER : remain_size;
+                toggle = 1 - toggle;
+
+                td_init(&data->tds[td_current], data_dir, transfer_buffer,
+                    transfer_size, toggle);
+                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
+                usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
+                    data->tds[td_current].status, data->tds[td_current].cbp,
+                    data->tds[td_current].next, data->tds[td_current].be);
+
+                transfer_buffer += transfer_size;
+                remain_size -= transfer_size;
+                assert(td_current < data->td_count - 2);
+                ++td_current;
+        }
+
+        /* status stage */
+        assert(td_current == data->td_count - 2);
+        td_init(&data->tds[td_current], status_dir, NULL, 0, 1);
+        usb_log_debug("Created STATUS TD: %x:%x:%x:%x.\n",
+            data->tds[td_current].status, data->tds[td_current].cbp,
+            data->tds[td_current].next, data->tds[td_current].be);
+}
+/*----------------------------------------------------------------------------*/
 /** Helper function calls callback and correctly disposes of batch structure.
  *