Changeset 32fb6bce in mainline for uspace/drv/bus/usb/vhc

Timestamp:

2017-12-18T22:50:21Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

7f70d1c

Parents:

1ea0bbf

git-author:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:04:50)

git-committer:

Ondřej Hlavatý <aearsis@…> (2017-12-18 22:50:21)

Message:

usbhost: refactoring

This commit moves interrupt, status and schedule to bus
operations. Then the purpose of hcd_t is better defined, and split into
hc_driver_t and hc_device_t. hc_driver_t is used to wrap driver
implementation by the library (similar to how usb_driver_t is used to
wrap usb device drivers). hc_device_t is used as a parent for hc_t
inside drivers, and is allocated inside the DDF device node.

To support these changes, some local identifiers were renamed, some
functions were moved and/or renamed and their arguments changed. The
most notable one being hcd_send_batch → bus_device_send_batch.

Location:

uspace/drv/bus/usb/vhc

Files:

• main.c (modified) (2 diffs)
• transfer.c (modified) (5 diffs)
• vhcd.h (modified) (3 diffs)

uspace/drv/bus/usb/vhc/main.c

@@ -69 +69 @@
                 return ret;
         }
-        vhc_init(vhc, dev_to_hcd(dev));
         return EOK;
 }
 
-hcd_ops_t vhc_hc_ops = {
-        .schedule = vhc_schedule,
-};
-
 static int vhc_dev_add(ddf_dev_t *dev)
 {
+        /* Initialize generic structures */
+        int ret = hcd_ddf_setup_hc(dev, sizeof(vhc_data_t));
+        if (ret != EOK) {
+                usb_log_error("Failed to init HCD structures: %s.\n",
+                   str_error(ret));
+                return ret;
+        }
+        vhc_data_t *vhc = ddf_dev_data_get(dev);
+        vhc_init(vhc);
+
+        hc_device_setup(&vhc->base, (bus_t *) &vhc->bus);
+
         /* Initialize virtual structure */
         ddf_fun_t *ctl_fun = NULL;
-        int ret = vhc_control_node(dev, &ctl_fun);
+        ret = vhc_control_node(dev, &ctl_fun);
         if (ret != EOK) {
                 usb_log_error("Failed to setup control node.\n");
                 return ret;
         }
-        vhc_data_t *data = ddf_fun_data_get(ctl_fun);
-
-        /* Initialize generic structures */
-        ret = hcd_ddf_setup_hc(dev);
-        if (ret != EOK) {
-                usb_log_error("Failed to init HCD structures: %s.\n",
-                   str_error(ret));
-                ddf_fun_destroy(ctl_fun);
-                return ret;
-        }
-
-        hcd_set_implementation(dev_to_hcd(dev), data, &vhc_hc_ops, &data->bus.base);
 
         /* Add virtual hub device */
-        ret = vhc_virtdev_plug_hub(data, &data->hub, NULL, 0);
+        ret = vhc_virtdev_plug_hub(vhc, &vhc->hub, NULL, 0);
         if (ret != EOK) {
                 usb_log_error("Failed to plug root hub: %s.\n", str_error(ret));
@@ -111 +106 @@
          * needs to be ready at this time.
          */
-        ret = hcd_setup_virtual_root_hub(dev_to_hcd(dev), dev);
+        ret = hcd_setup_virtual_root_hub(&vhc->base);
         if (ret != EOK) {
                 usb_log_error("Failed to init VHC root hub: %s\n",

uspace/drv/bus/usb/vhc/transfer.c

@@ -40 +40 @@
 static bool is_set_address_transfer(vhc_transfer_t *transfer)
 {
-        if (transfer->batch->target.endpoint != 0) {
-                return false;
-        }
-        if (transfer->batch->ep->transfer_type != USB_TRANSFER_CONTROL) {
-                return false;
-        }
-        if (transfer->batch->dir != USB_DIRECTION_OUT) {
+        if (transfer->batch.target.endpoint != 0) {
+                return false;
+        }
+        if (transfer->batch.ep->transfer_type != USB_TRANSFER_CONTROL) {
+                return false;
+        }
+        if (transfer->batch.dir != USB_DIRECTION_OUT) {
                 return false;
         }
         const usb_device_request_setup_packet_t *setup
-                = &transfer->batch->setup.packet;
+                = &transfer->batch.setup.packet;
         if (setup->request_type != 0) {
                 return false;
@@ -150 +150 @@
         assert(outcome != ENAK);
         assert(transfer);
-        assert(transfer->batch);
-        transfer->batch->error = outcome;
-        transfer->batch->transfered_size = data_transfer_size;
-        usb_transfer_batch_finish(transfer->batch);
+        transfer->batch.error = outcome;
+        transfer->batch.transfered_size = data_transfer_size;
+        usb_transfer_batch_finish(&transfer->batch);
         free(transfer);
+}
+
+static usb_transfer_batch_t *batch_create(endpoint_t *ep)
+{
+        vhc_transfer_t *transfer = calloc(1, sizeof(vhc_transfer_t));
+        usb_transfer_batch_init(&transfer->batch, ep);
+        link_initialize(&transfer->link);
+        return &transfer->batch;
 }
 
 static const bus_ops_t vhc_bus_ops = {
         .parent = &usb2_bus_ops,
+
         .endpoint_count_bw = bandwidth_count_usb11,
+        .batch_create = batch_create,
+        .batch_schedule = vhc_schedule,
 };
 
-int vhc_init(vhc_data_t *instance, hcd_t *hcd)
+int vhc_init(vhc_data_t *instance)
 {
         assert(instance);
         list_initialize(&instance->devices);
         fibril_mutex_initialize(&instance->guard);
-        usb2_bus_init(&instance->bus, hcd, BANDWIDTH_AVAILABLE_USB11);
+        usb2_bus_init(&instance->bus, BANDWIDTH_AVAILABLE_USB11);
         instance->bus.base.ops = &vhc_bus_ops;
-        instance->magic = 0xDEADBEEF;
         return virthub_init(&instance->hub, "root hub");
 }
 
-int vhc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
-{
-        assert(hcd);
+int vhc_schedule(usb_transfer_batch_t *batch)
+{
         assert(batch);
-        vhc_data_t *vhc = hcd_get_driver_data(hcd);
+        vhc_transfer_t *transfer = (vhc_transfer_t *) batch;
+        vhc_data_t *vhc = bus_to_vhc(endpoint_get_bus(batch->ep));
         assert(vhc);
-
-        vhc_transfer_t *transfer = malloc(sizeof(vhc_transfer_t));
-        if (!transfer)
-                return ENOMEM;
-        link_initialize(&transfer->link);
-        transfer->batch = batch;
 
         fibril_mutex_lock(&vhc->guard);
@@ -192 +195 @@
         list_foreach(vhc->devices, link, vhc_virtdev_t, dev) {
                 fibril_mutex_lock(&dev->guard);
-                if (dev->address == transfer->batch->target.address) {
+                if (dev->address == transfer->batch.target.address) {
                         if (!targets) {
                                 list_append(&transfer->link, &dev->transfer_queue);
@@ -227 +230 @@
                 size_t data_transfer_size = 0;
                 if (dev->dev_sess) {
-                        rc = process_transfer_remote(transfer->batch,
+                        rc = process_transfer_remote(&transfer->batch,
                             dev->dev_sess, &data_transfer_size);
                 } else if (dev->dev_local != NULL) {
-                        rc = process_transfer_local(transfer->batch,
+                        rc = process_transfer_local(&transfer->batch,
                             dev->dev_local, &data_transfer_size);
                 } else {
@@ -244 +247 @@
                         if (is_set_address_transfer(transfer)) {
                                 usb_device_request_setup_packet_t *setup =
-                                    (void*) transfer->batch->setup.buffer;
+                                    (void*) transfer->batch.setup.buffer;
                                 dev->address = setup->value;
                                 usb_log_debug2("Address changed to %d\n",

uspace/drv/bus/usb/vhc/vhcd.h

@@ -39 +39 @@
 #include <usbvirt/device.h>
 #include <async.h>
+#include <macros.h>
 
 #include <usb/host/hcd.h>
 #include <usb/host/usb2_bus.h>
+#include <usb/host/usb_transfer_batch.h>
 
 #define NAME "vhc"
@@ -56 +58 @@
 
 typedef struct {
-        uint32_t magic;
+        hc_device_t base;
+
+        usb2_bus_t bus;
+        ddf_fun_t *virtual_fun;
         list_t devices;
         fibril_mutex_t guard;
         usbvirt_device_t hub;
-        usb2_bus_t bus;
 } vhc_data_t;
 
 typedef struct {
+        usb_transfer_batch_t batch;
         link_t link;
-        usb_transfer_batch_t *batch;
 } vhc_transfer_t;
+
+static inline vhc_data_t *hcd_to_vhc(hc_device_t *hcd)
+{
+        assert(hcd);
+        return (vhc_data_t *) hcd;
+}
+
+static inline vhc_data_t *bus_to_vhc(bus_t *bus)
+{
+        assert(bus);
+        return member_to_inst(bus, vhc_data_t, bus);
+}
 
 void on_client_close(ddf_fun_t *fun);
@@ -77 +93 @@
 void vhc_virtdev_unplug(vhc_data_t *, uintptr_t);
 
-int vhc_init(vhc_data_t *instance, hcd_t *);
-int vhc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
+int vhc_init(vhc_data_t *);
+int vhc_schedule(usb_transfer_batch_t *);
 int vhc_transfer_queue_processor(void *arg);