Changeset 6832245 in mainline for uspace/drv/bus/usb/ehci

Timestamp:

2017-12-14T23:01:57Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

837d53d

Parents:

bd05140

git-author:

Ondřej Hlavatý <aearsis@…> (2017-12-14 23:01:54)

git-committer:

Ondřej Hlavatý <aearsis@…> (2017-12-14 23:01:57)

Message:

usbhost bus: refactor the bus ops

This way, method names better represent the entity it is working with.
Their semantics was shifted a bit.

Regarding the tree of structures:

bus ← device ← endpoint ← batch

Previously, devices were kept in DDF function nodes, and endpoints had
pointer to the bus and device. Now, devices have pointer to bus,
endpoints don't.

Pointer to hcd_t in bus is WIP, and will be removed.

Location:

uspace/drv/bus/usb/ehci

Files:

• ehci_bus.c (modified) (6 diffs)
• ehci_bus.h (modified) (1 diff)
• hc.c (modified) (2 diffs)
• hc.h (modified) (1 diff)
• main.c (modified) (1 diff)

uspace/drv/bus/usb/ehci/ehci_bus.c

@@ -79 +79 @@
 /** Creates new hcd endpoint representation.
  */
-static endpoint_t *ehci_endpoint_create(bus_t *bus)
+static endpoint_t *ehci_endpoint_create(device_t *dev, const usb_endpoint_desc_t *desc)
 {
-        assert(bus);
+        assert(dev);
 
         ehci_endpoint_t *ehci_ep = malloc(sizeof(ehci_endpoint_t));
@@ -87 +87 @@
                 return NULL;
 
-        endpoint_init(&ehci_ep->base, bus);
+        endpoint_init(&ehci_ep->base, dev, desc);
+
+        // TODO: extract USB2 information from desc
 
         ehci_ep->qh = malloc32(sizeof(qh_t));
@@ -114 +116 @@
 
 
-static int ehci_register_ep(bus_t *bus_base, device_t *dev, endpoint_t *ep, const usb_endpoint_desc_t *desc)
+static int ehci_register_ep(endpoint_t *ep)
 {
+        bus_t *bus_base = endpoint_get_bus(ep);
         ehci_bus_t *bus = (ehci_bus_t *) bus_base;
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
+        assert(fibril_mutex_is_locked(&bus_base->guard));
 
-        // TODO utilize desc->usb2
-
-        const int err = bus->parent_ops.register_endpoint(bus_base, dev, ep, desc);
+        const int err = usb2_bus_ops.endpoint_register(ep);
         if (err)
                 return err;
@@ -131 +133 @@
 }
 
-static int ehci_unregister_ep(bus_t *bus_base, endpoint_t *ep)
+static int ehci_unregister_ep(endpoint_t *ep)
 {
+        bus_t *bus_base = endpoint_get_bus(ep);
         ehci_bus_t *bus = (ehci_bus_t *) bus_base;
         assert(bus);
         assert(ep);
 
-        const int err = bus->parent_ops.unregister_endpoint(bus_base, ep);
+        const int err = usb2_bus_ops.endpoint_unregister(ep);
         if (err)
                 return err;
@@ -145 +148 @@
 }
 
-static usb_transfer_batch_t *ehci_bus_create_batch(bus_t *bus, endpoint_t *ep)
+static usb_transfer_batch_t *ehci_create_batch(endpoint_t *ep)
 {
         ehci_transfer_batch_t *batch = ehci_transfer_batch_create(ep);
@@ -151 +154 @@
 }
 
-static void ehci_bus_destroy_batch(usb_transfer_batch_t *batch)
+static void ehci_destroy_batch(usb_transfer_batch_t *batch)
 {
         ehci_transfer_batch_destroy(ehci_transfer_batch_get(batch));
 }
 
-int ehci_bus_init(ehci_bus_t *bus, hc_t *hc)
+static const bus_ops_t ehci_bus_ops = {
+        .parent = &usb2_bus_ops,
+
+        .endpoint_destroy = ehci_endpoint_destroy,
+        .endpoint_create = ehci_endpoint_create,
+        .endpoint_register = ehci_register_ep,
+        .endpoint_unregister = ehci_unregister_ep,
+        .endpoint_set_toggle = ehci_ep_toggle_set,
+        .endpoint_get_toggle = ehci_ep_toggle_get,
+        .endpoint_count_bw = bandwidth_count_usb11,
+        .batch_create = ehci_create_batch,
+        .batch_destroy = ehci_destroy_batch,
+};
+
+int ehci_bus_init(ehci_bus_t *bus, hcd_t *hcd, hc_t *hc)
 {
         assert(hc);
         assert(bus);
 
-        // FIXME: Implement the USB2 bw counting.
-        usb2_bus_init(&bus->base, BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
+        usb2_bus_t *usb2_bus = (usb2_bus_t *) bus;
+        bus_t *bus_base = (bus_t *) bus;
 
-        bus_ops_t *ops = &bus->base.base.ops;
-        bus->parent_ops = *ops;
-        ops->create_endpoint = ehci_endpoint_create;
-        ops->destroy_endpoint = ehci_endpoint_destroy;
-        ops->endpoint_set_toggle = ehci_ep_toggle_set;
-        ops->endpoint_get_toggle = ehci_ep_toggle_get;
-
-        ops->register_endpoint = ehci_register_ep;
-        ops->unregister_endpoint = ehci_unregister_ep;
-
-        ops->create_batch = ehci_bus_create_batch;
-        ops->destroy_batch = ehci_bus_destroy_batch;
+        usb2_bus_init(usb2_bus, hcd, BANDWIDTH_AVAILABLE_USB11);
+        bus_base->ops = &ehci_bus_ops;
 
         bus->hc = hc;

uspace/drv/bus/usb/ehci/ehci_bus.h

@@ -59 +59 @@
         usb2_bus_t base;
         hc_t *hc;
-
-        /* Stored original ops from base, they are called in our handlers */
-        bus_ops_t parent_ops;
 } ehci_bus_t;
 
-int ehci_bus_init(ehci_bus_t *, hc_t *);
+void ehci_bus_prepare_ops(void);
+
+int ehci_bus_init(ehci_bus_t *, hcd_t *, hc_t *);
 
 /** Get and convert assigned ehci_endpoint_t structure

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

@@ -149 +149 @@
  * @return Error code
  */
-int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res)
+int hc_init(hc_t *instance, hcd_t *hcd, const hw_res_list_parsed_t *hw_res)
 {
         assert(instance);
@@ -190 +190 @@
             &instance->rh, instance->caps, instance->registers, "ehci rh");
 
-        ehci_bus_init(&instance->bus, instance);
+        ehci_bus_init(&instance->bus, hcd, instance);
         return EOK;
 }

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

@@ -85 +85 @@
 } hc_t;
 
-int hc_init(hc_t *instance, const hw_res_list_parsed_t *hw_res);
+int hc_init(hc_t *instance, hcd_t *hcd, const hw_res_list_parsed_t *hw_res);
 int hc_start(hc_t *instance, bool interrupts);
 void hc_fini(hc_t *instance);

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

@@ -81 +81 @@
                 return ENOMEM;
 
-        const int ret = hc_init(instance, res);
+        const int ret = hc_init(instance, hcd, res);
         if (ret == EOK) {
                 hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops, &instance->bus.base.base);