Changeset b8d453ec in mainline

Timestamp:

2011-03-25T17:18:46Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

9a2923d

Parents:

da3dafc (diff), 095b2017 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Fixes issue #122.

New allocator on not cached memory.
Only one control transfer per device as allowed

Files:

• kernel/generic/src/mm/as.c (modified) (1 diff)
• uspace/drv/uhci-hcd/Makefile (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (6 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (5 diffs)
• uspace/drv/uhci-hcd/utils/slab.c (added)
• uspace/drv/uhci-hcd/utils/slab.h (added)
• uspace/lib/c/generic/malloc.c (modified) (1 diff)
• uspace/lib/usb/include/usb/host/device_keeper.h (modified) (3 diffs)
• uspace/lib/usb/src/host/device_keeper.c (modified) (4 diffs)

kernel/generic/src/mm/as.c

@@ -1949 +1949 @@
 sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
 {
-        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
+        if (as_area_create(AS, flags, size, address,
             AS_AREA_ATTR_NONE, &anon_backend, NULL))
                 return (sysarg_t) address;

uspace/drv/uhci-hcd/Makefile

@@ -40 +40 @@
         root_hub.c \
         hw_struct/transfer_descriptor.c \
+        utils/slab.c \
         pci.c \
         batch.c

uspace/drv/uhci-hcd/hc.c

@@ -223 +223 @@
         ret = instance ? EOK : ENOMEM;
         CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
-        usb_log_debug("Initialized frame list.\n");
+        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
 
         /* Set all frames to point to the first queue head */
@@ -336 +336 @@
             instance->transfers[batch->speed][batch->transfer_type];
         assert(list);
+        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                usb_device_keeper_use_control(
+                    &instance->manager, batch->target.address);
+        }
         transfer_list_add_batch(list, batch);
 
@@ -357 +361 @@
         /* Lower 2 bits are transaction error and transaction complete */
         if (status & 0x3) {
-                transfer_list_remove_finished(&instance->transfers_interrupt);
-                transfer_list_remove_finished(&instance->transfers_control_slow);
-                transfer_list_remove_finished(&instance->transfers_control_full);
-                transfer_list_remove_finished(&instance->transfers_bulk_full);
+                LIST_INITIALIZE(done);
+                transfer_list_remove_finished(
+                    &instance->transfers_interrupt, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_slow, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_full, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_bulk_full, &done);
+
+                while (!list_empty(&done)) {
+                        link_t *item = done.next;
+                        list_remove(item);
+                        usb_transfer_batch_t *batch =
+                            list_get_instance(item, usb_transfer_batch_t, link);
+                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                                usb_device_keeper_release_control(
+                                    &instance->manager, batch->target.address);
+                        }
+                        batch->next_step(batch);
+                }
         }
         /* bits 4 and 5 indicate hc error */

uspace/drv/uhci-hcd/transfer_list.c

@@ -58 +58 @@
         }
         instance->queue_head_pa = addr_to_phys(instance->queue_head);
+        usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
+            name, instance->queue_head, instance->queue_head_pa);
 
         qh_init(instance->queue_head);
@@ -118 +120 @@
         qh_set_next_qh(last_qh, pa);
 
+        asm volatile ("": : :"memory");
+
         /* Add to the driver list */
         list_append(&batch->link, &instance->batch_list);
@@ -137 +141 @@
  * this transfer list leading to the deadlock if its done inline.
  */
-void transfer_list_remove_finished(transfer_list_t *instance)
-{
-        assert(instance);
-
-        LIST_INITIALIZE(done);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
+{
+        assert(instance);
+        assert(done);
 
         fibril_mutex_lock(&instance->guard);
@@ -153 +156 @@
                         /* Save for post-processing */
                         transfer_list_remove_batch(instance, batch);
-                        list_append(current, &done);
+                        list_append(current, done);
                 }
                 current = next;
@@ -159 +162 @@
         fibril_mutex_unlock(&instance->guard);
 
-        while (!list_empty(&done)) {
-                link_t *item = done.next;
-                list_remove(item);
-                usb_transfer_batch_t *batch =
-                    list_get_instance(item, usb_transfer_batch_t, link);
-                batch->next_step(batch);
-        }
 }
 /*----------------------------------------------------------------------------*/
@@ -222 +218 @@
                 qpos = "NOT FIRST";
         }
+        asm volatile ("": : :"memory");
         /* Remove from the batch list */
         list_remove(&batch->link);

uspace/drv/uhci-hcd/transfer_list.h

@@ -67 +67 @@
 void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
 
-void transfer_list_remove_finished(transfer_list_t *instance);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
 
 void transfer_list_abort_all(transfer_list_t *instance);

uspace/drv/uhci-hcd/utils/malloc32.h

@@ -40 +40 @@
 #include <as.h>
 
+#include "slab.h"
+
 #define UHCI_STRCUTURES_ALIGNMENT 16
 #define UHCI_REQUIRED_PAGE_SIZE 4096
+
 
 /** Get physical address translation
@@ -54 +57 @@
 
         uintptr_t result;
-        int ret = as_get_physical_mapping(addr, &result);
+        const int ret = as_get_physical_mapping(addr, &result);
+        assert(ret == EOK);
 
         if (ret != EOK)
@@ -66 +70 @@
  * @return Address of the alligned and big enough memory place, NULL on failure.
  */
-static inline void * malloc32(size_t size)
-        { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
+static inline void * malloc32(size_t size) {
+        if (size <= SLAB_ELEMENT_SIZE)
+                return slab_malloc_g();
+        assert(false);
+        return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
+}
 /*----------------------------------------------------------------------------*/
 /** Physical mallocator simulator
@@ -73 +81 @@
  * @param[in] addr Address of the place allocated by malloc32
  */
-static inline void free32(void *addr)
-        { if (addr) free(addr); }
+static inline void free32(void *addr) {
+        if (!addr)
+                return;
+        if (slab_in_range_g(addr))
+                return slab_free_g(addr);
+        free(addr);
+}
 /*----------------------------------------------------------------------------*/
 /** Create 4KB page mapping
@@ -82 +95 @@
 static inline void * get_page(void)
 {
-        void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
-        assert(free_address);
+        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
+        assert(free_address); /* TODO: remove this assert */
         if (free_address == 0)
                 return NULL;
-        void* ret =
-          as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
+        void *ret = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
                   AS_AREA_READ | AS_AREA_WRITE);
         if (ret != free_address)

uspace/lib/c/generic/malloc.c

@@ -240 +240 @@
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         
-        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
+        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
         if (astart == (void *) -1)
                 return false;

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -51 +51 @@
         usb_speed_t speed;
         bool occupied;
+        bool control_used;
         uint16_t toggle_status[2];
         devman_handle_t handle;
@@ -61 +62 @@
         struct usb_device_info devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
-        fibril_condvar_t default_address_occupied;
+        fibril_condvar_t change;
         usb_address_t last_address;
 } usb_device_keeper_t;
@@ -97 +98 @@
     usb_address_t address);
 
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
 #endif
 /**

uspace/lib/usb/src/host/device_keeper.c

@@ -49 +49 @@
         assert(instance);
         fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->default_address_occupied);
+        fibril_condvar_initialize(&instance->change);
         instance->last_address = 0;
         unsigned i = 0;
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
+                instance->devices[i].control_used = false;
                 instance->devices[i].handle = 0;
                 instance->devices[i].toggle_status[0] = 0;
@@ -71 +72 @@
         fibril_mutex_lock(&instance->guard);
         while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
-                fibril_condvar_wait(&instance->default_address_occupied,
-                    &instance->guard);
+                fibril_condvar_wait(&instance->change, &instance->guard);
         }
         instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
@@ -90 +90 @@
         instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
         fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->default_address_occupied);
+        fibril_condvar_signal(&instance->change);
 }
 /*----------------------------------------------------------------------------*/
@@ -309 +309 @@
         return instance->devices[address].speed;
 }
-
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[address].control_used) {
+                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
+        instance->devices[address].control_used = true;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->devices[address].control_used = false;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->change);
+}
 /**
  * @}