Changeset 2ab6875 in mainline

Timestamp:

2011-03-07T11:18:21Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

bcaefe3

Parents:

4b4e163

Message:

Further refactoring

Location:

uspace/drv/uhci-hcd

Files:

• batch.c (modified) (3 diffs)
• transfer_list.c (modified) (1 diff)
• transfer_list.h (modified) (1 diff)
• uhci_struct/queue_head.h (modified) (2 diffs)

uspace/drv/uhci-hcd/batch.c

@@ -69 +69 @@
         assert(func_in != NULL || func_out != NULL);
 
+#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
+        if (ptr == NULL) { \
+                usb_log_error(message); \
+                if (instance) { \
+                        batch_dispose(instance); \
+                } \
+                return NULL; \
+        } else (void)0
+
         batch_t *instance = malloc(sizeof(batch_t));
-        if (instance == NULL) {
-                usb_log_error("Failed to allocate batch instance.\n");
-                return NULL;
-        }
-
-        instance->qh = queue_head_get();
-        if (instance->qh == NULL) {
-                usb_log_error("Failed to allocate queue head.\n");
-                free(instance);
-                return NULL;
-        }
+        CHECK_NULL_DISPOSE_RETURN(instance,
+            "Failed to allocate batch instance.\n");
+        bzero(instance, sizeof(batch_t));
+
+        instance->qh = malloc32(sizeof(queue_head_t));
+        CHECK_NULL_DISPOSE_RETURN(instance->qh,
+            "Failed to allocate batch queue head.\n");
+        queue_head_init(instance->qh);
 
         instance->packets = (size + max_packet_size - 1) / max_packet_size;
@@ -88 +94 @@
 
         instance->tds = malloc32(sizeof(td_t) * instance->packets);
-        if (instance->tds == NULL) {
-                usb_log_error("Failed to allocate transfer descriptors.\n");
-                queue_head_dispose(instance->qh);
-                free(instance);
-                return NULL;
-        }
+        CHECK_NULL_DISPOSE_RETURN(
+            instance->tds, "Failed to allocate transfer descriptors.\n");
         bzero(instance->tds, sizeof(td_t) * instance->packets);
 
         const size_t transport_size = max_packet_size * instance->packets;
 
-        instance->transport_buffer =
-           (size > 0) ? malloc32(transport_size) : NULL;
-
-        if ((size > 0) && (instance->transport_buffer == NULL)) {
-                usb_log_error("Failed to allocate device accessible buffer.\n");
-                queue_head_dispose(instance->qh);
-                free32(instance->tds);
-                free(instance);
-                return NULL;
-        }
-
-        instance->setup_buffer = setup_buffer ? malloc32(setup_size) : NULL;
-        if ((setup_size > 0) && (instance->setup_buffer == NULL)) {
-                usb_log_error("Failed to allocate device accessible setup buffer.\n");
-                queue_head_dispose(instance->qh);
-                free32(instance->tds);
-                free32(instance->transport_buffer);
-                free(instance);
-                return NULL;
-        }
-        if (instance->setup_buffer) {
+        if (size > 0) {
+                instance->transport_buffer = malloc32(transport_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);
         }
 
+
+        link_initialize(&instance->link);
+
         instance->max_packet_size = max_packet_size;
-
-        link_initialize(&instance->link);
-
         instance->target = target;
         instance->transfer_type = transfer_type;
-
-        if (func_out)
-                instance->callback_out = func_out;
-        if (func_in)
-                instance->callback_in = func_in;
-
         instance->buffer = buffer;
         instance->buffer_size = size;
@@ -142 +127 @@
         instance->manager = manager;
 
-        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
+        if (func_out)
+                instance->callback_out = func_out;
+        if (func_in)
+                instance->callback_in = func_in;
+
+        queue_head_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);

uspace/drv/uhci-hcd/transfer_list.c

@@ -43 +43 @@
         instance->next = NULL;
         instance->name = name;
-        instance->queue_head = queue_head_get();
+        instance->queue_head = malloc32(sizeof(queue_head_t));
         if (!instance->queue_head) {
                 usb_log_error("Failed to allocate queue head.\n");
                 return ENOMEM;
         }
-        instance->queue_head_pa = (uintptr_t)addr_to_phys(instance->queue_head);
+        queue_head_init(instance->queue_head);
+        instance->queue_head_pa = addr_to_phys(instance->queue_head);
 
         queue_head_init(instance->queue_head);

uspace/drv/uhci-hcd/transfer_list.h

@@ -58 +58 @@
 {
         assert(instance);
-        queue_head_dispose(instance->queue_head);
+        free32(instance->queue_head);
 }
 void transfer_list_remove_finished(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci_struct/queue_head.h

@@ -71 +71 @@
 }
 
-static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa)
+static inline void queue_head_set_element_td(queue_head_t *instance, uint32_t pa)
 {
         if (pa) {
@@ -78 +78 @@
 }
 
-static inline queue_head_t * queue_head_get() {
-        queue_head_t *ret = malloc32(sizeof(queue_head_t));
-        if (ret)
-                queue_head_init(ret);
-        return ret;
-}
-
-static inline void queue_head_dispose(queue_head_t *head)
-        { free32(head); }
-
-
 #endif
 /**