usb: find internal hub tier mismatch via acpi

ACPI identifies peer ports by setting their 'group_token' and
'group_position' _PLD data to the same value.  If a platform has tier
mismatch [1] , ACPI can override the default (USB3 defined) peer port
association for internal hubs.  External hubs follow the default peer
association scheme.

Location data is cached as an opaque cookie in usb_port_location data.

Note that we only consider the group_token and group_position attributes
from the _PLD data as ACPI specifies that group_token is a unique
identifier.

When we find port location data for a port then we assume that the
firmware will also describe its peer port.  This allows the
implementation to only ever set the peer once.  This leads to a question
about what happens when a pm runtime event occurs while the peer
associations are still resolving.  Since we only ever set the peer
information once, a USB3 port needs to be prevented from suspending
while its ->peer pointer is NULL (implemented in a subsequent patch).

There is always the possibility that firmware mis-identifies the ports,
but there is not much the kernel can do in that case.

[1]: xhci 1.1 appendix D figure 131
[2]: acpi 5 section 6.1.8

[alan]: don't do default peering when acpi data present
Suggested-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

4 files changed, 83 insertions, 22 deletions

diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index fcad5f9d12f0..048c797f394c 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -84,6 +84,7 @@ struct usb_hub {
  * @port_owner: port's owner
  * @peer: related usb2 and usb3 ports (share the same connector)
  * @connect_type: port's connect type
+ * @location: opaque representation of platform connector location
  * @portnum: port index num based one
  * @power_is_on: port's power state
  * @did_runtime_put: port has done pm_runtime_put().
@@ -94,6 +95,7 @@ struct usb_port {
         struct usb_dev_state *port_owner;
         struct usb_port *peer;
         enum usb_port_connect_type connect_type;
+        usb_port_location_t location;
         u8 portnum;
         unsigned power_is_on:1;
         unsigned did_runtime_put:1;
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index 9b7496b52f2a..aea54e8dfe47 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -188,8 +188,42 @@ static void unlink_peers(struct usb_port *left, struct usb_port *right)
 }
 
 /*
- * Set the default peer port for root hubs, or via the upstream peer
- * relationship for all other hubs
+ * For each usb hub device in the system check to see if it is in the
+ * peer domain of the given port_dev, and if it is check to see if it
+ * has a port that matches the given port by location
+ */
+static int match_location(struct usb_device *peer_hdev, void *p)
+{
+        int port1;
+        struct usb_hcd *hcd, *peer_hcd;
+        struct usb_port *port_dev = p, *peer;
+        struct usb_hub *peer_hub = usb_hub_to_struct_hub(peer_hdev);
+        struct usb_device *hdev = to_usb_device(port_dev->dev.parent->parent);
+
+        if (!peer_hub)
+                return 0;
+
+        hcd = bus_to_hcd(hdev->bus);
+        peer_hcd = bus_to_hcd(peer_hdev->bus);
+        /* peer_hcd is provisional until we verify it against the known peer */
+        if (peer_hcd != hcd->shared_hcd)
+                return 0;
+
+        for (port1 = 1; port1 <= peer_hdev->maxchild; port1++) {
+                peer = peer_hub->ports[port1 - 1];
+                if (peer && peer->location == port_dev->location) {
+                        link_peers(port_dev, peer);
+                        return 1; /* done */
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * Find the peer port either via explicit platform firmware "location"
+ * data, the peer hcd for root hubs, or the upstream peer relationship
+ * for all other hubs.
  */
 static void find_and_link_peer(struct usb_hub *hub, int port1)
 {
@@ -198,7 +232,17 @@ static void find_and_link_peer(struct usb_hub *hub, int port1)
         struct usb_device *peer_hdev;
         struct usb_hub *peer_hub;
 
-        if (!hdev->parent) {
+        /*
+         * If location data is available then we can only peer this port
+         * by a location match, not the default peer (lest we create a
+         * situation where we need to go back and undo a default peering
+         * when the port is later peered by location data)
+         */
+        if (port_dev->location) {
+                /* we link the peer in match_location() if found */
+                usb_for_each_dev(port_dev, match_location);
+                return;
+        } else if (!hdev->parent) {
                 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
                 struct usb_hcd *peer_hcd = hcd->shared_hcd;
 
@@ -225,8 +269,12 @@ static void find_and_link_peer(struct usb_hub *hub, int port1)
         if (!peer_hub || port1 > peer_hdev->maxchild)
                 return;
 
+        /*
+         * we found a valid default peer, last check is to make sure it
+         * does not have location data
+         */
         peer = peer_hub->ports[port1 - 1];
-        if (peer)
+        if (peer && peer->location == 0)
                 link_peers(port_dev, peer);
 }
 
diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
index d3e7e1b4125e..2776cfe64c09 100644
--- a/drivers/usb/core/usb-acpi.c
+++ b/drivers/usb/core/usb-acpi.c
@@ -85,19 +85,13 @@ int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 }
 EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
 
-static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
-        acpi_handle handle, int port1)
+static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
+                struct acpi_pld_info *pld)
 {
         enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
-        struct acpi_pld_info *pld;
         union acpi_object *upc;
         acpi_status status;
-        int ret = 0;
-
-        if (!hub)
-                return 0;
 
         /*
          * According to ACPI Spec 9.13. PLD indicates whether usb port is
@@ -107,15 +101,10 @@ static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
          * a usb device is directly hard-wired to the port. If no visible and
          * no connectable, the port would be not used.
          */
-        status = acpi_get_physical_device_location(handle, &pld);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
         status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
         upc = buffer.pointer;
         if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
                 || upc->package.count != 4) {
-                ret = -EINVAL;
                 goto out;
         }
 
@@ -126,14 +115,18 @@ static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
                         connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
         else if (!pld->user_visible)
                 connect_type = USB_PORT_NOT_USED;
-        hub->ports[port1 - 1]->connect_type = connect_type;
-
 out:
-        ACPI_FREE(pld);
         kfree(upc);
-        return ret;
+        return connect_type;
 }
 
+
+/*
+ * Private to usb-acpi, all the core needs to know is that
+ * port_dev->location is non-zero when it has been set by the firmware.
+ */
+#define USB_ACPI_LOCATION_VALID (1 << 31)
+
 static struct acpi_device *usb_acpi_find_companion(struct device *dev)
 {
         struct usb_device *udev;
@@ -164,6 +157,9 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
         } else if (is_usb_port(dev)) {
                 struct usb_port *port_dev = to_usb_port(dev);
                 int port1 = port_dev->portnum;
+                struct acpi_pld_info *pld;
+                acpi_handle *handle;
+                acpi_status status;
 
                 /* Get the struct usb_device point of port's hub */
                 udev = to_usb_device(dev->parent->parent);
@@ -194,7 +190,16 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
                         if (!adev)
                                 return NULL;
                 }
-                usb_acpi_check_port_connect_type(udev, adev->handle, port1);
+                handle = adev->handle;
+                status = acpi_get_physical_device_location(handle, &pld);
+                if (ACPI_FAILURE(status) || !pld)
+                        return adev;
+
+                port_dev->location = USB_ACPI_LOCATION_VALID
+                        | pld->group_token << 8 | pld->group_position;
+                port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
+                ACPI_FREE(pld);
+
                 return adev;
         }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 6afa738b5ba4..98dc08e13448 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -171,6 +171,12 @@ extern void usbfs_conn_disc_event(void);
 extern int usb_devio_init(void);
 extern void usb_devio_cleanup(void);
 
+/*
+ * Firmware specific cookie identifying a port's location. '0' == no location
+ * data available
+ */
+typedef u32 usb_port_location_t;
+
 /* internal notify stuff */
 extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);