Changeset d369b3b in mainline for uspace/drv

Timestamp:

2018-01-25T02:05: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:

296d22fc

Parents:

b357377

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-25 01:52:13)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-01-25 02:05:57)

Message:

usb2_bus: no longer be a bus

As the number of implemented functions got to 3, it's not so beneficial
to inherit usb2 bus to get the functionality. Overall, four trampolines
needed to be added, which is an acceptable number.

Now, the usb2_bus has become a usb2_bus_helper, to be used as
a companion to the common bus.

This is mostly a preparation to remove the runtime binding of the bus
methods.

Location:

uspace/drv/bus/usb

Files:

• ehci/ehci_bus.c (modified) (5 diffs)
• ehci/ehci_bus.h (modified) (1 diff)
• ohci/ohci_bus.c (modified) (5 diffs)
• ohci/ohci_bus.h (modified) (1 diff)
• uhci/hc.c (modified) (4 diffs)
• uhci/hc.h (modified) (1 diff)
• vhc/transfer.c (modified) (2 diffs)
• vhc/vhcd.h (modified) (1 diff)

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

@@ -57 +57 @@
 }
 
+static int ehci_device_enumerate(device_t *dev)
+{
+        ehci_bus_t *bus = (ehci_bus_t *) dev->bus;
+        return usb2_bus_device_enumerate(&bus->helper, dev);
+}
 
 /** Creates new hcd endpoint representation.
@@ -101 +106 @@
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
 
-        const int err = usb2_bus_ops.endpoint_register(ep);
+        const int err = usb2_bus_endpoint_register(&bus->helper, ep);
         if (err)
                 return err;
@@ -119 +124 @@
         assert(ep);
 
-        usb2_bus_ops.endpoint_unregister(ep);
+        usb2_bus_endpoint_unregister(&bus->helper, ep);
         hc_dequeue_endpoint(hc, ep);
         /*
@@ -154 +159 @@
 
 static const bus_ops_t ehci_bus_ops = {
-        .parent = &usb2_bus_ops,
-
         .interrupt = ehci_hc_interrupt,
         .status = ehci_hc_status,
+
+        .device_enumerate = ehci_device_enumerate,
 
         .endpoint_destroy = ehci_endpoint_destroy,
@@ -174 +179 @@
         assert(bus);
 
-        usb2_bus_t *usb2_bus = (usb2_bus_t *) bus;
         bus_t *bus_base = (bus_t *) bus;
+        bus_init(bus_base, sizeof(device_t));
+        bus_base->ops = &ehci_bus_ops;
 
-        usb2_bus_init(usb2_bus, &bandwidth_accounting_usb2);
-        bus_base->ops = &ehci_bus_ops;
+        usb2_bus_helper_init(&bus->helper, &bandwidth_accounting_usb2);
 
         bus->hc = hc;

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

@@ -64 +64 @@
 
 typedef struct {
-        usb2_bus_t base;
+        bus_t base;
+        usb2_bus_helper_t helper;
         hc_t *hc;
 } ehci_bus_t;

uspace/drv/bus/usb/ohci/ohci_bus.c

@@ -57 +57 @@
 }
 
+static int ohci_device_enumerate(device_t *dev)
+{
+        ohci_bus_t *bus = (ohci_bus_t *) dev->bus;
+        return usb2_bus_device_enumerate(&bus->helper, dev);
+}
+
 /** Creates new hcd endpoint representation.
  */
@@ -109 +115 @@
         ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
 
-        const int err = usb2_bus_ops.endpoint_register(ep);
+        const int err = usb2_bus_endpoint_register(&bus->helper, ep);
         if (err)
                 return err;
@@ -126 +132 @@
         assert(ep);
 
-        usb2_bus_ops.endpoint_unregister(ep);
+        usb2_bus_endpoint_unregister(&bus->helper, ep);
         hc_dequeue_endpoint(bus->hc, ep);
 
@@ -162 +168 @@
 
 static const bus_ops_t ohci_bus_ops = {
-        .parent = &usb2_bus_ops,
-
         .interrupt = ohci_hc_interrupt,
         .status = ohci_hc_status,
+
+        .device_enumerate = ohci_device_enumerate,
 
         .endpoint_destroy = ohci_endpoint_destroy,
@@ -183 +189 @@
         assert(bus);
 
-        usb2_bus_t *usb2_bus = (usb2_bus_t *) bus;
         bus_t *bus_base = (bus_t *) bus;
-
-        usb2_bus_init(usb2_bus, &bandwidth_accounting_usb11);
+        bus_init(bus_base, sizeof(device_t));
         bus_base->ops = &ohci_bus_ops;
+
+        usb2_bus_helper_init(&bus->helper, &bandwidth_accounting_usb11);
 
         bus->hc = hc;

uspace/drv/bus/usb/ohci/ohci_bus.h

@@ -60 +60 @@
 
 typedef struct {
-        usb2_bus_t base;
+        bus_t base;
+        usb2_bus_helper_t helper;
         hc_t *hc;
 } ohci_bus_t;

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

@@ -329 +329 @@
         hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
 
-        const int err = usb2_bus_ops.endpoint_register(ep);
+        const int err = usb2_bus_endpoint_register(&hc->bus_helper, ep);
         if (err)
                 return err;
@@ -350 +350 @@
 {
         hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
-        usb2_bus_ops.endpoint_unregister(ep);
+        usb2_bus_endpoint_unregister(&hc->bus_helper, ep);
 
         // Check for the roothub, as it does not schedule into lists
@@ -406 +406 @@
 }
 
+static int device_enumerate(device_t *dev)
+{
+        hc_t * const hc = bus_to_hc(dev->bus);
+        return usb2_bus_device_enumerate(&hc->bus_helper, dev);
+}
+
 static int hc_status(bus_t *, uint32_t *);
 static int hc_schedule(usb_transfer_batch_t *);
 
 static const bus_ops_t uhci_bus_ops = {
-        .parent = &usb2_bus_ops,
-
         .interrupt = hc_interrupt,
         .status = hc_status,
+
+        .device_enumerate = device_enumerate,
 
         .endpoint_create = endpoint_create,
@@ -438 +444 @@
         assert(instance);
 
-        usb2_bus_init(&instance->bus, &bandwidth_accounting_usb11);
-
-        bus_t *bus = (bus_t *) &instance->bus;
-        bus->ops = &uhci_bus_ops;
-
-        hc_device_setup(&instance->base, bus);
+        usb2_bus_helper_init(&instance->bus_helper, &bandwidth_accounting_usb11);
+
+        bus_init(&instance->bus, sizeof(device_t));
+        instance->bus.ops = &uhci_bus_ops;
+
+        hc_device_setup(&instance->base, &instance->bus);
 
         /* Init USB frame list page */

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

@@ -104 +104 @@
 
         uhci_rh_t rh;
-        usb2_bus_t bus;
+        bus_t bus;
+        usb2_bus_helper_t bus_helper;
+
         /** Addresses of I/O registers */
         uhci_regs_t *registers;

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

@@ -163 +163 @@
 }
 
+static int device_enumerate(device_t *device)
+{
+        vhc_data_t *vhc = bus_to_vhc(device->bus);
+        return usb2_bus_device_enumerate(&vhc->bus_helper, device);
+}
+
+static int endpoint_register(endpoint_t *endpoint)
+{
+        vhc_data_t *vhc = bus_to_vhc(endpoint->device->bus);
+        return usb2_bus_endpoint_register(&vhc->bus_helper, endpoint);
+}
+
+static void endpoint_unregister(endpoint_t *endpoint)
+{
+        vhc_data_t *vhc = bus_to_vhc(endpoint->device->bus);
+        usb2_bus_endpoint_unregister(&vhc->bus_helper, endpoint);
+
+        // TODO: abort transfer?
+}
+
 static const bus_ops_t vhc_bus_ops = {
-        .parent = &usb2_bus_ops,
-
         .batch_create = batch_create,
         .batch_schedule = vhc_schedule,
+
+        .device_enumerate = device_enumerate,
+        .endpoint_register = endpoint_register,
+        .endpoint_unregister = endpoint_unregister,
 };
 
@@ -175 +197 @@
         list_initialize(&instance->devices);
         fibril_mutex_initialize(&instance->guard);
-        usb2_bus_init(&instance->bus, &bandwidth_accounting_usb11);
-        instance->bus.base.ops = &vhc_bus_ops;
+        bus_init(&instance->bus, sizeof(device_t));
+        usb2_bus_helper_init(&instance->bus_helper, &bandwidth_accounting_usb11);
+        instance->bus.ops = &vhc_bus_ops;
         return virthub_init(&instance->hub, "root hub");
 }

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

@@ -60 +60 @@
         hc_device_t base;
 
-        usb2_bus_t bus;
+        bus_t bus;
+        usb2_bus_helper_t bus_helper;
+
         ddf_fun_t *virtual_fun;
         list_t devices;