Changeset d369b3b in mainline for uspace/lib/usbhost/src/usb2_bus.c

Timestamp:

2018-01-25T02:05:57Z (7 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.

File:

• uspace/lib/usbhost/src/usb2_bus.c (modified) (11 diffs)

uspace/lib/usbhost/src/usb2_bus.c

@@ -54 +54 @@
 
 /**
- * Ops receive generic bus_t pointer.
- */
-static inline usb2_bus_t *bus_to_usb2_bus(bus_t *bus_base)
-{
-        assert(bus_base);
-        return (usb2_bus_t *) bus_base;
-}
-
-/**
  * Request a new address. A free address is found and marked as occupied.
  *
@@ -71 +62 @@
  * @param addr Pointer to requested address value, place to store new address
  */
-static int request_address(usb2_bus_t *bus, usb_address_t *addr)
+static int request_address(usb2_bus_helper_t *helper, usb_address_t *addr)
 {
         // Find a free address
-        usb_address_t new_address = bus->last_address;
+        usb_address_t new_address = helper->last_address;
         do {
                 new_address = (new_address + 1) % USB_ADDRESS_COUNT;
                 if (new_address == USB_ADDRESS_DEFAULT)
                         new_address = 1;
-                if (new_address == bus->last_address)
+                if (new_address == helper->last_address)
                         return ENOSPC;
-        } while (bus->address_occupied[new_address]);
-        bus->last_address = new_address;
+        } while (helper->address_occupied[new_address]);
+        helper->last_address = new_address;
 
         *addr = new_address;
-        bus->address_occupied[*addr] = true;
+        helper->address_occupied[*addr] = true;
 
         return EOK;
@@ -93 +84 @@
  * Mark address as free.
  */
-static void release_address(usb2_bus_t *bus, usb_address_t address)
-{
-        bus->address_occupied[address] = false;
+static void release_address(usb2_bus_helper_t *helper, usb_address_t address)
+{
+        helper->address_occupied[address] = false;
 }
 
@@ -109 +100 @@
  * Configure the device with the new address,
  */
-static int address_device(device_t *dev)
+static int address_device(usb2_bus_helper_t *helper, device_t *dev)
 {
         int err;
-
-        usb2_bus_t *bus = (usb2_bus_t *) dev->bus;
 
         /* The default address is currently reserved for this device */
@@ -120 +109 @@
         /** Reserve address early, we want pretty log messages */
         usb_address_t address = USB_ADDRESS_DEFAULT;
-        if ((err = request_address(bus, &address))) {
+        if ((err = request_address(helper, &address))) {
                 usb_log_error("Failed to reserve new address: %s.",
                     str_error(err));
@@ -141 +130 @@
         }
 
-        if ((err = hc_get_ep0_max_packet_size(&ep0_desc.endpoint.max_packet_size, &bus->base, dev)))
+        if ((err = hc_get_ep0_max_packet_size(&ep0_desc.endpoint.max_packet_size, dev->bus, dev)))
                 goto err_address;
 
@@ -178 +167 @@
         bus_endpoint_remove(default_ep);
 err_address:
-        release_address(bus, address);
+        release_address(helper, address);
         return err;
 }
@@ -186 +175 @@
  * to create a DDF function node with proper characteristics.
  */
-static int usb2_bus_device_enumerate(device_t *dev)
+int usb2_bus_device_enumerate(usb2_bus_helper_t *helper, device_t *dev)
 {
         int err;
-        usb2_bus_t *bus = bus_to_usb2_bus(dev->bus);
-
         usb_log_debug("Found new %s speed USB device.", usb_str_speed(dev->speed));
 
         /* Assign an address to the device */
-        if ((err = address_device(dev))) {
+        if ((err = address_device(helper, dev))) {
                 usb_log_error("Failed to setup address of the new device: %s", str_error(err));
                 return err;
@@ -202 +189 @@
         if ((err = hc_device_explore(dev))) {
                 usb_log_error("Device(%d): Failed to explore device: %s", dev->address, str_error(err));
-                release_address(bus, dev->address);
+                release_address(helper, dev->address);
                 return err;
         }
@@ -210 +197 @@
 
 /**
- * Call the bus operation to count bandwidth.
- *
- * @param ep Endpoint on which the transfer will take place.
- * @param size The payload size.
- */
-static ssize_t endpoint_count_bw(endpoint_t *ep)
+ * Register an endpoint to the bus. Reserves bandwidth.
+ */
+int usb2_bus_endpoint_register(usb2_bus_helper_t *helper, endpoint_t *ep)
 {
         assert(ep);
-
-        usb2_bus_t *bus = bus_to_usb2_bus(ep->device->bus);
-
-        return bus->bw_accounting->count_bw(ep);
-}
-
-/**
- * Register an endpoint to the bus. Reserves bandwidth.
- */
-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(&ep->device->guard));
+
+        size_t bw = helper->bw_accounting->count_bw(ep);
+
+        /* Check for available bandwidth */
+        if (bw > helper->free_bw)
+                return ENOSPC;
+
+        helper->free_bw -= bw;
+
+        return EOK;
+}
+
+/**
+ * Release bandwidth reserved by the given endpoint.
+ */
+void usb2_bus_endpoint_unregister(usb2_bus_helper_t *helper, endpoint_t *ep)
+{
+        assert(helper);
         assert(ep);
 
-        size_t bw = endpoint_count_bw(ep);
-
-        /* Check for available bandwidth */
-        if (bw > bus->free_bw)
-                return ENOSPC;
-
-        bus->free_bw -= bw;
-
-        return EOK;
-}
-
-/**
- * Release bandwidth reserved by the given endpoint.
- */
-static void usb2_bus_unregister_ep(endpoint_t *ep)
-{
-        usb2_bus_t *bus = bus_to_usb2_bus(ep->device->bus);
-        assert(ep);
-
-        bus->free_bw += endpoint_count_bw(ep);
-}
-
-const bus_ops_t usb2_bus_ops = {
-        .device_enumerate = usb2_bus_device_enumerate,
-        .endpoint_register = usb2_bus_register_ep,
-        .endpoint_unregister = usb2_bus_unregister_ep,
-};
-
-/** Initialize to default state.
- *
- * @param bus usb_bus structure, non-null.
- * @param available_bandwidth Size of the bandwidth pool.
- */
-void usb2_bus_init(usb2_bus_t *bus, const bandwidth_accounting_t *bw_accounting)
-{
-        assert(bus);
+        helper->free_bw += helper->bw_accounting->count_bw(ep);
+}
+
+/**
+ * Initialize to default state.
+ *
+ * @param helper usb_bus_helper structure, non-null.
+ * @param bw_accounting a structure defining bandwidth accounting
+ */
+void usb2_bus_helper_init(usb2_bus_helper_t *helper, const bandwidth_accounting_t *bw_accounting)
+{
+        assert(helper);
         assert(bw_accounting);
 
-        bus_init(&bus->base, sizeof(device_t));
-        bus->base.ops = &usb2_bus_ops;
-
-        bus->bw_accounting = bw_accounting;
-        bus->free_bw = bw_accounting->available_bandwidth;
+        helper->bw_accounting = bw_accounting;
+        helper->free_bw = bw_accounting->available_bandwidth;
 
         /*
@@ -282 +245 @@
          * address 1.
          */
-        bus->last_address = USB_ADDRESS_COUNT - 2;
+        helper->last_address = USB_ADDRESS_COUNT - 2;
 }