Changeset 929599a8 in mainline

Timestamp:

2018-01-11T13:30:37Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

4ed803f1

Parents:

351113f

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-11 13:30:31)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-01-11 13:30:37)

Message:

uhci: implemented transfer abort

Location:

uspace/drv/bus/usb/uhci

Files:

• hc.c (modified) (4 diffs)
• hc.h (modified) (1 diff)
• transfer_list.c (modified) (1 diff)
• transfer_list.h (modified) (1 diff)
• uhci_batch.c (modified) (1 diff)
• uhci_batch.h (modified) (1 diff)

uspace/drv/bus/usb/uhci/hc.c

@@ -53 +53 @@
 
 #include "uhci_batch.h"
+#include "transfer_list.h"
 #include "hc.h"
 
@@ -323 +324 @@
 static void endpoint_unregister(endpoint_t *ep)
 {
+        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
         usb2_bus_ops.endpoint_unregister(ep);
+
+        uhci_transfer_batch_t *batch = NULL;
 
         fibril_mutex_lock(&ep->guard);
         if (ep->active_batch) {
-                uhci_transfer_batch_t *ub = uhci_transfer_batch_get(ep->active_batch);
-                uhci_transfer_batch_abort(ub);
-
-                assert(ep->active_batch == NULL);
+                batch = uhci_transfer_batch_get(ep->active_batch);
+
+                transfer_list_t *list = hc->transfers[ep->device->speed][ep->transfer_type];
+                assert(list);
+
+                fibril_mutex_lock(&list->guard);
+                transfer_list_remove_batch(list, batch);
+                fibril_mutex_unlock(&list->guard);
+
+                endpoint_wait_timeout_locked(ep, 2000);
+
+                batch = uhci_transfer_batch_get(ep->active_batch);
+                if (ep->active_batch) {
+                        endpoint_deactivate_locked(ep);
+                }
         }
         fibril_mutex_unlock(&ep->guard);
+
+        if (batch) {
+                batch->base.error = EINTR;
+                batch->base.transfered_size = 0;
+                usb_transfer_batch_finish(&batch->base);
+        }
 }
 
@@ -486 +507 @@
 static int hc_schedule(usb_transfer_batch_t *batch)
 {
-        assert(batch);
-        hc_t *instance = bus_to_hc(endpoint_get_bus(batch->ep));
-
-        if (batch->target.address == uhci_rh_get_address(&instance->rh))
-                return uhci_rh_schedule(&instance->rh, batch);
-
-        uhci_transfer_batch_t *uhci_batch = (uhci_transfer_batch_t *) batch;
-        if (!uhci_batch) {
-                usb_log_error("Failed to create UHCI transfer structures.\n");
-                return ENOMEM;
-        }
+        uhci_transfer_batch_t *uhci_batch = uhci_transfer_batch_get(batch);
+        endpoint_t *ep = batch->ep;
+        hc_t *hc = bus_to_hc(endpoint_get_bus(ep));
+
+        if (batch->target.address == uhci_rh_get_address(&hc->rh))
+                return uhci_rh_schedule(&hc->rh, batch);
+
 
         const int err = uhci_transfer_batch_prepare(uhci_batch);
@@ -502 +519 @@
                 return err;
 
-        transfer_list_t *list =
-            instance->transfers[batch->ep->device->speed][batch->ep->transfer_type];
+        transfer_list_t *list = hc->transfers[ep->device->speed][ep->transfer_type];
         assert(list);
         transfer_list_add_batch(list, uhci_batch);
+
+        return EOK;
+}
+
+int hc_unschedule_batch(usb_transfer_batch_t *batch)
+{
 
         return EOK;

uspace/drv/bus/usb/uhci/hc.h

@@ -139 +139 @@
 }
 
+int hc_unschedule_batch(usb_transfer_batch_t *);
+
 extern int hc_add(hc_device_t *, const hw_res_list_parsed_t *);
 extern int hc_gen_irq_code(irq_code_t *, hc_device_t *, const hw_res_list_parsed_t *);

uspace/drv/bus/usb/uhci/transfer_list.c

@@ -45 +45 @@
 #include "transfer_list.h"
 
-static void transfer_list_remove_batch(
-    transfer_list_t *instance, uhci_transfer_batch_t *uhci_batch);
-
 /** Initialize transfer list structures.
  *

uspace/drv/bus/usb/uhci/transfer_list.h

@@ -56 +56 @@
 } transfer_list_t;
 
-void transfer_list_fini(transfer_list_t *instance);
-int transfer_list_init(transfer_list_t *instance, const char *name);
-void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
-void transfer_list_add_batch(
-    transfer_list_t *instance, uhci_transfer_batch_t *batch);
-void transfer_list_remove_finished(transfer_list_t *instance, list_t *done);
-void transfer_list_abort_all(transfer_list_t *instance);
+void transfer_list_fini(transfer_list_t *);
+int transfer_list_init(transfer_list_t *, const char *);
+void transfer_list_set_next(transfer_list_t *, transfer_list_t *);
+void transfer_list_add_batch(transfer_list_t *, uhci_transfer_batch_t *);
+void transfer_list_remove_batch(transfer_list_t *, uhci_transfer_batch_t *);
+void transfer_list_remove_finished(transfer_list_t *, list_t *);
+void transfer_list_abort_all(transfer_list_t *);
 
 #endif

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -64 +64 @@
 }
 
-/**
- * Abort a transfer that is currently running.
- * Call with endpoint guard locked.
- */
-void uhci_transfer_batch_abort(uhci_transfer_batch_t *batch)
-{
-        assert(batch);
-
-        endpoint_t *ep = batch->base.ep;
-        assert(ep);
-        assert(fibril_mutex_is_locked(&ep->guard));
-        assert(ep->active_batch == &batch->base);
-
-        /*
-         * TODO: Do some magic here to remove the batch from schedule.
-         */
-
-        /*
-         * Wait for 2 frames. If the transfer was being processed,
-         * it shall be marked as finished already after 1ms.
-         */
-        endpoint_wait_timeout_locked(ep, 2000);
-        if (ep->active_batch != &batch->base)
-                return;
-
-        /*
-         * Now, we can be sure the transfer is not scheduled,
-         * and as such will not be completed. We now own the batch.
-         */
-        endpoint_deactivate_locked(ep);
-
-        /* Leave the critical section for finishing the batch. */
-        fibril_mutex_unlock(&ep->guard);
-
-        batch->base.error = EINTR;
-        batch->base.transfered_size = 0;
-        usb_transfer_batch_finish(&batch->base);
-
-        fibril_mutex_lock(&ep->guard);
-}
-
 /** Allocate memory and initialize internal data structure.
  *

uspace/drv/bus/usb/uhci/uhci_batch.h

@@ -70 +70 @@
 int uhci_transfer_batch_prepare(uhci_transfer_batch_t *);
 bool uhci_transfer_batch_check_completed(uhci_transfer_batch_t *);
-void uhci_transfer_batch_abort(uhci_transfer_batch_t *);
 void uhci_transfer_batch_destroy(uhci_transfer_batch_t *);