Changeset 6832245 in mainline for uspace/lib/usbhost

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/lib/usbhost

Files:

• include/usb/host/bandwidth.h (modified) (1 diff)
• include/usb/host/bus.h (modified) (2 diffs)
• include/usb/host/ddf_helpers.h (modified) (1 diff)
• include/usb/host/endpoint.h (modified) (4 diffs)
• include/usb/host/usb2_bus.h (modified) (2 diffs)
• src/bandwidth.c (modified) (2 diffs)
• src/bus.c (modified) (9 diffs)
• src/ddf_helpers.c (modified) (15 diffs)
• src/endpoint.c (modified) (5 diffs)
• src/hcd.c (modified) (2 diffs)
• src/usb2_bus.c (modified) (16 diffs)
• src/usb_transfer_batch.c (modified) (4 diffs)

uspace/lib/usbhost/include/usb/host/bandwidth.h

@@ -51 +51 @@
 typedef struct endpoint endpoint_t;
 
-extern size_t bandwidth_count_usb11(endpoint_t *, size_t);
+extern ssize_t bandwidth_count_usb11(endpoint_t *, size_t);
 
-extern size_t bandwidth_count_usb20(endpoint_t *, size_t);
+extern ssize_t bandwidth_count_usb20(endpoint_t *, size_t);
 
 #endif

uspace/lib/usbhost/include/usb/host/bus.h

@@ -77 +77 @@
         usb_address_t address;
 
+        /* Managing bus */
+        bus_t *bus;
+
         /* This structure is meant to be extended by overriding. */
 } device_t;
 
-typedef struct {
-        int (*enumerate_device)(bus_t *, hcd_t *, device_t *);
-        int (*remove_device)(bus_t *, hcd_t *, device_t *);
+typedef struct bus_ops bus_ops_t;
 
-        int (*online_device)(bus_t *, hcd_t *, device_t *);                     /**< Optional */
-        int (*offline_device)(bus_t *, hcd_t *, device_t *);                    /**< Optional */
+/**
+ * Operations structure serving as an interface of hc driver for the library
+ * (and the rest of the system).
+ */
+struct bus_ops {
+        /* Undefined operations will be delegated to parent ops */
+        const bus_ops_t *parent;
 
-        /* The following operations are protected by a bus guard. */
-        endpoint_t *(*create_endpoint)(bus_t *);
-        int (*register_endpoint)(bus_t *, device_t *, endpoint_t *, const usb_endpoint_desc_t *);
-        int (*unregister_endpoint)(bus_t *, endpoint_t *);
-        endpoint_t *(*find_endpoint)(bus_t *, device_t*, usb_target_t, usb_direction_t);
-        void (*destroy_endpoint)(endpoint_t *);                 /**< Optional */
+        /* Global operations on the bus */
+        int (*reserve_default_address)(bus_t *, usb_speed_t);
+        int (*release_default_address)(bus_t *);
+        int (*reset_toggle)(bus_t *, usb_target_t, toggle_reset_mode_t);
+
+        /* Operations on device */
+        int (*device_enumerate)(device_t *);
+        int (*device_remove)(device_t *);
+        int (*device_online)(device_t *);                       /**< Optional */
+        int (*device_offline)(device_t *);                      /**< Optional */
+        endpoint_t *(*device_find_endpoint)(device_t*, usb_target_t, usb_direction_t);
+        endpoint_t *(*endpoint_create)(device_t *, const usb_endpoint_desc_t *);
+
+        /* Operations on endpoint */
+        int (*endpoint_register)(endpoint_t *);
+        int (*endpoint_unregister)(endpoint_t *);
+        void (*endpoint_destroy)(endpoint_t *);                 /**< Optional */
         bool (*endpoint_get_toggle)(endpoint_t *);              /**< Optional */
         void (*endpoint_set_toggle)(endpoint_t *, bool);        /**< Optional */
+        ssize_t (*endpoint_count_bw) (endpoint_t *, size_t);
+        usb_transfer_batch_t *(*batch_create)(endpoint_t *);    /**< Optional */
 
-        int (*reserve_default_address)(bus_t *, usb_speed_t);
-        int (*release_default_address)(bus_t *);
+        /* Operations on batch */
+        void (*batch_destroy)(usb_transfer_batch_t *);  /**< Optional */
+};
 
-        int (*reset_toggle)(bus_t *, usb_target_t, toggle_reset_mode_t);
-
-        size_t (*count_bw) (endpoint_t *, size_t);
-
-        usb_transfer_batch_t *(*create_batch)(bus_t *, endpoint_t *); /**< Optional */
-        void (*destroy_batch)(usb_transfer_batch_t *);  /**< Optional */
-} bus_ops_t;
+/**
+ * Use this macro to lookup virtual function.
+ */
+#define BUS_OPS_LOOKUP(start, fn) ({ bus_ops_t const * ops = (start); while (ops && ops->fn == NULL) ops = ops->parent; ops; })
 
 /** Endpoint management structure */
@@ -112 +129 @@
         fibril_mutex_t guard;
 
+        /* TODO: get rid of this one. */
+        hcd_t *hcd;
+
         size_t device_size;
 
         /* Do not call directly, ops are synchronized. */
-        bus_ops_t ops;
+        const bus_ops_t *ops;
 
         /* This structure is meant to be extended by overriding. */
 } bus_t;
 
-void bus_init(bus_t *, size_t);
-int device_init(device_t *);
+void bus_init(bus_t *, hcd_t *, size_t);
+int bus_device_init(device_t *, bus_t *);
 
-int device_set_default_name(device_t *);
+int bus_device_set_default_name(device_t *);
 
-int bus_enumerate_device(bus_t *, hcd_t *, device_t *);
-int bus_remove_device(bus_t *, hcd_t *, device_t *);
+int bus_device_enumerate(device_t *);
+int bus_device_remove(device_t *);
 
-int bus_online_device(bus_t *, hcd_t *, device_t *);
-int bus_offline_device(bus_t *, hcd_t *, device_t *);
+int bus_device_online(device_t *);
+int bus_device_offline(device_t *);
 
-int bus_add_endpoint(bus_t *, device_t *, const usb_endpoint_desc_t *, endpoint_t **);
-endpoint_t *bus_find_endpoint(bus_t *, device_t *, usb_target_t, usb_direction_t);
-int bus_remove_endpoint(bus_t *, endpoint_t *);
-
-size_t bus_count_bw(endpoint_t *, size_t);
+int bus_endpoint_add(device_t *, const usb_endpoint_desc_t *, endpoint_t **);
+endpoint_t *bus_find_endpoint(device_t *, usb_target_t, usb_direction_t);
+int bus_endpoint_remove(endpoint_t *);
 
 int bus_reserve_default_address(bus_t *, usb_speed_t);

uspace/lib/usbhost/include/usb/host/ddf_helpers.h

@@ -81 +81 @@
 int hcd_setup_virtual_root_hub(hcd_t *, ddf_dev_t *);
 
-device_t *hcd_ddf_device_create(ddf_dev_t *, size_t);
+device_t *hcd_ddf_device_create(ddf_dev_t *, bus_t *);
 void hcd_ddf_device_destroy(device_t *);
-int hcd_ddf_device_explore(hcd_t *, device_t *);
+int hcd_ddf_device_explore(device_t *);
 int hcd_ddf_device_online(ddf_fun_t *);
 int hcd_ddf_device_offline(ddf_fun_t *);

uspace/lib/usbhost/include/usb/host/endpoint.h

@@ -45 +45 @@
 #include <stdbool.h>
 #include <usb/usb.h>
+#include <usb/host/bus.h>
 
 typedef struct bus bus_t;
@@ -54 +55 @@
         /** Part of linked list. */
         link_t link;
-        /** Managing bus */
-        bus_t *bus;
+        /** USB device */
+        device_t *device;
         /** Reference count. */
         atomic_t refcnt;
-        /** USB device */
-        device_t *device;
         /** Enpoint number */
         usb_endpoint_t endpoint;
@@ -84 +83 @@
 } endpoint_t;
 
-extern void endpoint_init(endpoint_t *, bus_t *);
+extern void endpoint_init(endpoint_t *, device_t *, const usb_endpoint_desc_t *);
 
 extern void endpoint_add_ref(endpoint_t *);
@@ -103 +102 @@
 void endpoint_abort(endpoint_t *);
 
+/* Manage the toggle bit */
 extern int endpoint_toggle_get(endpoint_t *);
 extern void endpoint_toggle_set(endpoint_t *, bool);
+
+/* Calculate bandwidth */
+ssize_t endpoint_count_bw(endpoint_t *, size_t);
+
+static inline bus_t *endpoint_get_bus(endpoint_t *ep)
+{
+        return ep->device->bus;
+}
 
 /** list_get_instance wrapper.

uspace/lib/usbhost/include/usb/host/usb2_bus.h

@@ -46 +46 @@
 typedef struct endpoint endpoint_t;
 
-typedef size_t (*count_bw_func_t)(endpoint_t *, size_t);
-
 /** Endpoint management structure */
 typedef struct usb2_bus {
@@ -66 +64 @@
 } usb2_bus_t;
 
-extern int usb2_bus_init(usb2_bus_t *, size_t, count_bw_func_t);
+extern const bus_ops_t usb2_bus_ops;
+
+extern int usb2_bus_init(usb2_bus_t *, hcd_t *, size_t);
 
 #endif

uspace/lib/usbhost/src/bandwidth.c

@@ -48 +48 @@
  * @param max_packet_size Maximum bytes in one packet.
  */
-size_t bandwidth_count_usb11(endpoint_t *ep, size_t size)
+ssize_t bandwidth_count_usb11(endpoint_t *ep, size_t size)
 {
         assert(ep);
@@ -102 +102 @@
  * @param max_packet_size Maximum bytes in one packet.
  */
-size_t bandwidth_count_usb20(endpoint_t *ep, size_t size)
+ssize_t bandwidth_count_usb20(endpoint_t *ep, size_t size)
 {
         assert(ep);

uspace/lib/usbhost/src/bus.c

@@ -46 +46 @@
  * Initializes the bus structure.
  */
-void bus_init(bus_t *bus, size_t device_size)
-{
-        assert(bus);
+void bus_init(bus_t *bus, hcd_t *hcd, size_t device_size)
+{
+        assert(bus);
+        assert(hcd);
         assert(device_size >= sizeof(device_t));
         memset(bus, 0, sizeof(bus_t));
 
         fibril_mutex_initialize(&bus->guard);
+        bus->hcd = hcd;
         bus->device_size = device_size;
 }
 
-int device_init(device_t *dev)
-{
+int bus_device_init(device_t *dev, bus_t *bus)
+{
+        assert(bus);
+        assert(bus->hcd);
+
         memset(dev, 0, sizeof(*dev));
+
+        dev->bus = bus;
 
         link_initialize(&dev->link);
@@ -67 +74 @@
 }
 
-int device_set_default_name(device_t *dev)
+int bus_device_set_default_name(device_t *dev)
 {
         assert(dev);
@@ -79 +86 @@
 }
 
-int bus_enumerate_device(bus_t *bus, hcd_t *hcd, device_t *dev)
-{
-        assert(bus);
-        assert(hcd);
-        assert(dev);
-
-        if (!bus->ops.enumerate_device)
-                return ENOTSUP;
-
-        return bus->ops.enumerate_device(bus, hcd, dev);
-}
-
-int bus_remove_device(bus_t *bus, hcd_t *hcd, device_t *dev)
-{
-        assert(bus);
-        assert(dev);
-
-        if (!bus->ops.remove_device)
-                return ENOTSUP;
-
-        return bus->ops.remove_device(bus, hcd, dev);
-}
-
-int bus_online_device(bus_t *bus, hcd_t *hcd, device_t *dev)
-{
-        assert(bus);
-        assert(hcd);
-        assert(dev);
-
-        if (!bus->ops.online_device)
-                return ENOTSUP;
-
-        return bus->ops.online_device(bus, hcd, dev);
-}
-
-int bus_offline_device(bus_t *bus, hcd_t *hcd, device_t *dev)
-{
-        assert(bus);
-        assert(hcd);
-        assert(dev);
-
-        if (!bus->ops.offline_device)
-                return ENOTSUP;
-
-        return bus->ops.offline_device(bus, hcd, dev);
-}
-
-int bus_add_endpoint(bus_t *bus, device_t *device, const usb_endpoint_desc_t *desc, endpoint_t **out_ep)
-{
-        assert(bus);
+int bus_device_enumerate(device_t *dev)
+{
+        assert(dev);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_enumerate);
+        if (!ops)
+                return ENOTSUP;
+
+        return ops->device_enumerate(dev);
+}
+
+int bus_device_remove(device_t *dev)
+{
+        assert(dev);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_remove);
+
+        if (!ops)
+                return ENOTSUP;
+
+        return ops->device_remove(dev);
+}
+
+int bus_device_online(device_t *dev)
+{
+        assert(dev);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_online);
+        if (!ops)
+                return ENOTSUP;
+
+        return ops->device_online(dev);
+}
+
+int bus_device_offline(device_t *dev)
+{
+        assert(dev);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_offline);
+        if (!ops)
+                return ENOTSUP;
+
+        return ops->device_offline(dev);
+}
+
+int bus_endpoint_add(device_t *device, const usb_endpoint_desc_t *desc, endpoint_t **out_ep)
+{
+        int err;
         assert(device);
+
+        bus_t *bus = device->bus;
 
         if (desc->max_packet_size == 0 || desc->packets == 0) {
@@ -136 +143 @@
         }
 
-        fibril_mutex_lock(&bus->guard);
-
-        int err = ENOMEM;
-        endpoint_t *ep = bus->ops.create_endpoint(bus);
+        const bus_ops_t *create_ops = BUS_OPS_LOOKUP(bus->ops, endpoint_create);
+        const bus_ops_t *register_ops = BUS_OPS_LOOKUP(bus->ops, endpoint_register);
+        if (!create_ops || !register_ops)
+                return ENOTSUP;
+
+        endpoint_t *ep = create_ops->endpoint_create(device, desc);
         if (!ep)
-                goto err;
-
-        /* Bus reference */
+                return ENOMEM;
+
+        /* Temporary reference */
         endpoint_add_ref(ep);
 
-        if ((err = bus->ops.register_endpoint(bus, device, ep, desc)))
-                goto err_ep;
+        fibril_mutex_lock(&bus->guard);
+        err = register_ops->endpoint_register(ep);
+        fibril_mutex_unlock(&bus->guard);
 
         if (out_ep) {
+                /* Exporting reference */
                 endpoint_add_ref(ep);
                 *out_ep = ep;
         }
 
-        fibril_mutex_unlock(&bus->guard);
-        return EOK;
-
-err_ep:
+        /* Temporary reference */
         endpoint_del_ref(ep);
-err:
-        fibril_mutex_unlock(&bus->guard);
         return err;
 }
@@ -166 +172 @@
 /** Searches for an endpoint. Returns a reference.
  */
-endpoint_t *bus_find_endpoint(bus_t *bus, device_t *device, usb_target_t endpoint, usb_direction_t dir)
-{
-        assert(bus);
-
-        fibril_mutex_lock(&bus->guard);
-        endpoint_t *ep = bus->ops.find_endpoint(bus, device, endpoint, dir);
+endpoint_t *bus_find_endpoint(device_t *device, usb_target_t endpoint, usb_direction_t dir)
+{
+        assert(device);
+
+        bus_t *bus = device->bus;
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, device_find_endpoint);
+        if (!ops)
+                return NULL;
+
+        fibril_mutex_lock(&bus->guard);
+        endpoint_t *ep = ops->device_find_endpoint(device, endpoint, dir);
         if (ep) {
                 /* Exporting reference */
@@ -181 +193 @@
 }
 
-int bus_remove_endpoint(bus_t *bus, endpoint_t *ep)
-{
-        assert(bus);
+int bus_endpoint_remove(endpoint_t *ep)
+{
         assert(ep);
 
-        fibril_mutex_lock(&bus->guard);
-        const int r = bus->ops.unregister_endpoint(bus, ep);
+        bus_t *bus = endpoint_get_bus(ep);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(ep->device->bus->ops, endpoint_unregister);
+        if (!ops)
+                return ENOTSUP;
+
+        fibril_mutex_lock(&bus->guard);
+        const int r = ops->endpoint_unregister(ep);
         fibril_mutex_unlock(&bus->guard);
 
@@ -203 +220 @@
         assert(bus);
 
-        if (!bus->ops.reserve_default_address)
-                return ENOTSUP;
-
-        fibril_mutex_lock(&bus->guard);
-        const int r = bus->ops.reserve_default_address(bus, speed);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, reserve_default_address);
+        if (!ops)
+                return ENOTSUP;
+
+        fibril_mutex_lock(&bus->guard);
+        const int r = ops->reserve_default_address(bus, speed);
         fibril_mutex_unlock(&bus->guard);
         return r;
@@ -216 +234 @@
         assert(bus);
 
-        /* If this op is not set, allow everything */
-        if (!bus->ops.release_default_address)
-                return ENOTSUP;
-
-        fibril_mutex_lock(&bus->guard);
-        const int r = bus->ops.release_default_address(bus);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, release_default_address);
+        if (!ops)
+                return ENOTSUP;
+
+        fibril_mutex_lock(&bus->guard);
+        const int r = ops->release_default_address(bus);
         fibril_mutex_unlock(&bus->guard);
         return r;
@@ -230 +248 @@
         assert(bus);
 
-        if (!bus->ops.reset_toggle)
-                return ENOTSUP;
-
-        fibril_mutex_lock(&bus->guard);
-        const int r = bus->ops.reset_toggle(bus, target, all);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, reset_toggle);
+        if (!ops)
+                return ENOTSUP;
+
+        fibril_mutex_lock(&bus->guard);
+        const int r = ops->reset_toggle(bus, target, all);
         fibril_mutex_unlock(&bus->guard);
         return r;
-}
-
-size_t bus_count_bw(endpoint_t *ep, size_t size)
-{
-        assert(ep);
-
-        fibril_mutex_lock(&ep->guard);
-        const size_t bw = ep->bus->ops.count_bw(ep, size);
-        fibril_mutex_unlock(&ep->guard);
-        return bw;
 }
 

uspace/lib/usbhost/src/ddf_helpers.c

@@ -101 +101 @@
                 endpoint_desc->max_packet_size, endpoint_desc->usb2.polling_interval);
 
-        return bus_add_endpoint(hcd->bus, dev, endpoint_desc, NULL);
+        return bus_endpoint_add(dev, endpoint_desc, NULL);
 }
 
@@ -128 +128 @@
                 usb_str_direction(endpoint_desc->direction));
 
-        endpoint_t *ep = bus_find_endpoint(hcd->bus, dev, target, endpoint_desc->direction);
+        endpoint_t *ep = bus_find_endpoint(dev, target, endpoint_desc->direction);
         if (!ep)
                 return ENOENT;
 
-        return bus_remove_endpoint(hcd->bus, ep);
+        return bus_endpoint_remove(ep);
 }
 
@@ -362 +362 @@
                 const int ret = ddf_fun_unbind(victim->fun);
                 if (ret == EOK) {
-                        bus_remove_device(hcd->bus, hcd, victim);
+                        bus_device_remove(victim);
                         ddf_fun_destroy(victim->fun);
                 } else {
@@ -374 +374 @@
 }
 
-device_t *hcd_ddf_device_create(ddf_dev_t *hc, size_t device_size)
+device_t *hcd_ddf_device_create(ddf_dev_t *hc, bus_t *bus)
 {
         /* Create DDF function for the new device */
@@ -384 +384 @@
 
         /* Create USB device node for the new device */
-        device_t *dev = ddf_fun_data_alloc(fun, device_size);
+        device_t *dev = ddf_fun_data_alloc(fun, bus->device_size);
         if (!dev) {
                 ddf_fun_destroy(fun);
@@ -390 +390 @@
         }
 
-        device_init(dev);
+        bus_device_init(dev, bus);
         dev->fun = fun;
         return dev;
@@ -402 +402 @@
 }
 
-int hcd_ddf_device_explore(hcd_t *hcd, device_t *device)
+int hcd_ddf_device_explore(device_t *device)
 {
         int err;
@@ -421 +421 @@
         usb_log_debug("Device(%d): Requesting full device descriptor.",
             device->address);
-        ssize_t got = hcd_send_batch_sync(hcd, device, control_ep, USB_DIRECTION_IN,
+        ssize_t got = hcd_send_batch_sync(device->bus->hcd, device, control_ep, USB_DIRECTION_IN,
             (char *) &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
             "read device descriptor");
@@ -458 +458 @@
         usb_log_info("Device(%d): Requested to be brought online.", dev->address);
 
-        return bus_online_device(hcd->bus, hcd, dev);
+        return bus_device_online(dev);
 }
 
@@ -472 +472 @@
         usb_log_info("Device(%d): Requested to be taken offline.", dev->address);
 
-        return bus_offline_device(hcd->bus, hcd, dev);
+        return bus_device_offline(dev);
 }
 
@@ -483 +483 @@
         assert(hc);
 
-        device_t *dev = hcd_ddf_device_create(hc, hcd->bus->device_size);
+        device_t *dev = hcd_ddf_device_create(hc, hcd->bus);
         if (!dev) {
                 usb_log_error("Failed to create USB device function.");
@@ -492 +492 @@
         dev->port = port;
 
-        if ((err = bus_enumerate_device(hcd->bus, hcd, dev))) {
+        if ((err = bus_device_enumerate(dev))) {
                 usb_log_error("Failed to initialize USB dev memory structures.");
                 return err;
@@ -501 +501 @@
          */
         if (!ddf_fun_get_name(dev->fun)) {
-                device_set_default_name(dev);
+                bus_device_set_default_name(dev);
         }
 
@@ -538 +538 @@
         }
 
-        device_t *dev = hcd_ddf_device_create(hc, hcd->bus->device_size);
+        device_t *dev = hcd_ddf_device_create(hc, hcd->bus);
         if (!dev) {
                 usb_log_error("Failed to create function for the root hub.");
@@ -547 +547 @@
 
         /* Assign an address to the device */
-        if ((err = bus_enumerate_device(hcd->bus, hcd, dev))) {
+        if ((err = bus_device_enumerate(dev))) {
                 usb_log_error("Failed to enumerate roothub device: %s", str_error(err));
                 goto err_usb_dev;

uspace/lib/usbhost/src/endpoint.c

@@ -47 +47 @@
 /** Initialize provided endpoint structure.
  */
-void endpoint_init(endpoint_t *ep, bus_t *bus)
+void endpoint_init(endpoint_t *ep, device_t *dev, const usb_endpoint_desc_t *desc)
 {
         memset(ep, 0, sizeof(endpoint_t));
 
-        ep->bus = bus;
+        assert(dev);
+        ep->device = dev;
+
         atomic_set(&ep->refcnt, 0);
         link_initialize(&ep->link);
         fibril_mutex_initialize(&ep->guard);
         fibril_condvar_initialize(&ep->avail);
+
+        ep->endpoint = desc->endpoint_no;
+        ep->direction = desc->direction;
+        ep->transfer_type = desc->transfer_type;
+        ep->max_packet_size = desc->max_packet_size;
+        ep->packets = desc->packets;
+
+        ep->bandwidth = endpoint_count_bw(ep, desc->max_packet_size);
+}
+
+static inline const bus_ops_t *get_bus_ops(endpoint_t *ep)
+{
+        return ep->device->bus->ops;
 }
 
@@ -63 +78 @@
 }
 
+static inline void endpoint_destroy(endpoint_t *ep)
+{
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_destroy);
+        if (ops) {
+                ops->endpoint_destroy(ep);
+        } else {
+                assert(ep->active_batch == NULL);
+
+                /* Assume mostly the eps will be allocated by malloc. */
+                free(ep);
+        }
+}
+
 void endpoint_del_ref(endpoint_t *ep)
 {
         if (atomic_predec(&ep->refcnt) == 0) {
-                if (ep->bus->ops.destroy_endpoint) {
-                        ep->bus->ops.destroy_endpoint(ep);
-                }
-                else {
-                        assert(ep->active_batch == NULL);
-
-                        /* Assume mostly the eps will be allocated by malloc. */
-                        free(ep);
-                }
+                endpoint_destroy(ep);
         }
 }
@@ -133 +153 @@
         assert(ep);
 
-        return ep->bus->ops.endpoint_get_toggle
-            ? ep->bus->ops.endpoint_get_toggle(ep)
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_get_toggle);
+        return ops
+            ? ops->endpoint_get_toggle(ep)
             : ep->toggle;
 }
@@ -146 +167 @@
         assert(ep);
 
-        if (ep->bus->ops.endpoint_set_toggle) {
-                ep->bus->ops.endpoint_set_toggle(ep, toggle);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_set_toggle);
+        if (ops) {
+                ops->endpoint_set_toggle(ep, toggle);
         }
         else {
@@ -154 +176 @@
 }
 
+ssize_t endpoint_count_bw(endpoint_t *ep, size_t packet_size)
+{
+        assert(ep);
+
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_count_bw);
+        if (!ops)
+                return 0;
+
+        return ops->endpoint_count_bw(ep, packet_size);
+}
+
 /**
  * @}

uspace/lib/usbhost/src/hcd.c

@@ -208 +208 @@
         }
 
-        endpoint_t *ep = bus_find_endpoint(hcd->bus, device, target, direction);
+        endpoint_t *ep = bus_find_endpoint(device, target, direction);
         if (ep == NULL) {
                 usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
@@ -216 +216 @@
 
         // TODO cut here aka provide helper to call with instance of endpoint_t in hand
+        assert(ep->device == device);
 
         usb_log_debug2("%s %d:%d %zu(%zu).\n",
             name, target.address, target.endpoint, size, ep->max_packet_size);
 
-        const size_t bw = bus_count_bw(ep, size);
+        const size_t bw = endpoint_count_bw(ep, size);
         /* Check if we have enough bandwidth reserved */
         if (ep->bandwidth < bw) {

uspace/lib/usbhost/src/usb2_bus.c

@@ -200 +200 @@
 }};
 
-static int address_device(usb2_bus_t *bus, hcd_t *hcd, device_t *dev)
+static int address_device(device_t *dev)
 {
         int err;
+
+        usb2_bus_t *bus = (usb2_bus_t *) dev->bus;
+        hcd_t *hcd = (hcd_t *) bus->base.hcd;
 
         /* The default address is currently reserved for this device */
@@ -220 +223 @@
 
         endpoint_t *default_ep;
-        err = bus_add_endpoint(&bus->base, dev, &usb2_default_control_ep, &default_ep);
+        err = bus_endpoint_add(dev, &usb2_default_control_ep, &default_ep);
         if (err != EOK) {
                 usb_log_error("Device(%d): Failed to add default target: %s.",
@@ -244 +247 @@
 
         /* We need to remove ep before we change the address */
-        if ((err = bus_remove_endpoint(&bus->base, default_ep))) {
+        if ((err = bus_endpoint_remove(default_ep))) {
                 usb_log_error("Device(%d): Failed to unregister default target: %s", address, str_error(err));
                 goto err_address;
@@ -262 +265 @@
         /* Register EP on the new address */
         usb_log_debug("Device(%d): Registering control EP.", address);
-        err = bus_add_endpoint(&bus->base, dev, &control_ep, NULL);
+        err = bus_endpoint_add(dev, &control_ep, NULL);
         if (err != EOK) {
                 usb_log_error("Device(%d): Failed to register EP0: %s",
@@ -272 +275 @@
 
 err_default_control_ep:
-        bus_remove_endpoint(&bus->base, default_ep);
+        bus_endpoint_remove(default_ep);
         endpoint_del_ref(default_ep);
 err_address:
@@ -281 +284 @@
 /** Enumerate a new USB device
  */
-static int usb2_bus_enumerate_device(bus_t *bus_base, hcd_t *hcd, device_t *dev)
+static int usb2_bus_device_enumerate(device_t *dev)
 {
         int err;
-        usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
+        usb2_bus_t *bus = bus_to_usb2_bus(dev->bus);
 
         /* The speed of the new device was reported by the hub when reserving
@@ -306 +309 @@
 
         /* Assign an address to the device */
-        if ((err = address_device(bus, hcd, dev))) {
+        if ((err = address_device(dev))) {
                 usb_log_error("Failed to setup address of the new device: %s", str_error(err));
                 return err;
@@ -312 +315 @@
 
         /* Read the device descriptor, derive the match ids */
-        if ((err = hcd_ddf_device_explore(hcd, dev))) {
+        if ((err = hcd_ddf_device_explore(dev))) {
                 usb_log_error("Device(%d): Failed to explore device: %s", dev->address, str_error(err));
                 release_address(bus, dev->address);
@@ -329 +332 @@
  * @note Assumes that the internal mutex is locked.
  */
-static endpoint_t *usb2_bus_find_ep(bus_t *bus_base, device_t *device, usb_target_t target, usb_direction_t direction)
-{
-        usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
+static endpoint_t *usb2_bus_find_ep(device_t *device, usb_target_t target, usb_direction_t direction)
+{
+        usb2_bus_t *bus = bus_to_usb2_bus(device->bus);
 
         assert(device->address == target.address);
@@ -345 +348 @@
 }
 
-static endpoint_t *usb2_bus_create_ep(bus_t *bus)
+static endpoint_t *usb2_bus_create_ep(device_t *dev, const usb_endpoint_desc_t *desc)
 {
         endpoint_t *ep = malloc(sizeof(endpoint_t));
@@ -351 +354 @@
                 return NULL;
 
-        endpoint_init(ep, bus);
+        endpoint_init(ep, dev, desc);
         return ep;
 }
@@ -370 +373 @@
  * @param endpoint USB endpoint number.
  */
-static int usb2_bus_register_ep(bus_t *bus_base, device_t *device, endpoint_t *ep, const usb_endpoint_desc_t *desc)
-{
-        usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
+static int usb2_bus_register_ep(endpoint_t *ep)
+{
+        usb2_bus_t *bus = bus_to_usb2_bus(ep->device->bus);
+        assert(fibril_mutex_is_locked(&bus->base.guard));
         assert(ep);
 
-        ep->device = device;
-
-        /* Extract USB2-related information from endpoint_desc */
-        ep->endpoint = desc->endpoint_no;
-        ep->direction = desc->direction;
-        ep->transfer_type = desc->transfer_type;
-        ep->max_packet_size = desc->max_packet_size;
-        ep->packets = desc->packets;
-
-        ep->bandwidth = bus_base->ops.count_bw(ep, desc->max_packet_size);
-
         /* Check for existence */
-        if (usb2_bus_find_ep(bus_base, ep->device, usb2_ep_to_target(ep), ep->direction))
+        if (usb2_bus_find_ep(ep->device, usb2_ep_to_target(ep), ep->direction))
                 return EEXIST;
 
@@ -394 +387 @@
                 return ENOSPC;
 
+        endpoint_add_ref(ep);
         list_append(&ep->link, get_list(bus, ep->device->address));
         bus->free_bw -= ep->bandwidth;
@@ -400 +394 @@
 }
 
-
 /** Release bandwidth reserved by the given endpoint.
  */
-static int usb2_bus_unregister_ep(bus_t *bus_base, endpoint_t *ep)
-{
-        usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
+static int usb2_bus_unregister_ep(endpoint_t *ep)
+{
+        usb2_bus_t *bus = bus_to_usb2_bus(ep->device->bus);
         assert(ep);
 
         list_remove(&ep->link);
-        ep->device = NULL;
 
         bus->free_bw += ep->bandwidth;
+        endpoint_del_ref(ep);
 
         return EOK;
@@ -452 +445 @@
 }
 
-static const bus_ops_t usb2_bus_ops = {
+const bus_ops_t usb2_bus_ops = {
         .reserve_default_address = usb2_bus_register_default_address,
         .release_default_address = usb2_bus_release_default_address,
-        .enumerate_device = usb2_bus_enumerate_device,
-        .create_endpoint = usb2_bus_create_ep,
-        .find_endpoint = usb2_bus_find_ep,
-        .unregister_endpoint = usb2_bus_unregister_ep,
-        .register_endpoint = usb2_bus_register_ep,
         .reset_toggle = usb2_bus_reset_toggle,
+        .device_enumerate = usb2_bus_device_enumerate,
+        .device_find_endpoint = usb2_bus_find_ep,
+        .endpoint_create= usb2_bus_create_ep,
+        .endpoint_register= usb2_bus_register_ep,
+        .endpoint_unregister= usb2_bus_unregister_ep,
 };
 
@@ -470 +463 @@
  * @return Error code.
  */
-int usb2_bus_init(usb2_bus_t *bus, size_t available_bandwidth, count_bw_func_t count_bw)
+int usb2_bus_init(usb2_bus_t *bus, hcd_t *hcd, size_t available_bandwidth)
 {
         assert(bus);
 
-        bus_init(&bus->base, sizeof(device_t));
-
-        bus->base.ops = usb2_bus_ops;
-        bus->base.ops.count_bw = count_bw;
+        bus_init(&bus->base, hcd, sizeof(device_t));
+        bus->base.ops = &usb2_bus_ops;
 
         bus->free_bw = available_bandwidth;

uspace/lib/usbhost/src/usb_transfer_batch.c

@@ -49 +49 @@
 {
         assert(ep);
-        assert(ep->bus);
 
-        usb_transfer_batch_t *batch;
-        if (ep->bus->ops.create_batch)
-                batch = ep->bus->ops.create_batch(ep->bus, ep);
-        else
-                batch = calloc(1, sizeof(usb_transfer_batch_t));
+        bus_t *bus = endpoint_get_bus(ep);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, batch_create);
 
-        return batch;
+        if (!ops) {
+                usb_transfer_batch_t *batch = calloc(1, sizeof(usb_transfer_batch_t));
+                usb_transfer_batch_init(batch, ep);
+                return batch;
+        }
+
+        return ops->batch_create(ep);
 }
 
@@ -64 +66 @@
 void usb_transfer_batch_init(usb_transfer_batch_t *batch, endpoint_t *ep)
 {
+        assert(ep);
+        endpoint_add_ref(ep);
         batch->ep = ep;
 }
@@ -82 +86 @@
             batch->toggle_reset_mode == RESET_ALL ? "all EPs toggle" : "EP toggle");
 
-        return bus_reset_toggle(batch->ep->bus, batch->target, batch->toggle_reset_mode);
+        return bus_reset_toggle(endpoint_get_bus(batch->ep), batch->target, batch->toggle_reset_mode);
 }
 
@@ -93 +97 @@
         assert(batch);
         assert(batch->ep);
-        assert(batch->ep->bus);
 
-        bus_t *bus = batch->ep->bus;
-        if (bus->ops.destroy_batch) {
+        bus_t *bus = endpoint_get_bus(batch->ep);
+        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, batch_destroy);
+
+        endpoint_del_ref(batch->ep);
+
+        if (ops) {
                 usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " destroying.\n",
                     batch, USB_TRANSFER_BATCH_ARGS(*batch));
-                bus->ops.destroy_batch(batch);
+                ops->batch_destroy(batch);
         }
         else {