Changeset 20eaa82 in mainline for uspace/drv/bus/usb/xhci

Timestamp:

2017-10-15T13:44:39Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

2770b66

Parents:

867b375

Message:

usbhost refactoring: introduced bus→enumerate_device

Location:

uspace/drv/bus/usb/xhci

Files:

• bus.c (modified) (7 diffs)
• bus.h (modified) (2 diffs)
• hc.c (modified) (3 diffs)
• hc.h (modified) (2 diffs)
• main.c (modified) (5 diffs)
• rh.c (modified) (6 diffs)
• rh.h (modified) (4 diffs)

uspace/drv/bus/usb/xhci/bus.c

@@ -35 +35 @@
 #include <adt/hash_table.h>
 #include <adt/hash.h>
+#include <usb/host/ddf_helpers.h>
 #include <usb/host/endpoint.h>
+#include <usb/host/hcd.h>
 #include <usb/debug.h>
 
 #include <assert.h>
 #include <errno.h>
+#include <str_error.h>
 #include <macros.h>
 #include <stdbool.h>
@@ -53 +56 @@
         xhci_device_t *device;
 } hashed_device_t;
+
+/** TODO: Still some copy-pasta left...
+ */
+int xhci_bus_enumerate_device(xhci_bus_t *bus, xhci_hc_t *hc, device_t *dev)
+{
+        int err;
+
+        /* TODO: get speed from the default address reservation */
+        dev->speed = USB_SPEED_FULL;
+
+        /* Manage TT */
+        if (dev->hub->speed == USB_SPEED_HIGH && usb_speed_is_11(dev->speed)) {
+                /* For LS devices under HS hub */
+                /* TODO: How about SS hubs? */
+                dev->tt.address = dev->hub->address;
+                dev->tt.port = dev->port;
+        }
+        else {
+                /* Inherit hub's TT */
+                dev->tt = dev->hub->tt;
+        }
+
+        /* Assign an address to the device */
+        if ((err = xhci_rh_address_device(&hc->rh, dev))) {
+                usb_log_error("Failed to setup address of the new device: %s", str_error(err));
+                return err;
+        }
+
+        /* Read the device descriptor, derive the match ids */
+        if ((err = hcd_ddf_device_explore(hc->hcd, dev))) {
+                usb_log_error("Device(%d): Failed to explore device: %s", dev->address, str_error(err));
+                bus_release_address(&bus->base, dev->address);
+                return err;
+        }
+
+        return EOK;
+}
+
+static int enumerate_device(bus_t *bus, hcd_t *hcd, device_t *dev)
+{
+        xhci_hc_t *hc = hcd_get_driver_data(hcd);
+        assert(hc);
+
+        return xhci_bus_enumerate_device((xhci_bus_t *) bus, hc, dev);
+}
+
+static int remove_device(bus_t *bus, hcd_t *hcd, device_t *dev)
+{
+        // TODO: Implement me!
+
+        return ENOTSUP;
+}
 
 /** Ops receive generic bus_t pointer. */
@@ -214 +269 @@
 }
 
-static int get_speed(bus_t *bus_base, usb_address_t address, usb_speed_t *speed)
-{
-        xhci_bus_t *bus = bus_to_xhci_bus(bus_base);
-        assert(bus);
-
-        // TODO: Use `xhci_get_port_speed` once we find the port corresponding to `address`.
-        *speed = USB_SPEED_SUPER;
-        return EOK;
-}
-
 static int release_address(bus_t *bus_base, usb_address_t address)
 {
@@ -255 +300 @@
 
 static const bus_ops_t xhci_bus_ops = {
+        .enumerate_device = enumerate_device,
+        .remove_device = remove_device,
+
         .create_endpoint = create_endpoint,
         .destroy_endpoint = destroy_endpoint,
@@ -263 +311 @@
 
         .request_address = request_address,
-        .get_speed = get_speed,
         .release_address = release_address,
         .reset_toggle = reset_toggle,
@@ -303 +350 @@
         assert(bus);
 
-        bus_init(&bus->base);
+        bus_init(&bus->base, sizeof(device_t));
 
         if (!hash_table_create(&bus->devices, 0, 0, &device_ht_ops)) {
@@ -320 +367 @@
         hash_table_destroy(&bus->devices);
 }
+
 /**
  * @}

uspace/drv/bus/usb/xhci/bus.h

@@ -42 +42 @@
 #include <usb/host/bus.h>
 
+typedef struct xhci_hc xhci_hc_t;
+
 /** Endpoint management structure */
 typedef struct xhci_bus {
@@ -58 +60 @@
 void xhci_bus_fini(xhci_bus_t *);
 
+int xhci_bus_enumerate_device(xhci_bus_t *, xhci_hc_t *, device_t *);
+
 #endif
 /**

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

@@ -158 +158 @@
                 return err;
 
-        hc->base = base;
+        hc->reg_base = base;
         hc->cap_regs = (xhci_cap_regs_t *)  base;
         hc->op_regs  = (xhci_op_regs_t *)  (base + XHCI_REG_RD(hc->cap_regs, XHCI_CAP_LENGTH));
@@ -180 +180 @@
 
         if ((err = hc_parse_ec(hc))) {
-                pio_disable(hc->base, RNGSZ(hc->mmio_range));
+                pio_disable(hc->reg_base, RNGSZ(hc->mmio_range));
                 return err;
         }
@@ -619 +619 @@
         xhci_fini_commands(hc);
         xhci_rh_fini(&hc->rh);
-        pio_disable(hc->base, RNGSZ(hc->mmio_range));
+        pio_disable(hc->reg_base, RNGSZ(hc->mmio_range));
         usb_log_info("HC(%p): Finalized.", hc);
 }

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

@@ -53 +53 @@
         /* MMIO range */
         addr_range_t mmio_range;
-        void *base;
 
         /* Mapped register sets */
+        void *reg_base;
         xhci_cap_regs_t *cap_regs;
         xhci_op_regs_t *op_regs;
@@ -83 +83 @@
         list_t commands;
         list_t transfers;
+
+        /* TODO: Hack. Figure out a better way. */
+        hcd_t *hcd;
 } xhci_hc_t;
 

uspace/drv/bus/usb/xhci/main.c

@@ -55 +55 @@
 static void hcd_interrupt(hcd_t *, uint32_t);
 static int hcd_schedule(hcd_t *, usb_transfer_batch_t *);
-static int hcd_address_device(hcd_t *, usb_speed_t, usb_tt_address_t, usb_address_t *);
 static void hc_driver_fini(hcd_t *);
 
 static const ddf_hc_driver_t xhci_ddf_hc_driver = {
-        .hc_speed = USB_SPEED_SUPER,
         .name = "XHCI-PCI",
         .init = hc_driver_init,
@@ -71 +69 @@
                 .irq_hook       = hcd_interrupt,
                 .status_hook    = hcd_status,
-                .address_device = hcd_address_device,
         }
 };
@@ -90 +87 @@
 
         hcd_set_implementation(hcd, hc, &xhci_ddf_hc_driver.ops, &hc->bus.base);
+        hc->hcd = hcd;
 
         return EOK;
@@ -126 +124 @@
         assert(hc);
 
-        hc->rh.hcd_rh = hcd_roothub_create(hcd, dev, USB_SPEED_SUPER);
-        return hc->rh.hcd_rh ? EOK : ENOMEM;
+        hc->rh.hc_device = dev;
+        return device_init(&hc->rh.device);
 }
 
@@ -153 +151 @@
 
         hc_interrupt(hc, status);
-}
-
-static int hcd_address_device(hcd_t *hcd, usb_speed_t speed, usb_tt_address_t tt, usb_address_t *address)
-{
-        xhci_hc_t *hc = hcd_get_driver_data(hcd);
-        assert(hc);
-
-        return xhci_rh_address_device(&hc->rh, speed, tt, address);
 }
 

uspace/drv/bus/usb/xhci/rh.c

@@ -38 +38 @@
 #include <usb/debug.h>
 #include <usb/host/utils/malloc32.h>
+#include <usb/host/bus.h>
 #include <usb/host/ddf_helpers.h>
 
@@ -73 +74 @@
 // TODO: This currently assumes the device is attached to rh directly.
 //       Also, we should consider moving a lot of functionailty to xhci bus
-int xhci_rh_address_device(xhci_rh_t *rh, usb_speed_t unused_speed, usb_tt_address_t tt, usb_address_t *address)
+int xhci_rh_address_device(xhci_rh_t *rh, device_t *dev)
 {
         int err;
@@ -81 +82 @@
         xhci_cmd_init(&cmd);
 
-        uint8_t port = tt.port;
-
         /* XXX Certainly not generic solution. */
         uint32_t route_str = 0;
 
-        const xhci_port_speed_t *speed = xhci_rh_get_port_speed(rh, port);
+        const xhci_port_speed_t *speed = xhci_rh_get_port_speed(rh, dev->port);
 
         xhci_send_enable_slot_command(hc, &cmd);
@@ -109 +108 @@
         /* Initialize slot_ctx according to section 4.3.3 point 3. */
         /* Attaching to root hub port, root string equals to 0. */
-        XHCI_SLOT_ROOT_HUB_PORT_SET(ictx->slot_ctx, port);
+        XHCI_SLOT_ROOT_HUB_PORT_SET(ictx->slot_ctx, dev->port);
         XHCI_SLOT_CTX_ENTRIES_SET(ictx->slot_ctx, 1);
         XHCI_SLOT_ROUTE_STRING_SET(ictx->slot_ctx, route_str);
@@ -158 +157 @@
         xhci_cmd_fini(&cmd);
 
-        *address = XHCI_SLOT_DEVICE_ADDRESS(dctx->slot_ctx);
-        usb_log_debug2("Obtained USB address: %d.\n", *address);
+        dev->address = XHCI_SLOT_DEVICE_ADDRESS(dctx->slot_ctx);
+        usb_log_debug2("Obtained USB address: %d.\n", dev->address);
 
         // TODO: Ask libusbhost to create a control endpoint for EP0.
@@ -183 +182 @@
 }
 
+/** Create a device node for device directly connected to RH.
+ */
 static int rh_setup_device(xhci_rh_t *rh, uint8_t port_id)
 {
-        /** This should ideally use the libusbhost in a clean and elegant way,
-         * to create child function. The refactoring of libusbhost is not over
-         * yet, so for now it is still quirky.
-         */
-
-        return hcd_roothub_new_device(rh->hcd_rh, port_id);
+        int err;
+        assert(rh);
+
+        xhci_bus_t *bus = &rh->hc->bus;
+
+        device_t *dev = hcd_ddf_device_create(rh->hc_device, bus->base.device_size);
+        if (!dev) {
+                usb_log_error("Failed to create USB device function.");
+                return ENOMEM;
+        }
+
+        dev->hub = &rh->device;
+        dev->port = port_id;
+
+        if ((err = xhci_bus_enumerate_device(bus, rh->hc, dev))) {
+                usb_log_error("Failed to enumerate USB device: %s", str_error(err));
+                return err;
+        }
+
+        if (!ddf_fun_get_name(dev->fun)) {
+                device_set_default_name(dev);
+        }
+
+        if ((err = ddf_fun_bind(dev->fun))) {
+                usb_log_error("Device(%d): Failed to register: %s.", dev->address, str_error(err));
+                goto err_usb_dev;
+        }
+
+        fibril_mutex_lock(&rh->device.guard);
+        list_append(&dev->link, &rh->device.devices);
+        fibril_mutex_unlock(&rh->device.guard);
+
+        return EOK;
+
+err_usb_dev:
+        hcd_ddf_device_destroy(dev);
+        return err;
 }
 

uspace/drv/bus/usb/xhci/rh.h

@@ -38 +38 @@
 
 #include <usb/host/usb_transfer_batch.h>
+#include <usb/host/bus.h>
 #include "hw_struct/regs.h"
 
 typedef struct xhci_hc xhci_hc_t;
+typedef struct ddf_dev ddf_dev_t;
 
 /**
@@ -58 +60 @@
         xhci_hc_t *hc;
 
+        /* Root for the device tree */
+        device_t device;
+
+        /* We need this to attach children to */
+        ddf_dev_t *hc_device;
+
         /** Port speeds reported from HC */
         xhci_port_speed_t speeds [16];
@@ -66 +74 @@
         /* Number of hub ports. */
         uint8_t max_ports;
-
-        /* We need this to create child devices */
-        hcd_roothub_t *hcd_rh;
 } xhci_rh_t;
 
@@ -79 +84 @@
 void xhci_rh_handle_port_change(xhci_rh_t *);
 
-int xhci_rh_address_device(xhci_rh_t *, usb_speed_t, usb_tt_address_t, usb_address_t *);
+int xhci_rh_address_device(xhci_rh_t *rh, device_t *dev);
 
 #endif