Changeset 56db65d in mainline for uspace/lib/usbhost/src

Timestamp:

2017-10-24T11:06:32Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

0206d35

Parents:

894f58c

Message:

usbhost: provide usb_endpoint_desc_t to bus when registering endpoint

This finishes the path of arbitrary information fetched from device all the way down to registering the endpoint in the bus.

Location:

uspace/lib/usbhost/src

Files:

• bus.c (modified) (4 diffs)
• ddf_helpers.c (modified) (2 diffs)
• hcd.c (modified) (3 diffs)
• usb2_bus.c (modified) (7 diffs)

uspace/lib/usbhost/src/bus.c

@@ -66 +66 @@
 }
 
-int bus_add_ep(bus_t *bus, device_t *device, usb_endpoint_t endpoint,
-    usb_direction_t dir, usb_transfer_type_t type, size_t max_packet_size,
-    unsigned packets, size_t size)
+int bus_add_ep(bus_t *bus, device_t *device, const usb_endpoint_desc_t *desc)
 {
         assert(bus);
@@ -78 +76 @@
                 return ENOMEM;
 
-        ep->target = (usb_target_t) {
-                .address = device->address,
-                .endpoint = endpoint,
-        };
-
         ep->device = device;
-        ep->direction = dir;
-        ep->transfer_type = type;
-        ep->max_packet_size = max_packet_size;
-        ep->packets = packets;
-
-        ep->bandwidth = bus_count_bw(ep, size);
-
-        const int err = bus_register_endpoint(bus, ep);
+        const int err = bus_register_endpoint(bus, ep, desc);
 
         /* drop Temporary reference */
@@ -165 +151 @@
 }
 
-int bus_register_endpoint(bus_t *bus, endpoint_t *ep)
+int bus_register_endpoint(bus_t *bus, endpoint_t *ep, const usb_endpoint_desc_t *desc)
 {
         assert(bus);
@@ -174 +160 @@
 
         fibril_mutex_lock(&bus->guard);
-        const int r = bus->ops.register_endpoint(bus, ep);
+        const int r = bus->ops.register_endpoint(bus, ep, desc);
         fibril_mutex_unlock(&bus->guard);
 

uspace/lib/usbhost/src/ddf_helpers.c

@@ -98 +98 @@
         assert(dev);
 
-        const size_t size = endpoint_desc->max_packet_size;
-
         usb_log_debug("Register endpoint %d:%d %s-%s %zuB %ums.\n",
                 dev->address, endpoint_desc->endpoint_no,
@@ -106 +104 @@
                 endpoint_desc->max_packet_size, endpoint_desc->usb2.polling_interval);
 
-        // FIXME: we now have max_streams and max_burst in endpoint_desc->usb3 struct
-        // Hand it down to XHCI, refactor, whatever
-
-        return bus_add_ep(hcd->bus, dev, endpoint_desc->endpoint_no,
-                endpoint_desc->direction, endpoint_desc->transfer_type,
-                endpoint_desc->max_packet_size, endpoint_desc->packets,
-                size);
+        return bus_add_ep(hcd->bus, dev, endpoint_desc);
 }
 

uspace/lib/usbhost/src/hcd.c

@@ -87 +87 @@
         assert(device->address == target.address);
 
+        if (!hcd->ops.schedule) {
+                usb_log_error("HCD does not implement scheduler.\n");
+                return ENOTSUP;
+        }
+
         endpoint_t *ep = bus_find_endpoint(hcd->bus, device, target, direction);
         if (ep == NULL) {
@@ -93 +98 @@
                 return ENOENT;
         }
+
+        // TODO cut here aka provide helper to call with instance of endpoint_t in hand
 
         usb_log_debug2("%s %d:%d %zu(%zu).\n",
@@ -104 +111 @@
                     ep->target.address, ep->target.endpoint, name, bw, ep->bandwidth);
                 return ENOSPC;
-        }
-        if (!hcd->ops.schedule) {
-                usb_log_error("HCD does not implement scheduler.\n");
-                return ENOTSUP;
         }
 

uspace/lib/usbhost/src/usb2_bus.c

@@ -91 +91 @@
 }
 
+static const usb_endpoint_desc_t usb2_default_control_ep = {
+        .endpoint_no = 0,
+        .transfer_type = USB_TRANSFER_CONTROL,
+        .direction = USB_DIRECTION_BOTH,
+        .max_packet_size = CTRL_PIPE_MIN_PACKET_SIZE,
+        .packets = 1,
+};
+
+
+static const usb_target_t usb2_default_target = {{
+        .address = USB_ADDRESS_DEFAULT,
+        .endpoint = 0,
+}};
+
 static int usb2_bus_address_device(bus_t *bus, hcd_t *hcd, device_t *dev)
 {
         int err;
-
-        static const usb_target_t default_target = {{
-                .address = USB_ADDRESS_DEFAULT,
-                .endpoint = 0,
-        }};
 
         /** Reserve address early, we want pretty log messages */
@@ -111 +120 @@
         /* Add default pipe on default address */
         usb_log_debug("Device(%d): Adding default target (0:0)", address);
-        err = bus_add_ep(bus, dev, 0, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
-            CTRL_PIPE_MIN_PACKET_SIZE, CTRL_PIPE_MIN_PACKET_SIZE, 1);
+        err = bus_add_ep(bus, dev, &usb2_default_control_ep);
         if (err != EOK) {
                 usb_log_error("Device(%d): Failed to add default target: %s.",
@@ -126 +134 @@
         usb_log_debug("Device(%d): Requesting first 8B of device descriptor.",
             address);
-        ssize_t got = hcd_send_batch_sync(hcd, dev, default_target, USB_DIRECTION_IN,
+        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");
@@ -134 +142 @@
                 usb_log_error("Device(%d): Failed to get 8B of dev descr: %s.",
                     address, str_error(err));
-                goto err_default_target;
+                goto err_default_control_ep;
         }
 
@@ -141 +149 @@
 
         usb_log_debug("Device(%d): Setting USB address.", address);
-        err = hcd_send_batch_sync(hcd, dev, default_target, USB_DIRECTION_OUT,
+        err = hcd_send_batch_sync(hcd, dev, usb2_default_target, USB_DIRECTION_OUT,
             NULL, 0, *(uint64_t *)&set_address, "set address");
         if (err != 0) {
                 usb_log_error("Device(%d): Failed to set new address: %s.",
                     address, str_error(got));
-                goto err_default_target;
+                goto err_default_control_ep;
         }
 
         dev->address = address;
+
+        const usb_endpoint_desc_t control_ep = {
+                .endpoint_no = 0,
+                .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)),
+        };
 
         /* Register EP on the new address */
         usb_log_debug("Device(%d): Registering control EP.", address);
-        err = bus_add_ep(bus, dev, 0, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
-            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
-            ED_MPS_TRANS_OPPORTUNITIES_GET(uint16_usb2host(desc.max_packet_size)),
-            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)));
+        err = bus_add_ep(bus, dev, &control_ep);
         if (err != EOK) {
                 usb_log_error("Device(%d): Failed to register EP0: %s",
                     address, str_error(err));
-                goto err_default_target;
-        }
-
-        bus_remove_ep(bus, dev, default_target, USB_DIRECTION_BOTH);
-        return EOK;
-
-err_default_target:
-        bus_remove_ep(bus, dev, default_target, USB_DIRECTION_BOTH);
+                goto err_default_control_ep;
+        }
+
+        bus_remove_ep(bus, dev, usb2_default_target, USB_DIRECTION_BOTH);
+        return EOK;
+
+err_default_control_ep:
+        bus_remove_ep(bus, dev, usb2_default_target, USB_DIRECTION_BOTH);
 err_address:
         bus_release_address(bus, address);
@@ -278 +291 @@
  * @param endpoint USB endpoint number.
  */
-static int usb2_bus_register_ep(bus_t *bus_base, endpoint_t *ep)
+static int usb2_bus_register_ep(bus_t *bus_base, endpoint_t *ep, const usb_endpoint_desc_t *desc)
 {
         usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
         assert(ep);
 
-        usb_address_t address = ep->target.address;
-
-        if (!usb_address_is_valid(address))
-                return EINVAL;
-
-        /* Check for speed and address */
-        if (!bus->devices[address].occupied)
-                return ENOENT;
+        assert(ep->device);
+
+        /* Extract USB2-related information from endpoint_desc */
+        ep->target = (usb_target_t) {{
+                .address = ep->device->address,
+                .endpoint = desc->endpoint_no,
+        }};
+        ep->direction = desc->direction;
+        ep->transfer_type = desc->transfer_type;
+        ep->max_packet_size = desc->max_packet_size;
+        ep->packets = desc->packets;
+
+        ep->bandwidth = bus_base->ops.count_bw(ep, desc->max_packet_size);
 
         /* Check for existence */
@@ -300 +318 @@
                 return ENOSPC;
 
-        list_append(&ep->link, get_list(bus, ep->target.address));
+        list_append(&ep->link, get_list(bus, ep->device->address));
         bus->free_bw -= ep->bandwidth;