Changeset 1ed3eb4 in mainline

Timestamp:

2018-01-13T19:13:04Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

2489353

Parents:

001778c

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-13 19:12:34)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-01-13 19:13:04)

Message:

usbhost: endpoint is identified also by its direction

Location:

uspace

Files:

• drv/bus/usb/xhci/bus.c (modified) (1 diff)
• drv/bus/usb/xhci/endpoint.c (modified) (1 diff)
• drv/bus/usb/xhci/endpoint.h (modified) (1 diff)
• drv/bus/usb/xhci/isoch.c (modified) (3 diffs)
• drv/bus/usb/xhci/isoch.h (modified) (1 diff)
• drv/bus/usb/xhci/transfers.c (modified) (4 diffs)
• lib/usbhost/include/usb/host/bus.h (modified) (2 diffs)
• lib/usbhost/src/bus.c (modified) (5 diffs)
• lib/usbhost/src/ddf_helpers.c (modified) (1 diff)

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

@@ -116 +116 @@
                 return err;
 
-        xhci_endpoint_t *ep0 = xhci_device_get_endpoint(dev, 0);
+        xhci_endpoint_t *ep0 = xhci_endpoint_get(dev->base.endpoints[0]);
         assert(ep0);
 

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

@@ -443 +443 @@
 }
 
-/** Retrieve XHCI endpoint from a device by the endpoint number.
- * @param[in] dev XHCI device to query.
- * @param[in] ep Endpoint number identifying the endpoint to retrieve.
- *
- * @return XHCI endpoint with the specified number or NULL if no such endpoint exists.
- */
-xhci_endpoint_t *xhci_device_get_endpoint(xhci_device_t *dev, usb_endpoint_t ep)
-{
-        endpoint_t *ep_base = dev->base.endpoints[ep];
-        if (!ep_base)
-                return NULL;
-
-        return xhci_endpoint_get(ep_base);
-}
-
 /**
  * @}

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

@@ -139 +139 @@
 void xhci_setup_endpoint_context(xhci_endpoint_t *, xhci_ep_ctx_t *);
 
-xhci_endpoint_t * xhci_device_get_endpoint(xhci_device_t *, usb_endpoint_t);
-
 static inline xhci_device_t * xhci_device_get(device_t *dev)
 {

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

@@ -572 +572 @@
 }
 
-int isoch_handle_transfer_event(xhci_hc_t *hc, xhci_endpoint_t *ep, xhci_trb_t *trb)
+void isoch_handle_transfer_event(xhci_hc_t *hc, xhci_endpoint_t *ep, xhci_trb_t *trb)
 {
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
@@ -591 +591 @@
                         fibril_condvar_broadcast(&ep->isoch->avail);
                         fibril_mutex_unlock(&ep->isoch->guard);
-                        return EOK;
+                        goto out;
                 case XHCI_TRBC_SHORT_PACKET:
                 case XHCI_TRBC_SUCCESS:
@@ -641 +641 @@
         timer_schedule_reset(ep);
 
+out:
         fibril_condvar_broadcast(&ep->isoch->avail);
         fibril_mutex_unlock(&ep->isoch->guard);
-        return EOK;
 }
 

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

@@ -123 +123 @@
 int isoch_schedule_out(xhci_transfer_t *);
 int isoch_schedule_in(xhci_transfer_t *);
-int isoch_handle_transfer_event(xhci_hc_t *, xhci_endpoint_t *, xhci_trb_t *);
+void isoch_handle_transfer_event(xhci_hc_t *, xhci_endpoint_t *, xhci_trb_t *);
 
 #endif

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

@@ -258 +258 @@
 
         const usb_endpoint_t ep_num = ep_dci / 2;
-        xhci_endpoint_t *ep = xhci_device_get_endpoint(dev, ep_num);
-        if (!ep) {
-                usb_log_error("Transfer event on dropped endpoint %u of device "
-                    XHCI_DEV_FMT, ep_num, XHCI_DEV_ARGS(*dev));
+        const usb_endpoint_t dir = ep_dci % 2 ? USB_DIRECTION_IN : USB_DIRECTION_OUT;
+        endpoint_t *ep_base = bus_find_endpoint(&dev->base, ep_num, dir);
+        if (!ep_base) {
+                usb_log_error("Transfer event on dropped endpoint %u %s of device "
+                    XHCI_DEV_FMT, ep_num, usb_str_direction(dir), XHCI_DEV_ARGS(*dev));
                 return ENOENT;
         }
-        // No need to add reference for endpoint, it is held by the transfer batch.
+        xhci_endpoint_t *ep = xhci_endpoint_get(ep_base);
 
         /* FIXME: This is racy. Do we care? */
@@ -270 +271 @@
 
         if (ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS) {
-                return isoch_handle_transfer_event(hc, ep, trb);
+                isoch_handle_transfer_event(hc, ep, trb);
+                endpoint_del_ref(&ep->base);
+                return EOK;
         }
 
@@ -277 +280 @@
         if (!batch) {
                 fibril_mutex_unlock(&ep->base.guard);
+                endpoint_del_ref(&ep->base);
                 return ENOENT;
         }
@@ -305 +309 @@
 
         usb_transfer_batch_finish(batch);
+        endpoint_del_ref(&ep->base);
         return EOK;
 }

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

@@ -76 +76 @@
         usb_speed_t speed;
         usb_address_t address;
-        endpoint_t *endpoints [USB_ENDPOINT_MAX];
+        endpoint_t *endpoints [2 * USB_ENDPOINT_MAX];
 
         /* Managing bus */
@@ -163 +163 @@
 
 int bus_endpoint_add(device_t *, const usb_endpoint_descriptors_t *, endpoint_t **);
-endpoint_t *bus_find_endpoint(device_t *, usb_endpoint_t);
+endpoint_t *bus_find_endpoint(device_t *, usb_endpoint_t, usb_direction_t);
 int bus_endpoint_remove(endpoint_t *);
 

uspace/lib/usbhost/src/bus.c

@@ -307 +307 @@
 err:
         return rc;
+}
+
+/**
+ * Calculate an index to the endpoint array.
+ * For the default control endpoint 0, it must return 0.
+ * For different arguments, the result is stable but not defined.
+ */
+static int bus_endpoint_index(usb_endpoint_t ep, usb_direction_t dir)
+{
+        return 2 * ep + (dir == USB_DIRECTION_OUT);
 }
 
@@ -357 +367 @@
             ep->max_transfer_size);
 
+        const int idx = bus_endpoint_index(ep->endpoint, ep->direction);
+
         fibril_mutex_lock(&device->guard);
         if (!device->online && ep->endpoint != 0) {
                 err = EAGAIN;
-        } else if (device->endpoints[ep->endpoint] != NULL) {
+        } else if (device->endpoints[idx] != NULL) {
                 err = EEXIST;
         } else {
                 err = register_ops->endpoint_register(ep);
                 if (!err)
-                        device->endpoints[ep->endpoint] = ep;
+                        device->endpoints[idx] = ep;
         }
         fibril_mutex_unlock(&device->guard);
@@ -385 +397 @@
  * Search for an endpoint. Returns a reference.
  */
-endpoint_t *bus_find_endpoint(device_t *device, usb_endpoint_t endpoint)
+endpoint_t *bus_find_endpoint(device_t *device, usb_endpoint_t endpoint, usb_direction_t dir)
 {
         assert(device);
 
+        const int idx = bus_endpoint_index(endpoint, dir);
+        const int ctrl_idx = bus_endpoint_index(endpoint, USB_DIRECTION_BOTH);
+
         fibril_mutex_lock(&device->guard);
-        endpoint_t *ep = device->endpoints[endpoint];
+        endpoint_t *ep = device->endpoints[idx];
+        /*
+         * If the endpoint was not found, it's still possible it is a control
+         * endpoint having direction BOTH.
+         */
+        if (!ep) {
+                ep = device->endpoints[ctrl_idx];
+                if (ep && ep->transfer_type != USB_TRANSFER_CONTROL)
+                        ep = NULL;
+        }
         if (ep) {
                 /* Exporting reference */
@@ -423 +447 @@
             ep->max_transfer_size);
 
+        const int idx = bus_endpoint_index(ep->endpoint, ep->direction);
+
         fibril_mutex_lock(&device->guard);
         ops->endpoint_unregister(ep);
-        device->endpoints[ep->endpoint] = NULL;
+        device->endpoints[idx] = NULL;
         fibril_mutex_unlock(&device->guard);
 
@@ -489 +515 @@
 
         /* Temporary reference */
-        endpoint_t *ep = bus_find_endpoint(device, target.endpoint);
+        endpoint_t *ep = bus_find_endpoint(device, target.endpoint, direction);
         if (ep == NULL) {
                 usb_log_error("Endpoint(%d:%d) not registered for %s.\n",

uspace/lib/usbhost/src/ddf_helpers.c

@@ -111 +111 @@
         assert(dev);
 
-        endpoint_t *ep = bus_find_endpoint(dev, pipe_desc->endpoint_no);
+        endpoint_t *ep = bus_find_endpoint(dev, pipe_desc->endpoint_no, pipe_desc->direction);
         if (!ep)
                 return ENOENT;