Changeset 89a0485a in mainline

Timestamp:

2011-01-25T20:44:28Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

b00163f

Parents:

7977fa1

Message:

Move function implementations to .c files

Unify error reporting in uhci_in()

Location:

uspace/drv/uhci

Files:

• Makefile (modified) (2 diffs)
• callback.c (added)
• callback.h (modified) (1 diff)
• transfer_list.c (added)
• transfer_list.h (modified) (2 diffs)
• uhci.c (modified) (2 diffs)

uspace/drv/uhci/Makefile

@@ -33 +33 @@
 
 SOURCES = \
+        callback.c \
         iface.c \
         main.c \
@@ -38 +39 @@
         root_hub/port_status.c \
         root_hub/root_hub.c \
+        transfer_list.c \
         uhci.c 
 

uspace/drv/uhci/callback.h

@@ -53 +53 @@
 
 
-static inline int callback_init(callback_t *instance, device_t *dev,
+int callback_init(callback_t *instance, device_t *dev,
   void *buffer, size_t size, usbhc_iface_transfer_in_callback_t func_in,
-  usbhc_iface_transfer_out_callback_t func_out, void *arg)
-{
-        assert(instance);
-        assert(func_in == NULL || func_out == NULL);
-        instance->new_buffer = trans_malloc(size);
-        if (!instance->new_buffer) {
-                uhci_print_error("Failed to allocate device acessible buffer.\n");
-                return ENOMEM;
-        }
+  usbhc_iface_transfer_out_callback_t func_out, void *arg);
 
-        if (func_out)
-                memcpy(instance->new_buffer, buffer, size);
-
-        instance->callback_out = func_out;
-        instance->callback_in = func_in;
-        instance->old_buffer = buffer;
-        instance->buffer_size = size;
-        instance->dev = dev;
-        return EOK;
-}
 #define callback_in_init(instance, dev, buffer, size, func, arg) \
         callback_init(instance, dev, buffer, size, func, NULL, arg)

uspace/drv/uhci/transfer_list.h

@@ -48 +48 @@
 } transfer_list_t;
 
-static inline int transfer_list_init(
-  transfer_list_t *instance, transfer_list_t *next)
-{
-        assert(instance);
-        instance->first = NULL;
-        instance->last = NULL;
-        instance->queue_head = trans_malloc(sizeof(queue_head_t));
-        if (!instance->queue_head) {
-                uhci_print_error("Failed to allocate queue head.\n");
-                return ENOMEM;
-        }
-        instance->queue_head_pa = (uintptr_t)addr_to_phys(instance->queue_head);
-
-        uint32_t next_pa = next ? next->queue_head_pa : 0;
-        queue_head_init(instance->queue_head, next_pa);
-        return EOK;
-}
+int transfer_list_init(transfer_list_t *instance, transfer_list_t *next);
 
 static inline void transfer_list_fini(transfer_list_t *instance)
@@ -73 +57 @@
 }
 
+int transfer_list_append(
+  transfer_list_t *instance, transfer_descriptor_t *transfer);
+
 #endif
 /**

uspace/drv/uhci/uhci.c

@@ -22 +22 @@
         if (!instance)
                 { return ENOMEM; }
-        memset( instance, 0, sizeof(uhci_t) );
+        bzero( instance, sizeof(uhci_t) );
 
         /* init address keeper(libusb) */
@@ -86 +86 @@
                 return ENOTSUP;
 
-        callback_t *job = malloc(sizeof(callback_t));
-        if (job == NULL) {
-                uhci_print_error("Failed to allocate callback structure.\n");
-                return ENOMEM;
-        }
+        transfer_descriptor_t *td = NULL;
+        callback_t *job = NULL;
+        int ret = EOK;
 
-#define CHECK_RET_FREE_JOB(r, message) \
-        if (r != EOK) { \
+#define CHECK_RET_TRANS_FREE_JOB_TD(message) \
+        if (ret != EOK) { \
                 uhci_print_error(message); \
-                callback_fini(job); \
-                trans_free(job); \
-                return r; \
+                if (job) { \
+                        callback_fini(job); \
+                        trans_free(job); \
+                } \
+                if (td) { trans_free(td); } \
+                return ret; \
         } else (void) 0
 
-        int ret = callback_in_init(job, dev, buffer, size, callback, arg);
-        CHECK_RET_FREE_JOB(ret, "Failed to initialize callback structure.\n");
 
-        transfer_descriptor_t *td = trans_malloc(sizeof(transfer_descriptor_t));
-        ret = (td == NULL) ? ENOMEM : EOK;
-        CHECK_RET_FREE_JOB(ret, "Failed to allocate tranfer descriptor.\n");
+        job = malloc(sizeof(callback_t));
+        ret= job ? EOK : ENOMEM;
+        CHECK_RET_TRANS_FREE_JOB_TD("Failed to allocate callback structure.\n");
+
+        ret = callback_in_init(job, dev, buffer, size, callback, arg);
+        CHECK_RET_TRANS_FREE_JOB_TD("Failed to initialize callback structure.\n");
+
+        td = trans_malloc(sizeof(transfer_descriptor_t));
+        ret = td ? ENOMEM : EOK;
+        CHECK_RET_TRANS_FREE_JOB_TD("Failed to allocate tranfer descriptor.\n");
 
         ret = transfer_descriptor_init(td, 3, size, false, target, USB_PID_IN);
-        if (ret != EOK) {
-                uhci_print_error("Failed to initialize transfer descriptor.\n");
-                trans_free(td);
-                trans_free(job);
-                return ret;
-        }
+        CHECK_RET_TRANS_FREE_JOB_TD("Failed to initialize transfer descriptor.\n");
+
         td->callback = job;
 
+        assert(dev);
+        uhci_t *instance = (uhci_t*)dev->driver_data;
+        assert(instance);
 
-        // TODO: add to list
-//      callback(dev, USB_OUTCOME_OK, size, arg);
+        ret = transfer_list_append(&instance->transfers[transfer_type], td);
+        CHECK_RET_TRANS_FREE_JOB_TD("Failed to append transfer descriptor.\n");
 
         return EOK;