Changeset b357377 in mainline for uspace/lib/usbhost/src

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:

d369b3b

Parents:

5f0b366

git-author:

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

git-committer:

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

Message:

usbhost: make bandwidth accounting a usb2_bus-thing

Location:

uspace/lib/usbhost/src

Files:

• bandwidth.c (modified) (5 diffs)
• usb2_bus.c (modified) (2 diffs)

uspace/lib/usbhost/src/bandwidth.c

@@ -42 +42 @@
 #include "bandwidth.h"
 
+/** Bytes per second in FULL SPEED */
+#define BANDWIDTH_TOTAL_USB11 (12000000 / 8)
+/** 90% of total bandwidth is available for periodic transfers */
+#define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 * 9) / 10)
+
 /**
  * Calculate bandwidth that needs to be reserved for communication with EP.
  * Calculation follows USB 1.1 specification.
- * @param ep Registered endpoint
- * @param size Number of bytes to transfer.
- * @param max_packet_size Maximum bytes in one packet.
+ *
+ * @param ep An endpoint for which the bandwidth is to be counted
  */
-ssize_t bandwidth_count_usb11(endpoint_t *ep, size_t size)
+static size_t bandwidth_count_usb11(endpoint_t *ep)
 {
         assert(ep);
@@ -63 +67 @@
 
         const size_t max_packet_size = ep->max_packet_size;
+        const size_t packet_count = ep->packets_per_uframe;
 
-        const unsigned packet_count =
-            (size + max_packet_size - 1) / max_packet_size;
         /* TODO: It may be that ISO and INT transfers use only one packet per
          * transaction, but I did not find text in USB spec to confirm this */
@@ -96 +99 @@
 }
 
-/** 
+const bandwidth_accounting_t bandwidth_accounting_usb11 = {
+        .available_bandwidth = BANDWIDTH_AVAILABLE_USB11,
+        .count_bw = &bandwidth_count_usb11,
+};
+
+/** Number of nanoseconds in one microframe */
+#define BANDWIDTH_TOTAL_USB2 (125000)
+/** 90% of total bandwidth is available for periodic transfers */
+#define BANDWIDTH_AVAILABLE_USB2  ((BANDWIDTH_TOTAL_USB2 * 9) / 10)
+
+/**
  * Calculate bandwidth that needs to be reserved for communication with EP.
  * Calculation follows USB 2.0 specification, chapter 5.11.3.
  *
- * @param speed Device's speed.
- * @param type Type of the transfer.
- * @param size Number of byte to transfer.
- * @param max_packet_size Maximum bytes in one packet.
+ * FIXME: Interrupt transfers shall be probably divided by their polling interval.
+ *
+ * @param ep An endpoint for which the bandwidth is to be counted
  * @return Number of nanoseconds transaction with @c size bytes payload will
  *         take.
  */
-ssize_t bandwidth_count_usb20(endpoint_t *ep, size_t size)
+static size_t bandwidth_count_usb2(endpoint_t *ep)
 {
         assert(ep);
+        assert(ep->device);
 
         const usb_transfer_type_t type = ep->transfer_type;
@@ -124 +137 @@
 
         // Approx. Floor(3.167 + BitStuffTime(Data_bc))
-        const size_t base_time = (size * 8 + 19) / 6;
+        const size_t base_time = (ep->max_transfer_size * 8 + 19) / 6;
 
         switch (ep->device->speed) {
@@ -152 +165 @@
         }
 }
+
+const bandwidth_accounting_t bandwidth_accounting_usb2 = {
+        .available_bandwidth = BANDWIDTH_AVAILABLE_USB2,
+        .count_bw = &bandwidth_count_usb2,
+};

uspace/lib/usbhost/src/usb2_bus.c

@@ -219 +219 @@
         assert(ep);
 
-        bus_t *bus = ep->device->bus;
-        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, endpoint_count_bw);
-        if (!ops)
-                return 0;
-
-        return ops->endpoint_count_bw(ep, ep->max_transfer_size);
+        usb2_bus_t *bus = bus_to_usb2_bus(ep->device->bus);
+
+        return bus->bw_accounting->count_bw(ep);
 }
 
@@ -269 +266 @@
  * @param available_bandwidth Size of the bandwidth pool.
  */
-void usb2_bus_init(usb2_bus_t *bus, size_t available_bandwidth)
+void usb2_bus_init(usb2_bus_t *bus, const bandwidth_accounting_t *bw_accounting)
 {
         assert(bus);
+        assert(bw_accounting);
 
         bus_init(&bus->base, sizeof(device_t));
         bus->base.ops = &usb2_bus_ops;
 
-        bus->free_bw = available_bandwidth;
+        bus->bw_accounting = bw_accounting;
+        bus->free_bw = bw_accounting->available_bandwidth;
 
         /*