Changeset b4b534ac in mainline for uspace/drv/bus/usb/ehci

Timestamp:

2016-07-22T08:24:47Z (10 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

f76d2c2

Parents:

5b18137 (diff), 8351f9a4 (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:

Merge from lp:~jan.vesely/helenos/usb

Location:

uspace/drv/bus/usb/ehci

Files:

• Makefile (modified) (3 diffs)
• ehci_batch.c (added)
• ehci_batch.h (added)
• ehci_endpoint.c (added)
• ehci_endpoint.h (moved) (moved from uspace/drv/bus/usb/uhcirh/root_hub.h ) (1 diff)
• ehci_regs.h (added)
• ehci_rh.c (added)
• ehci_rh.h (moved) (moved from uspace/drv/bus/usb/uhci/root_hub.c ) (2 diffs)
• endpoint_list.c (added)
• endpoint_list.h (added)
• hc.c (added)
• hc.h (added)
• hw_struct/fstn.h (moved) (moved from uspace/drv/bus/usb/uhci/uhci.h ) (2 diffs)
• hw_struct/iso_transfer_descriptor.h (added)
• hw_struct/link_pointer.h (moved) (moved from uspace/lib/usb/include/usb/ddfiface.h ) (2 diffs)
• hw_struct/mem_access.h (moved) (moved from uspace/drv/bus/usb/uhci/res.h ) (2 diffs)
• hw_struct/queue_head.c (added)
• hw_struct/queue_head.h (added)
• hw_struct/split_iso_transfer_descriptor.h (added)
• hw_struct/transfer_descriptor.c (added)
• hw_struct/transfer_descriptor.h (added)
• main.c (modified) (3 diffs)
• res.c (modified) (8 diffs)
• res.h (modified) (1 diff)

uspace/drv/bus/usb/ehci/Makefile

@@ -31 +31 @@
 LIBS = \
         $(LIBUSBHOST_PREFIX)/libusbhost.a \
+        $(LIBUSBVIRT_PREFIX)/libusbvirt.a \
         $(LIBUSB_PREFIX)/libusb.a \
         $(LIBDRV_PREFIX)/libdrv.a
@@ -36 +37 @@
 EXTRA_CFLAGS += \
         -I$(LIBUSB_PREFIX)/include \
+        -I$(LIBUSBDEV_PREFIX)/include \
         -I$(LIBUSBHOST_PREFIX)/include \
+        -I$(LIBUSBVIRT_PREFIX)/include \
         -I$(LIBDRV_PREFIX)/include
 
@@ -42 +45 @@
 
 SOURCES = \
+        ehci_batch.c \
+        ehci_endpoint.c \
+        ehci_rh.c \
+        endpoint_list.c \
+        hc.c \
+        hw_struct/queue_head.c \
+        hw_struct/transfer_descriptor.c \
         main.c \
         res.c

uspace/drv/bus/usb/ehci/ehci_endpoint.h

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup drvusbuhcirh
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
- * @brief UHCI driver
+ * @brief EHCI driver
  */
-#ifndef DRV_UHCI_ROOT_HUB_H
-#define DRV_UHCI_ROOT_HUB_H
+#ifndef DRV_EHCI_HCD_ENDPOINT_H
+#define DRV_EHCI_HCD_ENDPOINT_H
 
-#include <ddf/driver.h>
-#include <device/hw_res_parsed.h>
+#include <assert.h>
+#include <adt/list.h>
+#include <usb/host/endpoint.h>
+#include <usb/host/hcd.h>
 
-#include "port.h"
+#include "hw_struct/queue_head.h"
+#include "hw_struct/transfer_descriptor.h"
 
-#define UHCI_ROOT_HUB_PORT_COUNT 2
-#define ROOT_HUB_WAIT_USEC 250000 /* 250 miliseconds */
+/** Connector structure linking ED to to prepared TD. */
+typedef struct ehci_endpoint {
+        /** EHCI endpoint descriptor */
+        qh_t *qh;
+        /** Linked list used by driver software */
+        link_t link;
+} ehci_endpoint_t;
 
-/** UHCI root hub drvier structure */
-typedef struct root_hub {
-        /** Ports provided by the hub */
-        uhci_port_t ports[UHCI_ROOT_HUB_PORT_COUNT];
-} uhci_root_hub_t;
+int ehci_endpoint_init(hcd_t *hcd, endpoint_t *ep);
+void ehci_endpoint_fini(hcd_t *hcd, endpoint_t *ep);
 
-int uhci_root_hub_init(uhci_root_hub_t *instance, addr_range_t *regs,
-    ddf_dev_t *rh);
+/** Get and convert assigned ehci_endpoint_t structure
+ * @param[in] ep USBD endpoint structure.
+ * @return Pointer to assigned hcd endpoint structure
+ */
+static inline ehci_endpoint_t * ehci_endpoint_get(const endpoint_t *ep)
+{
+        assert(ep);
+        return ep->hc_data.data;
+}
 
-void uhci_root_hub_fini(uhci_root_hub_t *instance);
+static inline ehci_endpoint_t * ehci_endpoint_list_instance(link_t *l)
+{
+        return list_get_instance(l, ehci_endpoint_t, link);
+}
+
 #endif
 /**
  * @}
  */
+

uspace/drv/bus/usb/ehci/ehci_rh.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup drvusbuhci
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
- * @brief UHCI driver
+ * @brief EHCI driver
  */
+#ifndef DRV_EHCI_EHCI_RH_H
+#define DRV_EHCI_EHCI_RH_H
+
 #include <assert.h>
-#include <errno.h>
-#include <str_error.h>
-#include <stdio.h>
-#include <device/hw_res_parsed.h>
+#include <sys/types.h>
 
-#include <usb/debug.h>
+#include <usb/usb.h>
+#include <usb/classes/hub.h>
+#include <usb/host/usb_transfer_batch.h>
+#include <usbvirt/virthub_base.h>
 
-#include "root_hub.h"
+#include "ehci_regs.h"
 
-/** Root hub initialization
- * @param[in] instance RH structure to initialize
- * @param[in] fun DDF function representing UHCI root hub
- * @param[in] reg_addr Address of root hub status and control registers.
- * @param[in] reg_size Size of accessible address space.
- * @return Error code.
+enum {
+        EHCI_MAX_PORTS = 15,
+};
+
+typedef struct {
+        /** Virtual hub instance */
+        virthub_base_t base;
+        /** EHCI device registers */
+        ehci_regs_t *registers;
+        /** Number of downstream ports, EHCI limits this to 15 */
+        unsigned port_count;
+        /** USB hub descriptor describing the EHCI root hub */
+        struct {
+                usb_hub_descriptor_header_t header;
+                uint8_t rempow[STATUS_BYTES(EHCI_MAX_PORTS) * 2];
+        } __attribute__((packed)) hub_descriptor;
+        /** interrupt transfer waiting for an actual interrupt to occur */
+        usb_transfer_batch_t *unfinished_interrupt_transfer;
+        bool reset_flag[EHCI_MAX_PORTS];
+        bool resume_flag[EHCI_MAX_PORTS];
+} ehci_rh_t;
+
+int ehci_rh_init(ehci_rh_t *instance, ehci_caps_regs_t *caps, ehci_regs_t *regs,
+    const char *name);
+int ehci_rh_schedule(ehci_rh_t *instance, usb_transfer_batch_t *batch);
+int ehci_rh_interrupt(ehci_rh_t *instance);
+
+/** Get EHCI rh address.
+ *
+ * @param instance UHCI rh instance.
+ * @return USB address assigned to the hub.
+ * Wrapper for virtual hub address
  */
-int
-rh_init(rh_t *instance, ddf_fun_t *fun, addr_range_t *regs, uintptr_t reg_addr,
-    size_t reg_size)
+static inline usb_address_t ehci_rh_get_address(ehci_rh_t *instance)
 {
         assert(instance);
-        assert(fun);
-
-        /* Crop the PIO window to the absolute address range of UHCI I/O. */
-        instance->pio_window.mem.base = 0;
-        instance->pio_window.mem.size = 0;
-        instance->pio_window.io.base = RNGABS(*regs);
-        instance->pio_window.io.size = RNGSZ(*regs);
-
-        /* Initialize resource structure */
-        instance->resource_list.count = 1;
-        instance->resource_list.resources = &instance->io_regs;
-
-        instance->io_regs.type = IO_RANGE;
-        instance->io_regs.res.io_range.address = reg_addr;
-        instance->io_regs.res.io_range.size = reg_size;
-        instance->io_regs.res.io_range.relative = true;
-        instance->io_regs.res.io_range.endianness = LITTLE_ENDIAN;
-
-        const int ret = ddf_fun_add_match_id(fun, "usb&uhci&root-hub", 100);
-        if (ret != EOK) {
-                usb_log_error("Failed to add root hub match id: %s\n",
-                    str_error(ret));
-        }
-        return ret;
+        return virthub_base_get_address(&instance->base);
 }
+#endif
 /**
  * @}

uspace/drv/bus/usb/ehci/hw_struct/fstn.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup drvusbuhci
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
- * @brief UHCI driver main structure for both host controller and root-hub.
+ * @brief EHCI driver
  */
-#ifndef DRV_UHCI_UHCI_H
-#define DRV_UHCI_UHCI_H
-#include <ddf/driver.h>
+#ifndef DRV_EHCI_HW_STRUCT_FSTN_H
+#define DRV_EHCI_HW_STRUCT_FSTN_H
 
-int device_setup_uhci(ddf_dev_t *device);
+#include "link_pointer.h"
+
+typedef struct fstn {
+        link_pointer_t normal_path;
+        link_pointer_t back_path;
+} fstn_t;
+
 #endif
 /**
  * @}
  */
+

uspace/drv/bus/usb/ehci/hw_struct/link_pointer.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup libusb
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
- * Implementations of DDF interfaces functions.
+ * @brief EHCI driver
  */
-
-#ifndef LIBUSB_DDFIFACE_H_
-#define LIBUSB_DDFIFACE_H_
+#ifndef DRV_EHCI_HW_STRUCT_LINK_POINTER_H
+#define DRV_EHCI_HW_STRUCT_LINK_POINTER_H
 
 #include <sys/types.h>
-#include <usb_iface.h>
 
-extern int usb_iface_get_hc_handle_device_impl(ddf_fun_t *, devman_handle_t *);
-extern int usb_iface_get_my_address_forward_impl(ddf_fun_t *, usb_address_t *);
-extern usb_iface_t usb_iface_hub_impl;
+/** EHCI link pointer, used by many data structures */
+typedef volatile uint32_t link_pointer_t;
 
-extern int usb_iface_get_my_address_from_device_data(ddf_fun_t *, usb_address_t *);
-extern usb_iface_t usb_iface_hub_child_impl;
+#define LINK_POINTER_ADDRESS_MASK   0xfffffff0 /* upper 28 bits */
 
-extern int usb_iface_get_hc_handle_hc_impl(ddf_fun_t *, devman_handle_t *);
+#define LINK_POINTER_TERMINATE_FLAG   (1 << 0)
+
+enum {
+        LINK_POINTER_TYPE_iTD  = 0x0 << 1,
+        LINK_POINTER_TYPE_QH   = 0x1 << 1,
+        LINK_POINTER_TYPE_siTD = 0x2 << 1,
+        LINK_POINTER_TYPE_FSTN = 0x3 << 1,
+        LINK_POINTER_TYPE_MASK = 0x3 << 1,
+};
+
+#define LINK_POINTER_QH(address) \
+        ((address & LINK_POINTER_ADDRESS_MASK) | LINK_POINTER_TYPE_QH)
+
+#define LINK_POINTER_TD(address) \
+        (address & LINK_POINTER_ADDRESS_MASK)
+
+#define LINK_POINTER_TERM \
+        ((link_pointer_t)LINK_POINTER_TERMINATE_FLAG)
 
 #endif
-
 /**
  * @}

uspace/drv/bus/usb/ehci/hw_struct/mem_access.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup drvusbuhcihc
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
- * @brief UHCI driver PCI helper functions
+ * @brief EHCI driver
  */
-#ifndef DRV_UHCI_PCI_H
-#define DRV_UHCI_PCI_H
+#ifndef DRV_EHCI_HW_MEM_ACCESS_H
+#define DRV_EHCI_HW_MEM_ACCESS_H
 
-#include <ddf/driver.h>
-#include <device/hw_res_parsed.h>
+#include <byteorder.h>
+#include <libarch/barrier.h>
 
-int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
-int enable_interrupts(ddf_dev_t *);
-int disable_legacy(ddf_dev_t *);
+#define EHCI_MEM32_WR(reg, val) reg = host2uint32_t_le(val)
+#define EHCI_MEM32_RD(reg) uint32_t_le2host(reg)
+#define EHCI_MEM32_SET(reg, val) reg |= host2uint32_t_le(val)
+#define EHCI_MEM32_CLR(reg, val) reg &= host2uint32_t_le(~val)
 
 #endif
-/**
+
+/*
  * @}
  */

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

@@ -33 +33 @@
  * Main routines of EHCI driver.
  */
-
 #include <ddf/driver.h>
 #include <ddf/interrupt.h>
 #include <device/hw_res.h>
 #include <errno.h>
-#include <stdbool.h>
 #include <str_error.h>
+#include <io/logctl.h>
 
 #include <usb_iface.h>
-#include <usb/ddfiface.h>
 #include <usb/debug.h>
-#include <usb/host/hcd.h>
+#include <usb/host/ddf_helpers.h>
 
 #include "res.h"
+#include "hc.h"
+#include "ehci_endpoint.h"
 
 #define NAME "ehci"
 
-static int ehci_dev_add(ddf_dev_t *device);
+static int ehci_driver_init(hcd_t *, const hw_res_list_parsed_t *, bool);
+static void ehci_driver_fini(hcd_t *);
 
-static driver_ops_t ehci_driver_ops = {
-        .dev_add = ehci_dev_add,
+static const ddf_hc_driver_t ehci_hc_driver = {
+        .claim = disable_legacy,
+        .hc_speed = USB_SPEED_HIGH,
+        .irq_code_gen = ehci_hc_gen_irq_code,
+        .init = ehci_driver_init,
+        .fini = ehci_driver_fini,
+        .name = "EHCI-PCI",
+        .ops = {
+                .schedule       = ehci_hc_schedule,
+                .ep_add_hook    = ehci_endpoint_init,
+                .ep_remove_hook = ehci_endpoint_fini,
+                .irq_hook       = ehci_hc_interrupt,
+                .status_hook    = ehci_hc_status,
+        }
 };
 
-static driver_t ehci_driver = {
-        .name = NAME,
-        .driver_ops = &ehci_driver_ops
-};
-static ddf_dev_ops_t hc_ops = {
-        .interfaces[USBHC_DEV_IFACE] = &hcd_iface,
-};
 
+static int ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res, bool irq)
+{
+        assert(hcd);
+        assert(hcd_get_driver_data(hcd) == NULL);
+
+        hc_t *instance = malloc(sizeof(hc_t));
+        if (!instance)
+                return ENOMEM;
+
+        const int ret = hc_init(instance, res, irq);
+        if (ret == EOK) {
+                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops);
+        } else {
+                free(instance);
+        }
+        return ret;
+}
+
+static void ehci_driver_fini(hcd_t *hcd)
+{
+        assert(hcd);
+        hc_t *hc = hcd_get_driver_data(hcd);
+        if (hc)
+                hc_fini(hc);
+
+        free(hc);
+        hcd_set_implementation(hcd, NULL, NULL);
+}
 
 /** Initializes a new ddf driver instance of EHCI hcd.
@@ -72 +106 @@
 static int ehci_dev_add(ddf_dev_t *device)
 {
-        ddf_fun_t *hc_fun = NULL;
-        bool fun_bound = false;
-
+        usb_log_debug("ehci_dev_add() called\n");
         assert(device);
 
-        addr_range_t reg_range;
-        int irq = 0;
+        return hcd_ddf_add_hc(device, &ehci_hc_driver);
 
-        int rc = get_my_registers(device, &reg_range, &irq);
-        if (rc != EOK) {
-                usb_log_error("Failed to get memory addresses for %" PRIun
-                    ": %s.\n", ddf_dev_get_handle(device), str_error(rc));
-                goto error;
-        }
+}
 
-        usb_log_info("Memory mapped regs at %p (size %zu), IRQ %d.\n",
-            RNGABSPTR(reg_range), RNGSZ(reg_range), irq);
 
-        rc = disable_legacy(device, &reg_range);
-        if (rc != EOK) {
-                usb_log_error("Failed to disable legacy USB: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
+static const driver_ops_t ehci_driver_ops = {
+        .dev_add = ehci_dev_add,
+};
 
-        hc_fun = ddf_fun_create(device, fun_exposed, "ehci_hc");
-        if (hc_fun == NULL) {
-                usb_log_error("Failed to create EHCI function.\n");
-                rc = ENOMEM;
-                goto error;
-        }
+static const driver_t ehci_driver = {
+        .name = NAME,
+        .driver_ops = &ehci_driver_ops
+};
 
-        hcd_t *ehci_hc = ddf_fun_data_alloc(hc_fun, sizeof(hcd_t));
-        if (ehci_hc == NULL) {
-                usb_log_error("Failed to alloc generic HC driver.\n");
-                rc = ENOMEM;
-                goto error;
-        }
-
-        /* High Speed, no bandwidth */
-        hcd_init(ehci_hc, USB_SPEED_HIGH, 0, NULL);
-        ddf_fun_set_ops(hc_fun,  &hc_ops);
-
-        rc = ddf_fun_bind(hc_fun);
-        if (rc != EOK) {
-                usb_log_error("Failed to bind EHCI function: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
-
-        fun_bound = true;
-
-        rc = ddf_fun_add_to_category(hc_fun, USB_HC_CATEGORY);
-        if (rc != EOK) {
-                usb_log_error("Failed to add EHCI to HC class: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
-
-        usb_log_info("Controlling new EHCI device `%s' (handle %" PRIun ").\n",
-            ddf_dev_get_name(device), ddf_dev_get_handle(device));
-
-        return EOK;
-error:
-        if (fun_bound)
-                ddf_fun_unbind(hc_fun);
-        if (hc_fun != NULL)
-                ddf_fun_destroy(hc_fun);
-        return rc;
-}
 
 /** Initializes global driver structures (NONE).
@@ -154 +135 @@
 {
         log_init(NAME);
+        logctl_set_log_level(NAME, LVL_NOTE);
         return ddf_driver_main(&ehci_driver);
 }

uspace/drv/bus/usb/ehci/res.c

@@ -46 +46 @@
 
 #include "res.h"
-
-#define HCC_PARAMS_OFFSET 0x8
-#define HCC_PARAMS_EECP_MASK 0xff
-#define HCC_PARAMS_EECP_OFFSET 8
-
-#define CMD_OFFSET 0x0
-#define STS_OFFSET 0x4
-#define INT_OFFSET 0x8
-#define CFG_OFFSET 0x40
-
-#define USBCMD_RUN 1
-#define USBSTS_HALTED (1 << 12)
+#include "ehci_regs.h"
 
 #define USBLEGSUP_OFFSET 0
@@ -67 +56 @@
 #define WAIT_STEP 10
 
-
-/** Get address of registers and IRQ for given device.
- *
- * @param[in] dev Device asking for the addresses.
- * @param[out] mem_regs_p Pointer to the register range.
- * @param[out] irq_no IRQ assigned to the device.
- * @return Error code.
- */
-int get_my_registers(ddf_dev_t *dev,
-    addr_range_t *mem_regs_p, int *irq_no)
-{
-        assert(dev);
-        
-        async_sess_t *parent_sess = devman_parent_device_connect(
-            ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
-        if (!parent_sess)
-                return ENOMEM;
-        
-        hw_res_list_parsed_t hw_res;
-        hw_res_list_parsed_init(&hw_res);
-        const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
-        async_hangup(parent_sess);
-        if (ret != EOK) {
-                return ret;
-        }
-
-        if (hw_res.irqs.count != 1 || hw_res.mem_ranges.count != 1) {
-                hw_res_list_parsed_clean(&hw_res);
-                return ENOENT;
-        }
-
-        if (mem_regs_p)
-                *mem_regs_p = hw_res.mem_ranges.ranges[0];
-        if (irq_no)
-                *irq_no = hw_res.irqs.irqs[0];
-
-        hw_res_list_parsed_clean(&hw_res);
-        return EOK;
-}
-
-/** Calls the PCI driver with a request to enable interrupts
- *
- * @param[in] device Device asking for interrupts
- * @return Error code.
- */
-int enable_interrupts(ddf_dev_t *device)
-{
-        async_sess_t *parent_sess = devman_parent_device_connect(
-            ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
-        if (!parent_sess)
-                return ENOMEM;
-        
-        const bool enabled = hw_res_enable_interrupt(parent_sess);
-        async_hangup(parent_sess);
-        
-        return enabled ? EOK : EIO;
-}
-
 /** Implements BIOS hands-off routine as described in EHCI spec
  *
@@ -131 +62 @@
  * @return Error code.
  */
-static int disable_extended_caps(ddf_dev_t *device, unsigned eecp)
+static int disable_extended_caps(async_sess_t *parent_sess, unsigned eecp)
 {
         /* nothing to do */
@@ -137 +68 @@
                 return EOK;
 
-        async_sess_t *parent_sess = devman_parent_device_connect(
-            ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
-        if (!parent_sess)
-                return ENOMEM;
-
         /* Read the first EEC. i.e. Legacy Support register */
         uint32_t usblegsup;
-        int rc = pci_config_space_read_32(parent_sess,
+        int ret = pci_config_space_read_32(parent_sess,
             eecp + USBLEGSUP_OFFSET, &usblegsup);
-        if (rc != EOK) {
-                usb_log_error("Failed to read USBLEGSUP: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
-
-        usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+        if (ret != EOK) {
+                usb_log_error("Failed to read USBLEGSUP: %s.\n", str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
 
         /* Request control from firmware/BIOS by writing 1 to highest
          * byte. (OS Control semaphore)*/
         usb_log_debug("Requesting OS control.\n");
-        rc = pci_config_space_write_8(parent_sess,
+        ret = pci_config_space_write_8(parent_sess,
             eecp + USBLEGSUP_OFFSET + 3, 1);
-        if (rc != EOK) {
+        if (ret != EOK) {
                 usb_log_error("Failed to request OS EHCI control: %s.\n",
-                    str_error(rc));
-                goto error;
+                    str_error(ret));
+                return ret;
         }
 
         size_t wait = 0;
         /* Wait for BIOS to release control. */
-        rc = pci_config_space_read_32(
+        ret = pci_config_space_read_32(
             parent_sess, eecp + USBLEGSUP_OFFSET, &usblegsup);
-        if (rc != EOK) {
-                usb_log_error("Failed reading PCI config space: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
-
-        while ((wait < DEFAULT_WAIT) && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
+        while ((ret == EOK) && (wait < DEFAULT_WAIT)
+            && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
                 async_usleep(WAIT_STEP);
-                rc = pci_config_space_read_32(parent_sess,
+                ret = pci_config_space_read_32(parent_sess,
                     eecp + USBLEGSUP_OFFSET, &usblegsup);
-                if (rc != EOK) {
-                        usb_log_error("Failed reading PCI config space: %s.\n",
-                            str_error(rc));
-                        goto error;
-                }
                 wait += WAIT_STEP;
         }
@@ -189 +103 @@
         if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
                 usb_log_info("BIOS released control after %zu usec.\n", wait);
-                async_hangup(parent_sess);
                 return EOK;
         }
@@ -196 +109 @@
         usb_log_warning( "BIOS failed to release control after "
             "%zu usecs, force it.\n", wait);
-        rc = pci_config_space_write_32(parent_sess,
+        ret = pci_config_space_write_32(parent_sess,
             eecp + USBLEGSUP_OFFSET, USBLEGSUP_OS_CONTROL);
-        if (rc != EOK) {
-                usb_log_error("Failed to force OS control: "
-                    "%s.\n", str_error(rc));
-                goto error;
+        if (ret != EOK) {
+                usb_log_error("Failed to force OS control: %s.\n",
+                    str_error(ret));
+                return ret;
         }
 
@@ -213 +126 @@
                 /* Read the second EEC Legacy Support and Control register */
                 uint32_t usblegctlsts;
-                rc = pci_config_space_read_32(parent_sess,
+                ret = pci_config_space_read_32(parent_sess,
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
-                if (rc != EOK) {
+                if (ret != EOK) {
                         usb_log_error("Failed to get USBLEGCTLSTS: %s.\n",
-                            str_error(rc));
-                        goto error;
+                            str_error(ret));
+                        return ret;
                 }
-
-                usb_log_debug("USBLEGCTLSTS: %" PRIx32 ".\n", usblegctlsts);
+                usb_log_debug2("USBLEGCTLSTS: %" PRIx32 ".\n", usblegctlsts);
                 /*
                  * Zero SMI enables in legacy control register.
@@ -227 +139 @@
                  * interfering. NOTE: Three upper bits are WC
                  */
-                rc = pci_config_space_write_32(parent_sess,
+                ret = pci_config_space_write_32(parent_sess,
                     eecp + USBLEGCTLSTS_OFFSET, 0xe0000000);
-                if (rc != EOK) {
-                        usb_log_error("Failed(%d) zero USBLEGCTLSTS.\n", rc);
-                        goto error;
+                if (ret != EOK) {
+                        usb_log_error("Failed to zero USBLEGCTLSTS: %s\n",
+                            str_error(ret));
+                        return ret;
                 }
 
                 udelay(10);
-                rc = pci_config_space_read_32(parent_sess,
+                /* read again to amke sure it's zeroed */
+                ret = pci_config_space_read_32(parent_sess,
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
-                if (rc != EOK) {
+                if (ret != EOK) {
                         usb_log_error("Failed to get USBLEGCTLSTS 2: %s.\n",
-                            str_error(rc));
-                        goto error;
+                            str_error(ret));
+                        return ret;
                 }
-
-                usb_log_debug("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
+                usb_log_debug2("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
                     usblegctlsts);
         }
 
         /* Read again Legacy Support register */
-        rc = pci_config_space_read_32(parent_sess,
+        ret = pci_config_space_read_32(parent_sess,
             eecp + USBLEGSUP_OFFSET, &usblegsup);
-        if (rc != EOK) {
+        if (ret != EOK) {
                 usb_log_error("Failed to read USBLEGSUP: %s.\n",
-                    str_error(rc));
-                goto error;
-        }
-
-        usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
-        async_hangup(parent_sess);
-        return EOK;
-error:
-        async_hangup(parent_sess);
-        return rc;
+                    str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+        return ret;
 }
 
-int disable_legacy(ddf_dev_t *device, addr_range_t *reg_range)
+int disable_legacy(ddf_dev_t *device)
 {
         assert(device);
+
+        async_sess_t *parent_sess = devman_parent_device_connect(
+            ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
+        if (!parent_sess)
+                return ENOMEM;
+
         usb_log_debug("Disabling EHCI legacy support.\n");
+
+        hw_res_list_parsed_t res;
+        hw_res_list_parsed_init(&res);
+        int ret = hw_res_get_list_parsed(parent_sess, &res, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to get resource list: %s\n",
+                    str_error(ret));
+                goto clean;
+        }
+
+        if (res.mem_ranges.count < 1) {
+                usb_log_error("Incorrect mem range count: %zu",
+                    res.mem_ranges.count);
+                ret = EINVAL;
+                goto clean;
+        }
 
         /* Map EHCI registers */
         void *regs = NULL;
-        int rc = pio_enable_range(reg_range, &regs);
-        if (rc != EOK) {
+        ret = pio_enable_range(&res.mem_ranges.ranges[0], &regs);
+        if (ret != EOK) {
                 usb_log_error("Failed to map registers %p: %s.\n",
-                    RNGABSPTR(*reg_range), str_error(rc));
-                return rc;
-        }
-
-        usb_log_debug2("Registers mapped at: %p.\n", regs);
-
-        const uint32_t hcc_params =
-            *(uint32_t*)(regs + HCC_PARAMS_OFFSET);
-        usb_log_debug("Value of hcc params register: %x.\n", hcc_params);
+                    RNGABSPTR(res.mem_ranges.ranges[0]), str_error(ret));
+                goto clean;
+        }
+
+        usb_log_debug("Registers mapped at: %p.\n", regs);
+
+        ehci_caps_regs_t *ehci_caps = regs;
+
+        const uint32_t hcc_params = EHCI_RD(ehci_caps->hccparams);
+        usb_log_debug2("Value of hcc params register: %x.\n", hcc_params);
 
         /* Read value of EHCI Extended Capabilities Pointer
          * position of EEC registers (points to PCI config space) */
         const uint32_t eecp =
-            (hcc_params >> HCC_PARAMS_EECP_OFFSET) & HCC_PARAMS_EECP_MASK;
-        usb_log_debug("Value of EECP: %x.\n", eecp);
-
-        rc = disable_extended_caps(device, eecp);
-        if (rc != EOK) {
+            (hcc_params >> EHCI_CAPS_HCC_EECP_SHIFT) & EHCI_CAPS_HCC_EECP_MASK;
+        usb_log_debug2("Value of EECP: %x.\n", eecp);
+
+        ret = disable_extended_caps(parent_sess, eecp);
+        if (ret != EOK) {
                 usb_log_error("Failed to disable extended capabilities: %s.\n",
-                    str_error(rc));
-                return rc;
-        }
-
-        /*
-         * TURN OFF EHCI FOR NOW, DRIVER WILL REINITIALIZE IT IF NEEDED
-         */
-
-        /* Get size of capability registers in memory space. */
-        const unsigned operation_offset = *(uint8_t*)regs;
-        usb_log_debug("USBCMD offset: %d.\n", operation_offset);
-
-        /* Zero USBCMD register. */
-        volatile uint32_t *usbcmd =
-            (uint32_t*)((uint8_t*)regs + operation_offset + CMD_OFFSET);
-        volatile uint32_t *usbsts =
-            (uint32_t*)((uint8_t*)regs + operation_offset + STS_OFFSET);
-        volatile uint32_t *usbconf =
-            (uint32_t*)((uint8_t*)regs + operation_offset + CFG_OFFSET);
-        volatile uint32_t *usbint =
-            (uint32_t*)((uint8_t*)regs + operation_offset + INT_OFFSET);
-        usb_log_debug("USBCMD value: %x.\n", *usbcmd);
-        if (*usbcmd & USBCMD_RUN) {
-                *usbsts = 0x3f; /* ack all interrupts */
-                *usbint = 0; /* disable all interrupts */
-                *usbconf = 0; /* release control of RH ports */
-
-                *usbcmd = 0;
-                /* Wait until hc is halted */
-                while ((*usbsts & USBSTS_HALTED) == 0);
-                usb_log_info("EHCI turned off.\n");
-        } else {
-                usb_log_info("EHCI was not running.\n");
-        }
-        usb_log_debug("Registers: \n"
-            "\t USBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
-            "\t USBSTS(%p): %x(0x00001000 = HC halted)\n"
-            "\t USBINT(%p): %x(0x0 = no interrupts).\n"
-            "\t CONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
-            usbcmd, *usbcmd, usbsts, *usbsts, usbint, *usbint, usbconf,*usbconf);
-
-        return rc;
+                    str_error(ret));
+                    goto clean;
+        }
+clean:
+        //TODO unmap registers
+        hw_res_list_parsed_clean(&res);
+        async_hangup(parent_sess);
+        return ret;
 }
 

uspace/drv/bus/usb/ehci/res.h

@@ -39 +39 @@
 #include <device/hw_res_parsed.h>
 
-int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
-int enable_interrupts(ddf_dev_t *);
-int disable_legacy(ddf_dev_t *, addr_range_t *);
+int disable_legacy(ddf_dev_t *);
 
 #endif