Changes in / [4b39af4:8b74997f] in mainline

Location:

uspace

Files:

• drv/ohci/root_hub.c (modified) (2 diffs)
• drv/uhci-hcd/hc.c (modified) (2 diffs)
• drv/uhci-hcd/transfer_list.c (modified) (3 diffs)
• drv/uhci-hcd/transfers.c (added)
• lib/usb/include/usb/host/batch.h (modified) (1 diff)
• lib/usb/include/usb/host/device_keeper.h (modified) (1 diff)
• lib/usb/include/usb/host/endpoint.h (modified) (3 diffs)
• lib/usb/src/host/batch.c (modified) (2 diffs)
• lib/usb/src/host/device_keeper.c (modified) (1 diff)
• lib/usb/src/host/endpoint.c (modified) (3 diffs)

uspace/drv/ohci/root_hub.c

@@ -249 +249 @@
                 opResult = EINVAL;
         }
-        usb_transfer_batch_finish_error(request, opResult);
+        usb_transfer_batch_finish(request, opResult);
         return EOK;
 }
@@ -863 +863 @@
 }
 
+
+
+
 /**
  * @}

uspace/drv/uhci-hcd/hc.c

@@ -332 +332 @@
             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);
+        }
         transfer_list_add_batch(list, batch);
 
@@ -369 +373 @@
                         usb_transfer_batch_t *batch =
                             list_get_instance(item, usb_transfer_batch_t, link);
-                        usb_transfer_batch_finish(batch);
+                        switch (batch->transfer_type)
+                        {
+                        case USB_TRANSFER_CONTROL:
+                                usb_device_keeper_release_control(
+                                    &instance->manager, batch->target);
+                                break;
+                        case USB_TRANSFER_INTERRUPT:
+                        case USB_TRANSFER_ISOCHRONOUS: {
+/*
+                                int ret = bandwidth_free(&instance->bandwidth,
+                                    batch->target.address,
+                                    batch->target.endpoint,
+                                    batch->direction);
+                                if (ret != EOK)
+                                        usb_log_warning("Failed(%d) to free "
+                                            "reserved bw: %s.\n", ret,
+                                            str_error(ret));
+*/
+                                }
+                        default:
+                                break;
+                        }
+                        batch->next_step(batch);
                 }
         }

uspace/drv/uhci-hcd/transfer_list.c

@@ -132 +132 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Create list for finished batches.
- *
- * @param[in] instance List to use.
- * @param[in] done list to fill
+/** Check list for finished batches.
+ *
+ * @param[in] instance List to use.
+ * @return Error code
+ *
+ * Creates a local list of finished batches and calls next_step on each and
+ * every one. This is safer because next_step may theoretically access
+ * this transfer list leading to the deadlock if its done inline.
  */
 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
@@ -157 +161 @@
         }
         fibril_mutex_unlock(&instance->guard);
+
 }
 /*----------------------------------------------------------------------------*/
@@ -171 +176 @@
                     list_get_instance(current, usb_transfer_batch_t, link);
                 transfer_list_remove_batch(instance, batch);
-                usb_transfer_batch_finish_error(batch, EIO);
+                usb_transfer_batch_finish(batch, EIO);
         }
         fibril_mutex_unlock(&instance->guard);

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

@@ -92 +92 @@
 void usb_transfer_batch_call_in(usb_transfer_batch_t *instance);
 void usb_transfer_batch_call_out(usb_transfer_batch_t *instance);
-void usb_transfer_batch_finish(usb_transfer_batch_t *instance);
-
-static inline void usb_transfer_batch_finish_error(
-    usb_transfer_batch_t *instance, int error)
-{
-        assert(instance);
-        instance->error = error;
-        usb_transfer_batch_finish(instance);
-}
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error);
 
 #endif

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

@@ -96 +96 @@
 usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     usb_address_t address);
+
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_target_t target);
+
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_target_t target);
+
 #endif
 /**

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

@@ -39 +39 @@
 #include <bool.h>
 #include <adt/list.h>
-#include <fibril_synch.h>
-
 #include <usb/usb.h>
 
@@ -50 +48 @@
         usb_speed_t speed;
         size_t max_packet_size;
+        bool active;
         unsigned toggle:1;
-        fibril_mutex_t guard;
-        fibril_condvar_t avail;
-        volatile bool active;
         link_t same_device_eps;
 } endpoint_t;
@@ -62 +58 @@
 
 void endpoint_destroy(endpoint_t *instance);
-
-void endpoint_use(endpoint_t *instance);
-
-void endpoint_release(endpoint_t *instance);
 
 int endpoint_toggle_get(endpoint_t *instance);

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

@@ -79 +79 @@
         instance->error = EOK;
         instance->ep = ep;
-        endpoint_use(instance->ep);
 }
 /*----------------------------------------------------------------------------*/
@@ -87 +86 @@
  *
  */
-void usb_transfer_batch_finish(usb_transfer_batch_t *instance)
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error)
 {
         assert(instance);
-        assert(instance->ep);
-        endpoint_release(instance->ep);
+        instance->error = error;
         instance->next_step(instance);
 }

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

@@ -264 +264 @@
         return instance->devices[address].speed;
 }
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_use_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[target.address].control_used & ep) {
+                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
+        instance->devices[target.address].control_used |= ep;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        assert((instance->devices[target.address].control_used & ep) != 0);
+        instance->devices[target.address].control_used &= ~ep;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->change);
+}
 /**
  * @}

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

@@ -34 +34 @@
  */
 
-#include <assert.h>
 #include <errno.h>
 #include <usb/host/endpoint.h>
@@ -50 +49 @@
         instance->max_packet_size = max_packet_size;
         instance->toggle = 0;
-        instance->active = false;
-        fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->avail);
         link_initialize(&instance->same_device_eps);
         return EOK;
@@ -60 +56 @@
 {
         assert(instance);
-        assert(!instance->active);
         list_remove(&instance->same_device_eps);
         free(instance);
-}
-/*----------------------------------------------------------------------------*/
-void endpoint_use(endpoint_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->active)
-                fibril_condvar_wait(&instance->avail, &instance->guard);
-        instance->active = true;
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-void endpoint_release(endpoint_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->active = false;
-        fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->avail);
 }
 /*----------------------------------------------------------------------------*/