Changeset 5542b83 in mainline

Timestamp:

2011-04-02T15:47:45Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

322a8066, d8987b1

Parents:

969585f (diff), 0053fa38 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Add USB bandwidth control mechanism

Use per endpoint control transfer mutex
Bandwidth control issues warnings, drivers(libusb pipe init?) need to use it first.

Location:

uspace

Files:

• drv/uhci-hcd/hc.c (modified) (5 diffs)
• drv/uhci-hcd/hc.h (modified) (2 diffs)
• drv/uhci-hcd/iface.c (modified) (2 diffs)
• lib/c/generic/adt/hash_table.c (modified) (1 diff)
• lib/c/include/adt/hash_table.h (modified) (2 diffs)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/host/bandwidth.h (added)
• lib/usb/include/usb/host/device_keeper.h (modified) (2 diffs)
• lib/usb/src/host/bandwidth.c (added)
• lib/usb/src/host/device_keeper.c (modified) (2 diffs)

uspace/drv/uhci-hcd/hc.c

@@ -239 +239 @@
         usb_log_debug("Initialized device manager.\n");
 
+        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
+            bandwidth_count_usb11);
+        assert(ret == true);
+
         return EOK;
 #undef CHECK_RET_DEST_CMDS_RETURN
@@ -325 +329 @@
         if (!usb_is_allowed(
             low_speed, batch->transfer_type, batch->max_packet_size)) {
-                usb_log_warning(
-                    "Invalid USB transfer specified %s SPEED %d %zu.\n",
-                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
+                usb_log_error("Invalid USB transfer specified %s %d %zu.\n",
+                    usb_str_speed(batch->speed), batch->transfer_type,
                     batch->max_packet_size);
                 return ENOTSUP;
         }
-        /* TODO: check available bandwidth here */
+        /* Check available bandwidth */
+        if (batch->transfer_type == USB_TRANSFER_INTERRUPT ||
+            batch->transfer_type == USB_TRANSFER_ISOCHRONOUS) {
+                int ret =
+                    bandwidth_use(&instance->bandwidth, batch->target.address,
+                    batch->target.endpoint, batch->direction);
+                if (ret != EOK) {
+                        usb_log_warning("Failed(%d) to use reserved bw: %s.\n",
+                            ret, str_error(ret));
+                }
+        }
 
         transfer_list_t *list =
@@ -338 +351 @@
         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
                 usb_device_keeper_use_control(
-                    &instance->manager, batch->target.address);
+                    &instance->manager, batch->target);
         }
         transfer_list_add_batch(list, batch);
@@ -358 +371 @@
 {
         assert(instance);
+//      status |= 1; //Uncomment to work around qemu hang
         /* TODO: Resume interrupts are not supported */
         /* Lower 2 bits are transaction error and transaction complete */
@@ -376 +390 @@
                         usb_transfer_batch_t *batch =
                             list_get_instance(item, usb_transfer_batch_t, link);
-                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                        switch (batch->transfer_type)
+                        {
+                        case USB_TRANSFER_CONTROL:
                                 usb_device_keeper_release_control(
-                                    &instance->manager, batch->target.address);
+                                    &instance->manager, batch->target);
+                                break;
+                        case USB_TRANSFER_INTERRUPT:
+                        case USB_TRANSFER_ISOCHRONOUS: {
+                                int ret = bandwidth_free(&instance->bandwidth,
+                                    batch->target.address,
+                                    batch->target.endpoint,
+                                    batch->direction);
+                                if (ret != EOK)
+                                        usb_log_warning("Failed(%d) to free "
+                                            "reserved bw: %s.\n", ret,
+                                            str_error(ret));
+                                }
+                        default:
+                                break;
                         }
                         batch->next_step(batch);

uspace/drv/uhci-hcd/hc.h

@@ -43 +43 @@
 #include <usbhc_iface.h>
 #include <usb/host/device_keeper.h>
+#include <usb/host/bandwidth.h>
 
 #include "batch.h"
@@ -84 +85 @@
 typedef struct hc {
         usb_device_keeper_t manager;
+        bandwidth_t bandwidth;
 
         regs_t *registers;

uspace/drv/uhci-hcd/iface.c

@@ -128 +128 @@
 }
 /*----------------------------------------------------------------------------*/
+static int register_endpoint(
+    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
+    usb_transfer_type_t transfer_type, usb_direction_t direction,
+    size_t max_packet_size, unsigned int interval)
+{
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        const usb_speed_t speed =
+            usb_device_keeper_get_speed(&hc->manager, address);
+        size_t size = max_packet_size;
+
+        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
+            address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_speed(speed), direction, size, max_packet_size, interval);
+        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
+            speed, transfer_type, max_packet_size, size, interval);
+}
+/*----------------------------------------------------------------------------*/
+static int unregister_endpoint(
+    ddf_fun_t *fun, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_log_debug("Unregister endpoint %d:%d %d.\n",
+            address, endpoint, direction);
+        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
+}
+/*----------------------------------------------------------------------------*/
 /** Interrupt out transaction interface function
  *
@@ -365 +394 @@
         .release_address = release_address,
 
+        .register_endpoint = register_endpoint,
+        .unregister_endpoint = unregister_endpoint,
+
         .interrupt_out = interrupt_out,
         .interrupt_in = interrupt_in,

uspace/lib/c/generic/adt/hash_table.c

@@ -54 +54 @@
  *
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {

uspace/lib/c/include/adt/hash_table.h

@@ -38 +38 @@
 #include <adt/list.h>
 #include <unistd.h>
+#include <bool.h>
 
 typedef unsigned long hash_count_t;
@@ -83 +84 @@
     list_get_instance((item), type, member)
 
-extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
+extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     hash_table_operations_t *);
 extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

uspace/lib/usb/Makefile

@@ -53 +53 @@
         src/hidreport.c \
         src/host/device_keeper.c \
-        src/host/batch.c
+        src/host/batch.c \
+        src/host/bandwidth.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -51 +51 @@
         usb_speed_t speed;
         bool occupied;
-        bool control_used;
+        uint16_t control_used;
         uint16_t toggle_status[2];
         devman_handle_t handle;
@@ -99 +99 @@
 
 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 #endif

uspace/lib/usb/src/host/device_keeper.c

@@ -54 +54 @@
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
-                instance->devices[i].control_used = false;
+                instance->devices[i].control_used = 0;
                 instance->devices[i].handle = 0;
                 instance->devices[i].toggle_status[0] = 0;
@@ -311 +311 @@
 /*----------------------------------------------------------------------------*/
 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_address_t address)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->devices[address].control_used) {
+    usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[target.address].control_used & ep) {
                 fibril_condvar_wait(&instance->change, &instance->guard);
         }
-        instance->devices[address].control_used = true;
+        instance->devices[target.address].control_used |= ep;
         fibril_mutex_unlock(&instance->guard);
 }
 /*----------------------------------------------------------------------------*/
 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_address_t address)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->devices[address].control_used = false;
+    usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        assert((instance->devices[target.address].control_used & ep) != 0);
+        instance->devices[target.address].control_used &= ~ep;
         fibril_mutex_unlock(&instance->guard);
         fibril_condvar_signal(&instance->change);