Changeset 741bcdeb in mainline

Timestamp:

2017-10-13T09:21:22Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

c0e4b5b2

Parents:

e6b9182

Message:

WIP usbhost refactoring: ehci completed

vhc to go…

Location:

uspace/drv/bus/usb

Files:

• ehci/Makefile (modified) (1 diff)
• ehci/ehci_batch.c (modified) (1 diff)
• ehci/ehci_bus.c (moved) (moved from uspace/drv/bus/usb/ehci/ehci_endpoint.c ) (7 diffs)
• ehci/ehci_bus.h (moved) (moved from uspace/drv/bus/usb/ehci/ehci_endpoint.h ) (5 diffs)
• ehci/ehci_rh.c (modified) (2 diffs)
• ehci/endpoint_list.h (modified) (1 diff)
• ehci/hc.c (modified) (4 diffs)
• ehci/hc.h (modified) (1 diff)
• ehci/hw_struct/queue_head.c (modified) (1 diff)
• ehci/main.c (modified) (4 diffs)
• ohci/ohci_bus.c (modified) (1 diff)

uspace/drv/bus/usb/ehci/Makefile

@@ -46 +46 @@
 SOURCES = \
         ehci_batch.c \
-        ehci_endpoint.c \
+        ehci_bus.c \
         ehci_rh.c \
         endpoint_list.c \

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

@@ -45 +45 @@
 
 #include "ehci_batch.h"
-#include "ehci_endpoint.h"
+#include "ehci_bus.h"
 
 /* The buffer pointer list in the qTD is long enough to support a maximum

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

@@ -1 +1 @@
 /*
- * Copyright (c) 2014 Jan Vesely
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /** @addtogroup drvusbehci
  * @{
@@ -35 +36 @@
 #include <assert.h>
 #include <stdlib.h>
+#include <usb/host/utils/malloc32.h>
+#include <usb/host/bandwidth.h>
 #include <usb/debug.h>
-#include <usb/host/utils/malloc32.h>
 
-#include "ehci_endpoint.h"
+#include "ehci_bus.h"
 #include "hc.h"
 
@@ -46 +48 @@
  * @param[in] toggle new value of toggle bit
  */
-static void ehci_ep_toggle_set(void *ehci_ep, int toggle)
+static void ehci_ep_toggle_set(endpoint_t *ep, bool toggle)
 {
-        ehci_endpoint_t *instance = ehci_ep;
+        ehci_endpoint_t *instance = ehci_endpoint_get(ep);
         assert(instance);
         assert(instance->qh);
+        ep->toggle = toggle;
         if (qh_toggle_from_td(instance->qh))
                 usb_log_warning("EP(%p): Setting toggle bit for transfer "
@@ -62 +65 @@
  * @return Current value of toggle bit.
  */
-static int ehci_ep_toggle_get(void *ehci_ep)
+static bool ehci_ep_toggle_get(endpoint_t *ep)
 {
-        ehci_endpoint_t *instance = ehci_ep;
+        ehci_endpoint_t *instance = ehci_endpoint_get(ep);
         assert(instance);
         assert(instance->qh);
+
         if (qh_toggle_from_td(instance->qh))
                 usb_log_warning("EP(%p): Reading useless toggle bit", instance);
@@ -73 +77 @@
 
 /** Creates new hcd endpoint representation.
- *
- * @param[in] ep USBD endpoint structure
- * @return Error code.
  */
-int ehci_endpoint_init(hcd_t *hcd, endpoint_t *ep)
+static endpoint_t *ehci_endpoint_create(bus_t *bus)
 {
-        assert(ep);
-        hc_t *hc = hcd_get_driver_data(hcd);
+        assert(bus);
 
         ehci_endpoint_t *ehci_ep = malloc(sizeof(ehci_endpoint_t));
         if (ehci_ep == NULL)
-                return ENOMEM;
+                return NULL;
+
+        endpoint_init(&ehci_ep->base, bus);
 
         ehci_ep->qh = malloc32(sizeof(qh_t));
         if (ehci_ep->qh == NULL) {
                 free(ehci_ep);
-                return ENOMEM;
+                return NULL;
         }
 
-        usb_log_debug2("EP(%p): Creating for %p", ehci_ep, ep);
         link_initialize(&ehci_ep->link);
-        qh_init(ehci_ep->qh, ep);
-        endpoint_set_hc_data(
-            ep, ehci_ep, ehci_ep_toggle_get, ehci_ep_toggle_set);
-        hc_enqueue_endpoint(hc, ep);
         return EOK;
 }
@@ -106 +103 @@
  * @param[in] ep endpoint structure.
  */
-void ehci_endpoint_fini(hcd_t *hcd, endpoint_t *ep)
+static void ehci_endpoint_destroy(endpoint_t *ep)
 {
-        assert(hcd);
         assert(ep);
-        hc_t *hc = hcd_get_driver_data(hcd);
+        ehci_endpoint_t *instance = ehci_endpoint_get(ep);
 
-        ehci_endpoint_t *instance = ehci_endpoint_get(ep);
-        hc_dequeue_endpoint(hc, ep);
-        endpoint_clear_hc_data(ep);
-        usb_log_debug2("EP(%p): Destroying for %p", instance, ep);
-        if (instance) {
-                free32(instance->qh);
-                free(instance);
-        }
+        free32(instance->qh);
+        free(instance);
 }
+
+
+static int ehci_register_ep(bus_t *bus_base, endpoint_t *ep)
+{
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
+
+        const int err = bus->parent_ops.register_endpoint(bus_base, ep);
+        if (err)
+                return err;
+
+        qh_init(ehci_ep->qh, ep);
+        hc_enqueue_endpoint(bus->hc, ep);
+
+        return EOK;
+}
+
+static int ehci_release_ep(bus_t *bus_base, endpoint_t *ep)
+{
+        ehci_bus_t *bus = (ehci_bus_t *) bus_base;
+        assert(bus);
+        assert(ep);
+
+        const int err = bus->parent_ops.release_endpoint(bus_base, ep);
+        if (err)
+                return err;
+
+        hc_dequeue_endpoint(bus->hc, ep);
+        return EOK;
+
+}
+
+int ehci_bus_init(ehci_bus_t *bus, hc_t *hc)
+{
+        assert(hc);
+        assert(bus);
+
+        // FIXME: Implement the USB2 bw counting.
+        usb2_bus_init(&bus->base, BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
+
+        bus_ops_t *ops = &bus->base.base.ops;
+        bus->parent_ops = *ops;
+        ops->create_endpoint = ehci_endpoint_create;
+        ops->destroy_endpoint = ehci_endpoint_destroy;
+        ops->endpoint_set_toggle = ehci_ep_toggle_set;
+        ops->endpoint_get_toggle = ehci_ep_toggle_get;
+
+        ops->register_endpoint = ehci_register_ep;
+        ops->release_endpoint = ehci_release_ep;
+
+        return EOK;
+}
+
 /**
  * @}
  */
-

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2017 Ondrej Hlavaty <aearsis@eideo.cz>
  * All rights reserved.
  *
@@ -32 +33 @@
  * @brief EHCI driver
  */
-#ifndef DRV_EHCI_HCD_ENDPOINT_H
-#define DRV_EHCI_HCD_ENDPOINT_H
+#ifndef DRV_EHCI_HCD_BUS_H
+#define DRV_EHCI_HCD_BUS_H
 
 #include <assert.h>
 #include <adt/list.h>
+#include <usb/host/usb2_bus.h>
 #include <usb/host/endpoint.h>
-#include <usb/host/hcd.h>
 
 #include "hw_struct/queue_head.h"
-#include "hw_struct/transfer_descriptor.h"
 
 /** Connector structure linking ED to to prepared TD. */
 typedef struct ehci_endpoint {
+        /* Inheritance */
+        endpoint_t base;
+
         /** EHCI endpoint descriptor */
         qh_t *qh;
@@ -51 +54 @@
 } ehci_endpoint_t;
 
-int ehci_endpoint_init(hcd_t *hcd, endpoint_t *ep);
-void ehci_endpoint_fini(hcd_t *hcd, endpoint_t *ep);
+typedef struct hc hc_t;
+
+typedef struct {
+        usb2_bus_t base;
+        hc_t *hc;
+
+        /* Stored original ops from base, they are called in our handlers */
+        bus_ops_t parent_ops;
+} ehci_bus_t;
+
+int ehci_bus_init(ehci_bus_t *, hc_t *);
 
 /** Get and convert assigned ehci_endpoint_t structure
@@ -61 +73 @@
 {
         assert(ep);
-        return ep->hc_data.data;
+        return (ehci_endpoint_t *) ep;
 }
 
@@ -73 +85 @@
  * @}
  */
-

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

@@ -144 +144 @@
         assert(instance);
         assert(batch);
-        const usb_target_t target = {{
-                .address = batch->ep->address,
-                .endpoint = batch->ep->endpoint,
-        }};
+        const usb_target_t target = batch->ep->target;
         batch->error = virthub_base_request(&instance->base, target,
             usb_transfer_batch_direction(batch), (void*)batch->setup_buffer,
@@ -183 +180 @@
             instance, batch);
         if (batch) {
-                const usb_target_t target = {{
-                        .address = batch->ep->address,
-                        .endpoint = batch->ep->endpoint,
-                }};
+                const usb_target_t target = batch->ep->target;
                 batch->error = virthub_base_request(&instance->base, target,
                     usb_transfer_batch_direction(batch),

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

@@ -40 +40 @@
 #include <usb/host/utils/malloc32.h>
 
-#include "ehci_endpoint.h"
+#include "ehci_bus.h"
 #include "hw_struct/queue_head.h"
 

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

@@ -190 +190 @@
             &instance->rh, instance->caps, instance->registers, "ehci rh");
 
+        ehci_bus_init(&instance->bus, instance);
         return EOK;
 }
@@ -214 +215 @@
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
         usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+            ep->target.address, ep->target.endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -238 +239 @@
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
         usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
-            ep->address, ep->endpoint,
+            ep->target.address, ep->target.endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
@@ -290 +291 @@
 
         /* Check for root hub communication */
-        if (batch->ep->address == ehci_rh_get_address(&instance->rh)) {
+        if (batch->ep->target.address == ehci_rh_get_address(&instance->rh)) {
                 usb_log_debug("HC(%p): Scheduling BATCH(%p) for RH(%p)",
                     instance, batch, &instance->rh);

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

@@ -80 +80 @@
         /** USB hub emulation structure */
         ehci_rh_t rh;
+
+        /** USB bookkeeping */
+        ehci_bus_t bus;
 } hc_t;
 

uspace/drv/bus/usb/ehci/hw_struct/queue_head.c

@@ -65 +65 @@
         assert(ep->speed < ARRAY_SIZE(speed));
         EHCI_MEM32_WR(instance->ep_char,
-            QH_EP_CHAR_ADDR_SET(ep->address) |
-            QH_EP_CHAR_EP_SET(ep->endpoint) |
+            QH_EP_CHAR_ADDR_SET(ep->target.address) |
+            QH_EP_CHAR_EP_SET(ep->target.endpoint) |
             speed[ep->speed] |
             QH_EP_CHAR_MAX_LENGTH_SET(ep->max_packet_size)

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

@@ -48 +48 @@
 #include "res.h"
 #include "hc.h"
-#include "ehci_endpoint.h"
 
 #define NAME "ehci"
@@ -67 +66 @@
         .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,
@@ -86 +83 @@
         const int ret = hc_init(instance, res);
         if (ret == EOK) {
-                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops);
+                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops, &instance->bus.base.base);
         } else {
                 free(instance);
@@ -116 +113 @@
 
         free(hc);
-        hcd_set_implementation(hcd, NULL, NULL);
+        hcd_set_implementation(hcd, NULL, NULL, NULL);
 }
 

uspace/drv/bus/usb/ohci/ohci_bus.c

@@ -78 +78 @@
         if (ohci_ep == NULL)
                 return NULL;
+
+        endpoint_init(&ohci_ep->base, bus);
 
         ohci_ep->ed = malloc32(sizeof(ed_t));