Changeset 0892663a in mainline for uspace/drv/bus/usb/uhci

Timestamp:

2018-01-11T04:14:37Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

9848c77

Parents:

bad4a05

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-11 03:59:03)

git-committer:

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

Message:

usbhost: device removal and off/onlining moved into the library

Also, it is just not possible to make generic transfer abortion. So the
current semantics of endpoint unregistering is also aborting the pending
transfer. As it is not yet implemented in XHCI, and the stub in UHCI is
missing the magic, it breaks offlining interrupt devices, such as mouse.

When finishing this commit, I came across the fact we need some more
synchronization above device. Guard can protect internal structures, but
it cannot synchronize multiple calls to offline, or offline & removal
between each other - they both need to allow driver to unregister
endpoints, and as such must release the guard.

Location:

uspace/drv/bus/usb/uhci

Files:

• hc.c (modified) (3 diffs)
• 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

@@ -321 +321 @@
 }
 
-static int device_online(device_t *device)
-{
-        int err;
-        hc_t *instance = bus_to_hc(device->bus);
-        assert(instance);
-
-        /* Allow creation of new endpoints and transfers. */
-        usb_log_info("Device(%d): Going online.", device->address);
-        fibril_mutex_lock(&device->guard);
-        device->online = true;
-        fibril_mutex_unlock(&device->guard);
-
-        if ((err = ddf_fun_online(device->fun))) {
-                return err;
-        }
-
-        return EOK;
-}
-
-static int device_offline(device_t *device)
-{
-        int err;
-        hc_t *instance = bus_to_hc(device->bus);
-        assert(instance);
-
-        /* Tear down all drivers working with the device. */
-        if ((err = ddf_fun_offline(device->fun))) {
-                return err;
-        }
-
-        /* At this point, all drivers are assumed to have already terminated
-         * in a consistent way. The following code just cleans up hanging
-         * transfers if there are any. */
-
-        /* Block creation of new endpoints and transfers. */
-        usb_log_info("Device(%d): Going offline.", device->address);
-        fibril_mutex_lock(&device->guard);
-        device->online = false;
-        fibril_mutex_unlock(&device->guard);
-
-        /* Abort all transfers to all endpoints. */
-        transfer_list_abort_device(&instance->transfers_interrupt, device->address);
-        transfer_list_abort_device(&instance->transfers_control_slow, device->address);
-        transfer_list_abort_device(&instance->transfers_control_full, device->address);
-        transfer_list_abort_device(&instance->transfers_bulk_full, device->address);
-
-        return EOK;
+static void endpoint_unregister(endpoint_t *ep)
+{
+        usb2_bus_ops.endpoint_unregister(ep);
+
+        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);
+        }
+        fibril_mutex_unlock(&ep->guard);
 }
 
@@ -379 +344 @@
         .status = hc_status,
 
+        .endpoint_unregister = endpoint_unregister,
         .endpoint_count_bw = bandwidth_count_usb11,
+
         .batch_create = create_transfer_batch,
         .batch_schedule = hc_schedule,
         .batch_destroy = destroy_transfer_batch,
-
-        .device_online = device_online,
-        .device_offline = device_offline,
 };
 
@@ -522 +486 @@
 static int hc_schedule(usb_transfer_batch_t *batch)
 {
+        assert(batch);
         hc_t *instance = bus_to_hc(endpoint_get_bus(batch->ep));
-        assert(batch);
 
         if (batch->target.address == uhci_rh_get_address(&instance->rh))

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

@@ -194 +194 @@
         while (!list_empty(&instance->batch_list)) {
                 link_t * const current = list_first(&instance->batch_list);
-                uhci_transfer_batch_t *batch =
-                    uhci_transfer_batch_from_link(current);
+                uhci_transfer_batch_t *batch = uhci_transfer_batch_from_link(current);
                 transfer_list_remove_batch(instance, batch);
-                endpoint_abort(batch->base.ep);
-        }
-        fibril_mutex_unlock(&instance->guard);
-}
-
-/** Walk the list and finish all batches of a specified device with EINTR.
- *
- * @param[in] instance List to use.
- * @param[in] address Address of the specified device. Other addresses are skipped.
- */
-void transfer_list_abort_device(transfer_list_t *instance, usb_address_t address)
-{
-        fibril_mutex_lock(&instance->guard);
-        link_t *current = list_first(&instance->batch_list);
-        while (current && current != &instance->batch_list.head && !list_empty(&instance->batch_list)) {
-                link_t * const next = current->next;
-                uhci_transfer_batch_t *batch =
-                    uhci_transfer_batch_from_link(current);
-
-                if (batch->base.target.address == address) {
-                        transfer_list_remove_batch(instance, batch);
-                        endpoint_abort(batch->base.ep);
-                }
-
-                current = next;
         }
         fibril_mutex_unlock(&instance->guard);

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

@@ -63 +63 @@
 void transfer_list_remove_finished(transfer_list_t *instance, list_t *done);
 void transfer_list_abort_all(transfer_list_t *instance);
-void transfer_list_abort_device(transfer_list_t *instance, usb_address_t address);
 
 #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_finish(uhci_transfer_batch_t *);
+void uhci_transfer_batch_abort(uhci_transfer_batch_t *);
 void uhci_transfer_batch_destroy(uhci_transfer_batch_t *);