Changeset 306a36d in mainline

Timestamp:

2017-11-19T23:43:31Z (7 years ago)

Author:

Aearsis <Hlavaty.Ondrej@…>

Branches:

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

Children:

ff14aede

Parents:

e76c0ea

Message:

xhci: configuration of endpoint 0

Moved fetching of the first 8B of device descriptor from usb2_bus to
hcd, and using it in xhci bus. Also, the value was previously read wrong
by the endpoint descriptor macros, although the value is raw in the
device descriptor - now fixed.

Location:

uspace

Files:

• drv/bus/usb/ehci/hc.c (modified) (1 diff)
• drv/bus/usb/xhci/bus.c (modified) (4 diffs)
• drv/bus/usb/xhci/hc.c (modified) (2 diffs)
• drv/bus/usb/xhci/hc.h (modified) (1 diff)
• lib/usbhost/include/usb/host/hcd.h (modified) (1 diff)
• lib/usbhost/src/hcd.c (modified) (3 diffs)
• lib/usbhost/src/usb2_bus.c (modified) (3 diffs)

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

@@ -238 +238 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) dequeue EP(%d:%d:%s:%s)\n", instance,
-            ep->device->address, ep->endpoint,
+        usb_log_debug("HC(%p) dequeue EP(?:%d:%s:%s)\n", instance,
+            ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));

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

@@ -50 +50 @@
 
 
-/* FIXME Are these really static? Older HCs fetch it from descriptor. */
-/* FIXME Add USB3 options, if applicable. */
-static const usb_endpoint_desc_t ep0_desc = {
+static const usb_endpoint_desc_t ep0_initial_desc = {
         .endpoint_no = 0,
         .direction = USB_DIRECTION_BOTH,
@@ -97 +95 @@
         xhci_endpoint_t *ep0 = xhci_endpoint_get(ep0_base);
 
-        if ((err = prepare_endpoint(ep0, &ep0_desc)))
+        if ((err = prepare_endpoint(ep0, &ep0_initial_desc)))
                 goto err_ep;
 
@@ -124 +122 @@
 }
 
+static int setup_ep0_packet_size(xhci_hc_t *hc, xhci_device_t *dev)
+{
+        int err;
+
+        uint16_t max_packet_size;
+        if ((err = hcd_get_ep0_max_packet_size(&max_packet_size, hc->hcd, &dev->base)))
+                return err;
+
+        xhci_endpoint_t *ep0 = dev->endpoints[0];
+        assert(ep0);
+
+        if (ep0->base.max_packet_size == max_packet_size)
+                return EOK;
+
+        ep0->base.max_packet_size = max_packet_size;
+
+        xhci_ep_ctx_t ep_ctx;
+        xhci_setup_endpoint_context(ep0, &ep_ctx);
+
+        if ((err = hc_update_endpoint(hc, dev->slot_id, 0, &ep_ctx)))
+                return err;
+
+        return EOK;
+}
+
 int xhci_bus_enumerate_device(xhci_bus_t *bus, xhci_hc_t *hc, device_t *dev)
 {
@@ -160 +183 @@
         }
 
-        // TODO: Fetch descriptor of EP0 and reconfigure it accordingly
-        assert(xhci_dev->endpoints[0]);
+        if ((err = setup_ep0_packet_size(hc, xhci_dev))) {
+                usb_log_error("Failed to setup control endpoint of the new device: %s", str_error(err));
+                goto err_address;
+        }
 
         assert(bus->devices_by_slot[xhci_dev->slot_id] == NULL);

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

@@ -651 +651 @@
 }
 
-// TODO: This currently assumes the device is attached to rh directly
-//      -> calculate route string
 int hc_address_device(xhci_hc_t *hc, xhci_device_t *dev, xhci_endpoint_t *ep0)
 {
@@ -767 +765 @@
 }
 
+int hc_update_endpoint(xhci_hc_t *hc, uint32_t slot_id, uint8_t ep_idx, xhci_ep_ctx_t *ep_ctx)
+{
+        dma_buffer_t ictx_dma_buf;
+        const int err = dma_buffer_alloc(&ictx_dma_buf, sizeof(xhci_input_ctx_t));
+        if (err)
+                return err;
+
+        xhci_input_ctx_t *ictx = ictx_dma_buf.virt;
+        memset(ictx, 0, sizeof(xhci_input_ctx_t));
+
+        XHCI_INPUT_CTRL_CTX_ADD_SET(ictx->ctrl_ctx, ep_idx + 1);
+        memcpy(&ictx->endpoint_ctx[ep_idx], ep_ctx, sizeof(xhci_ep_ctx_t));
+
+        return xhci_cmd_sync_inline(hc, EVALUATE_CONTEXT, .slot_id = slot_id, .input_ctx = ictx_dma_buf);
+}
+
 /**
  * @}

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

@@ -110 +110 @@
 int hc_add_endpoint(xhci_hc_t *, uint32_t, uint8_t, xhci_ep_ctx_t *);
 int hc_drop_endpoint(xhci_hc_t *, uint32_t, uint8_t);
+int hc_update_endpoint(xhci_hc_t *, uint32_t, uint8_t, xhci_ep_ctx_t *);
 
 #endif

uspace/lib/usbhost/include/usb/host/hcd.h

@@ -102 +102 @@
 }
 
+extern int hcd_get_ep0_max_packet_size(uint16_t *, hcd_t *, device_t *);
+
 extern int hcd_send_batch(hcd_t *, device_t *, usb_target_t,
     usb_direction_t direction, char *, size_t, uint64_t,

uspace/lib/usbhost/src/hcd.c

@@ -35 +35 @@
 
 #include <usb/debug.h>
+#include <usb/descriptor.h>
 #include <usb/request.h>
 
@@ -40 +41 @@
 #include <async.h>
 #include <errno.h>
+#include <macros.h>
 #include <usb_iface.h>
 #include <str_error.h>
@@ -59 +61 @@
         hcd_set_implementation(hcd, NULL, NULL, NULL);
 }
+
+/** Get max packet size for the control endpoint 0.
+ *
+ * For LS, HS, and SS devices this value is fixed. For FS devices we must fetch
+ * the first 8B of the device descriptor to determine it.
+ *
+ * @return Combined value of max_packet_size and scheduling oppertunities,
+ *      see usb_standard_device_descriptor_t.
+ */
+int hcd_get_ep0_max_packet_size(uint16_t *mps, hcd_t *hcd, device_t *dev)
+{
+        static const uint16_t mps_fixed [] = {
+                [USB_SPEED_LOW] = 8,
+                [USB_SPEED_HIGH] = 64,
+                [USB_SPEED_SUPER] = 512,
+        };
+
+        if (dev->speed < ARRAY_SIZE(mps_fixed) && mps_fixed[dev->speed] != 0) {
+                *mps = mps_fixed[dev->speed];
+                return EOK;
+        }
+
+        const usb_target_t control_ep = {{
+                .address = dev->address,
+                .endpoint = 0,
+        }};
+
+        usb_standard_device_descriptor_t desc = { 0 };
+        const usb_device_request_setup_packet_t get_device_desc_8 =
+            GET_DEVICE_DESC(CTRL_PIPE_MIN_PACKET_SIZE);
+
+        usb_log_debug("Requesting first 8B of device descriptor.");
+        ssize_t got = hcd_send_batch_sync(hcd, dev, control_ep, USB_DIRECTION_IN,
+            (char *) &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
+            "read first 8 bytes of dev descriptor");
+
+        if (got != CTRL_PIPE_MIN_PACKET_SIZE) {
+                const int err = got < 0 ? got : EOVERFLOW;
+                usb_log_error("Failed to get 8B of dev descr: %s.", str_error(err));
+                return err;
+        }
+
+        *mps = uint16_usb2host(desc.max_packet_size);
+        return EOK;
+}
+
 
 /** Prepare generic usb_transfer_batch and schedule it.

uspace/lib/usbhost/src/usb2_bus.c

@@ -132 +132 @@
         }
 
-        /* Get max packet size for default pipe */
-        usb_standard_device_descriptor_t desc = { 0 };
-        const usb_device_request_setup_packet_t get_device_desc_8 =
-            GET_DEVICE_DESC(CTRL_PIPE_MIN_PACKET_SIZE);
-
-        usb_log_debug("Device(%d): Requesting first 8B of device descriptor.",
-            address);
-        ssize_t got = hcd_send_batch_sync(hcd, dev, usb2_default_target, USB_DIRECTION_IN,
-            (char *) &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
-            "read first 8 bytes of dev descriptor");
-
-        if (got != CTRL_PIPE_MIN_PACKET_SIZE) {
-                err = got < 0 ? got : EOVERFLOW;
-                usb_log_error("Device(%d): Failed to get 8B of dev descr: %s.",
-                    address, str_error(err));
-                goto err_default_control_ep;
-        }
+        uint16_t max_packet_size;
+        if ((err = hcd_get_ep0_max_packet_size(&max_packet_size, hcd, dev)))
+                goto err_address;
 
         /* Set new address */
@@ -158 +144 @@
         if (err != 0) {
                 usb_log_error("Device(%d): Failed to set new address: %s.",
-                    address, str_error(got));
+                    address, str_error(err));
                 goto err_default_control_ep;
         }
@@ -175 +161 @@
                 .transfer_type = USB_TRANSFER_CONTROL,
                 .direction = USB_DIRECTION_BOTH,
-                .max_packet_size = ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
-                .packets = ED_MPS_TRANS_OPPORTUNITIES_GET(uint16_usb2host(desc.max_packet_size)),
+                .max_packet_size = max_packet_size,
+                .packets = 1,
         };