Changes in / [474d08e:80fdffe] in mainline

Location:

uspace/drv/uhci-hcd

Files:

• batch.c (modified) (10 diffs)
• batch.h (modified) (1 diff)
• uhci_struct/transfer_descriptor.c (modified) (3 diffs)
• uhci_struct/transfer_descriptor.h (modified) (1 diff)

uspace/drv/uhci-hcd/batch.c ¶

@@ -47 +47 @@
 static int batch_schedule(batch_t *instance);
 
-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_control(
+    batch_t *instance, int data_stage, int status_stage);
+static void batch_data(batch_t *instance, int pid);
 static void batch_call_in(batch_t *instance);
 static void batch_call_out(batch_t *instance);
@@ -84 +84 @@
         }
 
-        instance->tds = malloc32(sizeof(td_t) * instance->packets);
+        instance->tds = malloc32(sizeof(transfer_descriptor_t) * instance->packets);
         if (instance->tds == NULL) {
                 usb_log_error("Failed to allocate transfer descriptors.\n");
@@ -91 +91 @@
                 return NULL;
         }
-        bzero(instance->tds, sizeof(td_t) * instance->packets);
+        bzero(instance->tds, sizeof(transfer_descriptor_t) * instance->packets);
 
         const size_t transport_size = max_packet_size * instance->packets;
@@ -152 +152 @@
         size_t i = 0;
         for (;i < instance->packets; ++i) {
-                if (td_is_active(&instance->tds[i])) {
+                if (transfer_descriptor_is_active(&instance->tds[i])) {
                         return false;
                 }
-
-                instance->error = td_status(&instance->tds[i]);
+                instance->error = transfer_descriptor_status(&instance->tds[i]);
                 if (instance->error != EOK) {
+                        if (i > 0)
+                                instance->transfered_size -= instance->setup_size;
                         usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
-                            instance, i, instance->tds[i].status);
-                        if (i > 0)
-                                goto substract_ret;
+                          instance, i, instance->tds[i].status);
                         return true;
                 }
-
-                instance->transfered_size += td_act_size(&instance->tds[i]);
-                if (td_is_short(&instance->tds[i]))
-                        goto substract_ret;
-        }
-substract_ret:
+                instance->transfered_size +=
+                    transfer_descriptor_actual_size(&instance->tds[i]);
+        }
         instance->transfered_size -= instance->setup_size;
         return true;
@@ -232 +228 @@
 }
 /*----------------------------------------------------------------------------*/
-static void batch_data(batch_t *instance, usb_packet_id pid)
+static void batch_data(batch_t *instance, int pid)
 {
         assert(instance);
@@ -251 +247 @@
                     remain_size : instance->max_packet_size;
 
-                td_init(&instance->tds[packet],
+                transfer_descriptor_init(&instance->tds[packet],
                     DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
                     instance->target, pid, data,
@@ -266 +262 @@
 }
 /*----------------------------------------------------------------------------*/
-static void batch_control(batch_t *instance,
-   usb_packet_id data_stage, usb_packet_id status_stage)
+static void batch_control(
+    batch_t *instance, int data_stage, int status_stage)
 {
         assert(instance);
@@ -274 +270 @@
         int toggle = 0;
         /* setup stage */
-        td_init(instance->tds, DEFAULT_ERROR_COUNT,
+        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
             instance->setup_size, toggle, false, low_speed, instance->target,
             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
@@ -292 +288 @@
                     remain_size : instance->max_packet_size;
 
-                td_init(&instance->tds[packet],
+                transfer_descriptor_init(&instance->tds[packet],
                     DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
                     instance->target, data_stage, data,
@@ -305 +301 @@
         /* status stage */
         assert(packet == instance->packets - 1);
-        td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
+        transfer_descriptor_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
             0, 1, false, low_speed, instance->target, status_stage, NULL, NULL);
 

uspace/drv/uhci-hcd/batch.h ¶

@@ -65 +65 @@
         ddf_fun_t *fun;
         queue_head_t *qh;
-        td_t *tds;
+        transfer_descriptor_t *tds;
         void (*next_step)(struct batch*);
 } batch_t;

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c ¶

@@ -38 +38 @@
 #include "utils/malloc32.h"
 
-void td_init(td_t *instance, int err_count, size_t size, bool toggle, bool iso,
-    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer, td_t *next)
+void transfer_descriptor_init(transfer_descriptor_t *instance,
+    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
+    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
 {
         assert(instance);
-        assert(size < 1024);
-        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN) || (pid == USB_PID_OUT));
 
         instance->next = 0
@@ -50 +49 @@
 
         instance->status = 0
-            | ((err_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
-            | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
-            | (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0)
-            | TD_STATUS_ERROR_ACTIVE;
+          | ((error_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+                | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
+          | TD_STATUS_ERROR_ACTIVE;
 
-        if (pid == USB_PID_IN && !iso) {
-                instance->status |= TD_STATUS_SPD_FLAG;
-        }
-
+        assert(size < 1024);
         instance->device = 0
-            | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
-            | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
-            | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
-            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
-            | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
+                | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
+                | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
+                | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
+                | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
+                | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
 
         instance->buffer_ptr = 0;
@@ -73 +68 @@
 
         usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
-            instance->next, instance->status, instance->device,
-            instance->buffer_ptr, buffer);
+                instance->next, instance->status, instance->device,
+          instance->buffer_ptr, buffer);
 }
 /*----------------------------------------------------------------------------*/
-int td_status(td_t *instance)
+int transfer_descriptor_status(transfer_descriptor_t *instance)
 {
         assert(instance);

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h ¶

@@ -88 +88 @@
          * we don't use it anyway
          */
-} __attribute__((packed)) td_t;
+} __attribute__((packed)) transfer_descriptor_t;
 
 
-void td_init(td_t *instance, int error_count, size_t size, bool toggle, bool iso,
-    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer,
-    td_t *next);
+void transfer_descriptor_init(transfer_descriptor_t *instance,
+    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
+    usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
 
-int td_status(td_t *instance);
+int transfer_descriptor_status(transfer_descriptor_t *instance);
 
-static inline size_t td_act_size(td_t *instance)
+static inline size_t transfer_descriptor_actual_size(
+    transfer_descriptor_t *instance)
 {
         assert(instance);
         return
-            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1)
-            & TD_STATUS_ACTLEN_MASK;
+            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
 }
 
-static inline bool td_is_short(td_t *instance)
-{
-        const size_t act_size = td_act_size(instance);
-        const size_t max_size =
-            ((instance->device >> TD_DEVICE_MAXLEN_POS) + 1)
-            & TD_DEVICE_MAXLEN_MASK;
-        return
-            (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;
-}
-
-static inline bool td_is_active(td_t *instance)
+static inline bool transfer_descriptor_is_active(
+    transfer_descriptor_t *instance)
 {
         assert(instance);