2013-01-11 05:10:38 -07:00
|
|
|
/*
|
|
|
|
* usb port device code
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012 Intel Corp
|
|
|
|
*
|
|
|
|
* Author: Lan Tianyu <tianyu.lan@intel.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
* for more details.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2013-01-19 07:30:19 -07:00
|
|
|
#include <linux/slab.h>
|
2013-01-22 13:26:29 -07:00
|
|
|
#include <linux/pm_qos.h>
|
2013-01-19 07:30:19 -07:00
|
|
|
|
2013-01-11 05:10:38 -07:00
|
|
|
#include "hub.h"
|
|
|
|
|
2014-06-17 17:16:27 -06:00
|
|
|
static int usb_port_block_power_off;
|
|
|
|
|
2013-01-19 10:53:32 -07:00
|
|
|
static const struct attribute_group *port_dev_group[];
|
|
|
|
|
2013-08-23 17:05:26 -06:00
|
|
|
static ssize_t connect_type_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2013-01-19 10:53:32 -07:00
|
|
|
{
|
|
|
|
struct usb_port *port_dev = to_usb_port(dev);
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
switch (port_dev->connect_type) {
|
|
|
|
case USB_PORT_CONNECT_TYPE_HOT_PLUG:
|
|
|
|
result = "hotplug";
|
|
|
|
break;
|
|
|
|
case USB_PORT_CONNECT_TYPE_HARD_WIRED:
|
|
|
|
result = "hardwired";
|
|
|
|
break;
|
|
|
|
case USB_PORT_NOT_USED:
|
|
|
|
result = "not used";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = "unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", result);
|
|
|
|
}
|
2013-08-23 17:05:26 -06:00
|
|
|
static DEVICE_ATTR_RO(connect_type);
|
2013-01-19 10:53:32 -07:00
|
|
|
|
|
|
|
static struct attribute *port_dev_attrs[] = {
|
|
|
|
&dev_attr_connect_type.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group port_dev_attr_grp = {
|
|
|
|
.attrs = port_dev_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *port_dev_group[] = {
|
|
|
|
&port_dev_attr_grp,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2013-01-11 05:10:38 -07:00
|
|
|
static void usb_port_device_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct usb_port *port_dev = to_usb_port(dev);
|
|
|
|
|
2014-06-17 17:16:32 -06:00
|
|
|
kfree(port_dev->req);
|
2013-01-11 05:10:38 -07:00
|
|
|
kfree(port_dev);
|
|
|
|
}
|
|
|
|
|
2014-11-29 15:47:05 -07:00
|
|
|
#ifdef CONFIG_PM
|
2013-01-22 13:26:29 -07:00
|
|
|
static int usb_port_runtime_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct usb_port *port_dev = to_usb_port(dev);
|
|
|
|
struct usb_device *hdev = to_usb_device(dev->parent->parent);
|
|
|
|
struct usb_interface *intf = to_usb_interface(dev->parent);
|
2013-01-22 13:26:30 -07:00
|
|
|
struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
|
usb: resume child device when port is powered on
Unconditionally wake up the child device when the power session is
recovered.
This addresses the following scenarios:
1/ The device may need a reset on power-session loss, without this
change port power-on recovery exposes khubd to scenarios that
usb_port_resume() is set to handle. Prior to port power control the
only time a power session would be lost is during dpm_suspend of the
hub. In that scenario usb_port_resume() is guaranteed to be called
prior to khubd running for that port. With this change we wakeup the
child device as soon as possible (prior to khubd running again for this
port).
Although khubd has facilities to wake a child device it will only do
so if the portstatus / portchange indicates a suspend state. In the
case of port power control we are not coming from a hub-port-suspend
state. This implementation simply uses pm_request_resume() to wake the
device and relies on the port_dev->status_lock to prevent any collisions
between khubd and usb_port_resume().
2/ This mechanism rate limits port power toggling. The minimum port
power on/off period is now gated by the child device suspend/resume
latency. Empirically this mitigates devices downgrading their connection
on perceived instability of the host connection. This ratelimiting is
really only relevant to port power control testing, but it is a nice
side effect of closing the above race. Namely, the race of khubd for
the given port running while a usb_port_resume() event is pending.
3/ Going forward we are finding that power-session recovery requires
warm-resets (http://marc.info/?t=138659232900003&r=1&w=2). This
mechanism allows for warm-resets to be requested at the same point in
the resume path for hub dpm_suspend power session losses, or port
rpm_suspend power session losses.
4/ If the device *was* disconnected the only time we'll know for sure is
after a failed resume, so it's necessary for usb_port_runtime_resume()
to expedite a usb_port_resume() to clean up the removed device. The
reasoning for this is "least surprise" for the user. Turning on a port
means that hotplug detection is again enabled for the port, it is
surprising that devices that were removed while the port was off are not
disconnected until they are attempted to be used. As a user "why would
I try to use a device I removed from the system?"
1, 2, and 4 are not a problem in the system dpm_resume() case because,
although the power-session is lost, khubd is frozen until after device
resume. For the rpm_resume() case pm_request_resume() is used to
request re-validation of the device, and if it happens to collide with a
khubd run we rely on the port_dev->status_lock to synchronize those
operations.
Besides testing, the primary scenario where this mechanism is expected
to be triggered is when the user changes the port power policy
(control/pm_qos_no_poweroff, or power/control). Each time power is
enabled want to revalidate the child device, where the revalidation is
handled by usb_port_resume().
Given that this arranges for port_dev->child to be de-referenced in
usb_port_runtime_resume() we need to make sure not to collide with
usb_disconnect() that frees the usb_device. To this end we hold the
port active with the "child_usage" reference across the disconnect
event. Subsequently, the need to access hub->child_usage_bits lead to
the creation of hub_disconnect_children() to remove any ambiguity of
which "hub" is being acted on in usb_disconnect() (prompted-by sharp
eyes from Alan).
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
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>
2014-05-20 19:09:36 -06:00
|
|
|
struct usb_device *udev = port_dev->child;
|
2014-05-20 19:08:57 -06:00
|
|
|
struct usb_port *peer = port_dev->peer;
|
2013-01-22 13:26:30 -07:00
|
|
|
int port1 = port_dev->portnum;
|
2013-01-22 13:26:29 -07:00
|
|
|
int retval;
|
|
|
|
|
2013-01-22 13:26:30 -07:00
|
|
|
if (!hub)
|
|
|
|
return -EINVAL;
|
2014-05-20 19:08:07 -06:00
|
|
|
if (hub->in_reset) {
|
2014-05-20 19:08:52 -06:00
|
|
|
set_bit(port1, hub->power_bits);
|
2014-05-20 19:08:07 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-01-22 13:26:30 -07:00
|
|
|
|
2014-05-20 19:08:57 -06:00
|
|
|
/*
|
|
|
|
* Power on our usb3 peer before this usb2 port to prevent a usb3
|
|
|
|
* device from degrading to its usb2 connection
|
|
|
|
*/
|
|
|
|
if (!port_dev->is_superspeed && peer)
|
|
|
|
pm_runtime_get_sync(&peer->dev);
|
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
usb_autopm_get_interface(intf);
|
2013-06-18 08:28:48 -06:00
|
|
|
retval = usb_hub_set_port_power(hdev, hub, port1, true);
|
2014-05-20 19:08:57 -06:00
|
|
|
msleep(hub_power_on_good_delay(hub));
|
usb: resume child device when port is powered on
Unconditionally wake up the child device when the power session is
recovered.
This addresses the following scenarios:
1/ The device may need a reset on power-session loss, without this
change port power-on recovery exposes khubd to scenarios that
usb_port_resume() is set to handle. Prior to port power control the
only time a power session would be lost is during dpm_suspend of the
hub. In that scenario usb_port_resume() is guaranteed to be called
prior to khubd running for that port. With this change we wakeup the
child device as soon as possible (prior to khubd running again for this
port).
Although khubd has facilities to wake a child device it will only do
so if the portstatus / portchange indicates a suspend state. In the
case of port power control we are not coming from a hub-port-suspend
state. This implementation simply uses pm_request_resume() to wake the
device and relies on the port_dev->status_lock to prevent any collisions
between khubd and usb_port_resume().
2/ This mechanism rate limits port power toggling. The minimum port
power on/off period is now gated by the child device suspend/resume
latency. Empirically this mitigates devices downgrading their connection
on perceived instability of the host connection. This ratelimiting is
really only relevant to port power control testing, but it is a nice
side effect of closing the above race. Namely, the race of khubd for
the given port running while a usb_port_resume() event is pending.
3/ Going forward we are finding that power-session recovery requires
warm-resets (http://marc.info/?t=138659232900003&r=1&w=2). This
mechanism allows for warm-resets to be requested at the same point in
the resume path for hub dpm_suspend power session losses, or port
rpm_suspend power session losses.
4/ If the device *was* disconnected the only time we'll know for sure is
after a failed resume, so it's necessary for usb_port_runtime_resume()
to expedite a usb_port_resume() to clean up the removed device. The
reasoning for this is "least surprise" for the user. Turning on a port
means that hotplug detection is again enabled for the port, it is
surprising that devices that were removed while the port was off are not
disconnected until they are attempted to be used. As a user "why would
I try to use a device I removed from the system?"
1, 2, and 4 are not a problem in the system dpm_resume() case because,
although the power-session is lost, khubd is frozen until after device
resume. For the rpm_resume() case pm_request_resume() is used to
request re-validation of the device, and if it happens to collide with a
khubd run we rely on the port_dev->status_lock to synchronize those
operations.
Besides testing, the primary scenario where this mechanism is expected
to be triggered is when the user changes the port power policy
(control/pm_qos_no_poweroff, or power/control). Each time power is
enabled want to revalidate the child device, where the revalidation is
handled by usb_port_resume().
Given that this arranges for port_dev->child to be de-referenced in
usb_port_runtime_resume() we need to make sure not to collide with
usb_disconnect() that frees the usb_device. To this end we hold the
port active with the "child_usage" reference across the disconnect
event. Subsequently, the need to access hub->child_usage_bits lead to
the creation of hub_disconnect_children() to remove any ambiguity of
which "hub" is being acted on in usb_disconnect() (prompted-by sharp
eyes from Alan).
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
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>
2014-05-20 19:09:36 -06:00
|
|
|
if (udev && !retval) {
|
2013-01-22 13:26:30 -07:00
|
|
|
/*
|
2014-05-29 13:58:46 -06:00
|
|
|
* Our preference is to simply wait for the port to reconnect,
|
|
|
|
* as that is the lowest latency method to restart the port.
|
|
|
|
* However, there are cases where toggling port power results in
|
|
|
|
* the host port and the device port getting out of sync causing
|
|
|
|
* a link training live lock. Upon timeout, flag the port as
|
|
|
|
* needing warm reset recovery (to be performed later by
|
|
|
|
* usb_port_resume() as requested via usb_wakeup_notification())
|
2013-01-22 13:26:30 -07:00
|
|
|
*/
|
2014-05-29 13:58:46 -06:00
|
|
|
if (hub_port_debounce_be_connected(hub, port1) < 0) {
|
|
|
|
dev_dbg(&port_dev->dev, "reconnect timeout\n");
|
|
|
|
if (hub_is_superspeed(hdev))
|
|
|
|
set_bit(port1, hub->warm_reset_bits);
|
|
|
|
}
|
usb: resume child device when port is powered on
Unconditionally wake up the child device when the power session is
recovered.
This addresses the following scenarios:
1/ The device may need a reset on power-session loss, without this
change port power-on recovery exposes khubd to scenarios that
usb_port_resume() is set to handle. Prior to port power control the
only time a power session would be lost is during dpm_suspend of the
hub. In that scenario usb_port_resume() is guaranteed to be called
prior to khubd running for that port. With this change we wakeup the
child device as soon as possible (prior to khubd running again for this
port).
Although khubd has facilities to wake a child device it will only do
so if the portstatus / portchange indicates a suspend state. In the
case of port power control we are not coming from a hub-port-suspend
state. This implementation simply uses pm_request_resume() to wake the
device and relies on the port_dev->status_lock to prevent any collisions
between khubd and usb_port_resume().
2/ This mechanism rate limits port power toggling. The minimum port
power on/off period is now gated by the child device suspend/resume
latency. Empirically this mitigates devices downgrading their connection
on perceived instability of the host connection. This ratelimiting is
really only relevant to port power control testing, but it is a nice
side effect of closing the above race. Namely, the race of khubd for
the given port running while a usb_port_resume() event is pending.
3/ Going forward we are finding that power-session recovery requires
warm-resets (http://marc.info/?t=138659232900003&r=1&w=2). This
mechanism allows for warm-resets to be requested at the same point in
the resume path for hub dpm_suspend power session losses, or port
rpm_suspend power session losses.
4/ If the device *was* disconnected the only time we'll know for sure is
after a failed resume, so it's necessary for usb_port_runtime_resume()
to expedite a usb_port_resume() to clean up the removed device. The
reasoning for this is "least surprise" for the user. Turning on a port
means that hotplug detection is again enabled for the port, it is
surprising that devices that were removed while the port was off are not
disconnected until they are attempted to be used. As a user "why would
I try to use a device I removed from the system?"
1, 2, and 4 are not a problem in the system dpm_resume() case because,
although the power-session is lost, khubd is frozen until after device
resume. For the rpm_resume() case pm_request_resume() is used to
request re-validation of the device, and if it happens to collide with a
khubd run we rely on the port_dev->status_lock to synchronize those
operations.
Besides testing, the primary scenario where this mechanism is expected
to be triggered is when the user changes the port power policy
(control/pm_qos_no_poweroff, or power/control). Each time power is
enabled want to revalidate the child device, where the revalidation is
handled by usb_port_resume().
Given that this arranges for port_dev->child to be de-referenced in
usb_port_runtime_resume() we need to make sure not to collide with
usb_disconnect() that frees the usb_device. To this end we hold the
port active with the "child_usage" reference across the disconnect
event. Subsequently, the need to access hub->child_usage_bits lead to
the creation of hub_disconnect_children() to remove any ambiguity of
which "hub" is being acted on in usb_disconnect() (prompted-by sharp
eyes from Alan).
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
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>
2014-05-20 19:09:36 -06:00
|
|
|
|
|
|
|
/* Force the child awake to revalidate after the power loss. */
|
|
|
|
if (!test_and_set_bit(port1, hub->child_usage_bits)) {
|
|
|
|
pm_runtime_get_noresume(&port_dev->dev);
|
|
|
|
pm_request_resume(&udev->dev);
|
|
|
|
}
|
2013-01-22 13:26:30 -07:00
|
|
|
}
|
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
usb_autopm_put_interface(intf);
|
2014-05-20 19:08:57 -06:00
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int usb_port_runtime_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct usb_port *port_dev = to_usb_port(dev);
|
|
|
|
struct usb_device *hdev = to_usb_device(dev->parent->parent);
|
|
|
|
struct usb_interface *intf = to_usb_interface(dev->parent);
|
2013-01-22 13:26:30 -07:00
|
|
|
struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
|
2014-05-20 19:08:57 -06:00
|
|
|
struct usb_port *peer = port_dev->peer;
|
2013-01-22 13:26:30 -07:00
|
|
|
int port1 = port_dev->portnum;
|
2013-01-22 13:26:29 -07:00
|
|
|
int retval;
|
|
|
|
|
2013-01-22 13:26:30 -07:00
|
|
|
if (!hub)
|
|
|
|
return -EINVAL;
|
2014-05-20 19:08:07 -06:00
|
|
|
if (hub->in_reset)
|
|
|
|
return -EBUSY;
|
2013-01-22 13:26:30 -07:00
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)
|
|
|
|
== PM_QOS_FLAGS_ALL)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2014-06-17 17:16:27 -06:00
|
|
|
if (usb_port_block_power_off)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
usb_autopm_get_interface(intf);
|
2013-06-18 08:28:48 -06:00
|
|
|
retval = usb_hub_set_port_power(hdev, hub, port1, false);
|
2013-01-22 13:26:30 -07:00
|
|
|
usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
|
2014-05-20 19:09:10 -06:00
|
|
|
if (!port_dev->is_superspeed)
|
|
|
|
usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
|
2013-01-22 13:26:29 -07:00
|
|
|
usb_autopm_put_interface(intf);
|
2014-05-20 19:08:57 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Our peer usb3 port may now be able to suspend, so
|
|
|
|
* asynchronously queue a suspend request to observe that this
|
|
|
|
* usb2 port is now off.
|
|
|
|
*/
|
|
|
|
if (!port_dev->is_superspeed && peer)
|
|
|
|
pm_runtime_put(&peer->dev);
|
|
|
|
|
2013-01-22 13:26:29 -07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const struct dev_pm_ops usb_port_pm_ops = {
|
2014-11-29 15:47:05 -07:00
|
|
|
#ifdef CONFIG_PM
|
2013-01-22 13:26:29 -07:00
|
|
|
.runtime_suspend = usb_port_runtime_suspend,
|
|
|
|
.runtime_resume = usb_port_runtime_resume,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2013-01-11 05:10:38 -07:00
|
|
|
struct device_type usb_port_device_type = {
|
|
|
|
.name = "usb_port",
|
|
|
|
.release = usb_port_device_release,
|
2013-01-22 13:26:29 -07:00
|
|
|
.pm = &usb_port_pm_ops,
|
2013-01-11 05:10:38 -07:00
|
|
|
};
|
|
|
|
|
2014-05-20 19:08:17 -06:00
|
|
|
static struct device_driver usb_port_driver = {
|
|
|
|
.name = "usb",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2014-05-20 19:08:45 -06:00
|
|
|
static int link_peers(struct usb_port *left, struct usb_port *right)
|
2014-05-20 19:08:28 -06:00
|
|
|
{
|
2014-05-20 19:08:57 -06:00
|
|
|
struct usb_port *ss_port, *hs_port;
|
2014-05-20 19:08:45 -06:00
|
|
|
int rc;
|
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
if (left->peer == right && right->peer == left)
|
2014-05-20 19:08:45 -06:00
|
|
|
return 0;
|
2014-05-20 19:08:28 -06:00
|
|
|
|
|
|
|
if (left->peer || right->peer) {
|
|
|
|
struct usb_port *lpeer = left->peer;
|
|
|
|
struct usb_port *rpeer = right->peer;
|
2014-06-17 17:16:27 -06:00
|
|
|
char *method;
|
|
|
|
|
|
|
|
if (left->location && left->location == right->location)
|
|
|
|
method = "location";
|
|
|
|
else
|
|
|
|
method = "default";
|
|
|
|
|
|
|
|
pr_warn("usb: failed to peer %s and %s by %s (%s:%s) (%s:%s)\n",
|
|
|
|
dev_name(&left->dev), dev_name(&right->dev), method,
|
|
|
|
dev_name(&left->dev),
|
|
|
|
lpeer ? dev_name(&lpeer->dev) : "none",
|
|
|
|
dev_name(&right->dev),
|
|
|
|
rpeer ? dev_name(&rpeer->dev) : "none");
|
2014-05-20 19:08:45 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = sysfs_create_link(&left->dev.kobj, &right->dev.kobj, "peer");
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
rc = sysfs_create_link(&right->dev.kobj, &left->dev.kobj, "peer");
|
|
|
|
if (rc) {
|
|
|
|
sysfs_remove_link(&left->dev.kobj, "peer");
|
|
|
|
return rc;
|
2014-05-20 19:08:28 -06:00
|
|
|
}
|
|
|
|
|
2014-05-20 19:08:57 -06:00
|
|
|
/*
|
|
|
|
* We need to wake the HiSpeed port to make sure we don't race
|
|
|
|
* setting ->peer with usb_port_runtime_suspend(). Otherwise we
|
|
|
|
* may miss a suspend event for the SuperSpeed port.
|
|
|
|
*/
|
|
|
|
if (left->is_superspeed) {
|
|
|
|
ss_port = left;
|
|
|
|
WARN_ON(right->is_superspeed);
|
|
|
|
hs_port = right;
|
|
|
|
} else {
|
|
|
|
ss_port = right;
|
|
|
|
WARN_ON(!right->is_superspeed);
|
|
|
|
hs_port = left;
|
|
|
|
}
|
|
|
|
pm_runtime_get_sync(&hs_port->dev);
|
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
left->peer = right;
|
|
|
|
right->peer = left;
|
2014-05-20 19:08:45 -06:00
|
|
|
|
2014-05-20 19:08:57 -06:00
|
|
|
/*
|
|
|
|
* The SuperSpeed reference is dropped when the HiSpeed port in
|
|
|
|
* this relationship suspends, i.e. when it is safe to allow a
|
|
|
|
* SuperSpeed connection to drop since there is no risk of a
|
|
|
|
* device degrading to its powered-off HiSpeed connection.
|
|
|
|
*
|
|
|
|
* Also, drop the HiSpeed ref taken above.
|
|
|
|
*/
|
|
|
|
pm_runtime_get_sync(&ss_port->dev);
|
|
|
|
pm_runtime_put(&hs_port->dev);
|
|
|
|
|
2014-05-20 19:08:45 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void link_peers_report(struct usb_port *left, struct usb_port *right)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = link_peers(left, right);
|
|
|
|
if (rc == 0) {
|
|
|
|
dev_dbg(&left->dev, "peered to %s\n", dev_name(&right->dev));
|
|
|
|
} else {
|
|
|
|
dev_warn(&left->dev, "failed to peer to %s (%d)\n",
|
|
|
|
dev_name(&right->dev), rc);
|
|
|
|
pr_warn_once("usb: port power management may be unreliable\n");
|
2014-06-17 17:16:27 -06:00
|
|
|
usb_port_block_power_off = 1;
|
2014-05-20 19:08:45 -06:00
|
|
|
}
|
2014-05-20 19:08:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void unlink_peers(struct usb_port *left, struct usb_port *right)
|
|
|
|
{
|
2014-05-20 19:08:57 -06:00
|
|
|
struct usb_port *ss_port, *hs_port;
|
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
WARN(right->peer != left || left->peer != right,
|
|
|
|
"%s and %s are not peers?\n",
|
|
|
|
dev_name(&left->dev), dev_name(&right->dev));
|
|
|
|
|
2014-05-20 19:08:57 -06:00
|
|
|
/*
|
|
|
|
* We wake the HiSpeed port to make sure we don't race its
|
|
|
|
* usb_port_runtime_resume() event which takes a SuperSpeed ref
|
|
|
|
* when ->peer is !NULL.
|
|
|
|
*/
|
|
|
|
if (left->is_superspeed) {
|
|
|
|
ss_port = left;
|
|
|
|
hs_port = right;
|
|
|
|
} else {
|
|
|
|
ss_port = right;
|
|
|
|
hs_port = left;
|
|
|
|
}
|
|
|
|
|
|
|
|
pm_runtime_get_sync(&hs_port->dev);
|
|
|
|
|
2014-05-20 19:08:45 -06:00
|
|
|
sysfs_remove_link(&left->dev.kobj, "peer");
|
2014-05-20 19:08:28 -06:00
|
|
|
right->peer = NULL;
|
2014-05-20 19:08:45 -06:00
|
|
|
sysfs_remove_link(&right->dev.kobj, "peer");
|
2014-05-20 19:08:28 -06:00
|
|
|
left->peer = NULL;
|
2014-05-20 19:08:57 -06:00
|
|
|
|
|
|
|
/* Drop the SuperSpeed ref held on behalf of the active HiSpeed port */
|
|
|
|
pm_runtime_put(&ss_port->dev);
|
|
|
|
|
|
|
|
/* Drop the ref taken above */
|
|
|
|
pm_runtime_put(&hs_port->dev);
|
2014-05-20 19:08:28 -06:00
|
|
|
}
|
|
|
|
|
2014-05-20 19:08:33 -06:00
|
|
|
/*
|
2014-05-20 19:08:40 -06:00
|
|
|
* 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) {
|
2014-05-20 19:08:45 -06:00
|
|
|
link_peers_report(port_dev, peer);
|
2014-05-20 19:08:40 -06:00
|
|
|
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.
|
2014-05-20 19:08:33 -06:00
|
|
|
*/
|
2014-05-20 19:08:28 -06:00
|
|
|
static void find_and_link_peer(struct usb_hub *hub, int port1)
|
|
|
|
{
|
|
|
|
struct usb_port *port_dev = hub->ports[port1 - 1], *peer;
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
2014-05-20 19:08:33 -06:00
|
|
|
struct usb_device *peer_hdev;
|
|
|
|
struct usb_hub *peer_hub;
|
2014-05-20 19:08:28 -06:00
|
|
|
|
2014-05-20 19:08:40 -06:00
|
|
|
/*
|
|
|
|
* 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) {
|
2014-05-20 19:08:28 -06:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
|
|
|
|
struct usb_hcd *peer_hcd = hcd->shared_hcd;
|
|
|
|
|
|
|
|
if (!peer_hcd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
peer_hdev = peer_hcd->self.root_hub;
|
2014-05-20 19:08:33 -06:00
|
|
|
} else {
|
|
|
|
struct usb_port *upstream;
|
|
|
|
struct usb_device *parent = hdev->parent;
|
|
|
|
struct usb_hub *parent_hub = usb_hub_to_struct_hub(parent);
|
|
|
|
|
|
|
|
if (!parent_hub)
|
2014-05-20 19:08:28 -06:00
|
|
|
return;
|
|
|
|
|
2014-05-20 19:08:33 -06:00
|
|
|
upstream = parent_hub->ports[hdev->portnum - 1];
|
|
|
|
if (!upstream || !upstream->peer)
|
|
|
|
return;
|
2014-05-20 19:08:28 -06:00
|
|
|
|
2014-05-20 19:08:33 -06:00
|
|
|
peer_hdev = upstream->peer->child;
|
2014-05-20 19:08:28 -06:00
|
|
|
}
|
2014-05-20 19:08:33 -06:00
|
|
|
|
|
|
|
peer_hub = usb_hub_to_struct_hub(peer_hdev);
|
|
|
|
if (!peer_hub || port1 > peer_hdev->maxchild)
|
|
|
|
return;
|
|
|
|
|
2014-05-20 19:08:40 -06:00
|
|
|
/*
|
|
|
|
* we found a valid default peer, last check is to make sure it
|
|
|
|
* does not have location data
|
|
|
|
*/
|
2014-05-20 19:08:33 -06:00
|
|
|
peer = peer_hub->ports[port1 - 1];
|
2014-05-20 19:08:40 -06:00
|
|
|
if (peer && peer->location == 0)
|
2014-05-20 19:08:45 -06:00
|
|
|
link_peers_report(port_dev, peer);
|
2014-05-20 19:08:28 -06:00
|
|
|
}
|
|
|
|
|
2013-01-11 05:10:38 -07:00
|
|
|
int usb_hub_create_port_device(struct usb_hub *hub, int port1)
|
|
|
|
{
|
2014-05-20 19:08:28 -06:00
|
|
|
struct usb_port *port_dev;
|
2013-01-11 05:10:38 -07:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
|
2014-06-17 17:16:32 -06:00
|
|
|
if (!port_dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
port_dev->req = kzalloc(sizeof(*(port_dev->req)), GFP_KERNEL);
|
|
|
|
if (!port_dev->req) {
|
|
|
|
kfree(port_dev);
|
|
|
|
return -ENOMEM;
|
2013-01-11 05:10:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
hub->ports[port1 - 1] = port_dev;
|
2013-01-22 13:26:29 -07:00
|
|
|
port_dev->portnum = port1;
|
2014-05-20 19:08:52 -06:00
|
|
|
set_bit(port1, hub->power_bits);
|
2013-01-11 05:10:38 -07:00
|
|
|
port_dev->dev.parent = hub->intfdev;
|
2013-01-19 10:53:32 -07:00
|
|
|
port_dev->dev.groups = port_dev_group;
|
2013-01-11 05:10:38 -07:00
|
|
|
port_dev->dev.type = &usb_port_device_type;
|
2014-05-20 19:08:17 -06:00
|
|
|
port_dev->dev.driver = &usb_port_driver;
|
2014-05-20 19:08:57 -06:00
|
|
|
if (hub_is_superspeed(hub->hdev))
|
|
|
|
port_dev->is_superspeed = 1;
|
2014-05-20 19:08:17 -06:00
|
|
|
dev_set_name(&port_dev->dev, "%s-port%d", dev_name(&hub->hdev->dev),
|
|
|
|
port1);
|
2014-05-20 19:09:26 -06:00
|
|
|
mutex_init(&port_dev->status_lock);
|
2013-01-11 05:10:38 -07:00
|
|
|
retval = device_register(&port_dev->dev);
|
2014-06-17 17:16:32 -06:00
|
|
|
if (retval) {
|
|
|
|
put_device(&port_dev->dev);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set default policy of port-poweroff disabled. */
|
|
|
|
retval = dev_pm_qos_add_request(&port_dev->dev, port_dev->req,
|
|
|
|
DEV_PM_QOS_FLAGS, PM_QOS_FLAG_NO_POWER_OFF);
|
|
|
|
if (retval < 0) {
|
|
|
|
device_unregister(&port_dev->dev);
|
|
|
|
return retval;
|
|
|
|
}
|
2013-01-11 05:10:38 -07:00
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
find_and_link_peer(hub, port1);
|
|
|
|
|
2014-06-17 17:16:32 -06:00
|
|
|
/*
|
|
|
|
* Enable runtime pm and hold a refernce that hub_configure()
|
|
|
|
* will drop once the PM_QOS_NO_POWER_OFF flag state has been set
|
|
|
|
* and the hub has been fully registered (hdev->maxchild set).
|
|
|
|
*/
|
2013-01-22 13:26:29 -07:00
|
|
|
pm_runtime_set_active(&port_dev->dev);
|
2014-06-17 17:16:32 -06:00
|
|
|
pm_runtime_get_noresume(&port_dev->dev);
|
|
|
|
pm_runtime_enable(&port_dev->dev);
|
|
|
|
device_enable_async_suspend(&port_dev->dev);
|
2013-01-22 13:26:31 -07:00
|
|
|
|
2014-05-20 19:08:12 -06:00
|
|
|
/*
|
2014-06-17 17:16:32 -06:00
|
|
|
* Keep hidden the ability to enable port-poweroff if the hub
|
|
|
|
* does not support power switching.
|
2013-01-22 13:26:31 -07:00
|
|
|
*/
|
2014-06-17 17:16:32 -06:00
|
|
|
if (!hub_is_port_power_switchable(hub))
|
|
|
|
return 0;
|
2013-01-22 13:26:31 -07:00
|
|
|
|
2014-06-17 17:16:32 -06:00
|
|
|
/* Attempt to let userspace take over the policy. */
|
|
|
|
retval = dev_pm_qos_expose_flags(&port_dev->dev,
|
|
|
|
PM_QOS_FLAG_NO_POWER_OFF);
|
|
|
|
if (retval < 0) {
|
|
|
|
dev_warn(&port_dev->dev, "failed to expose pm_qos_no_poweroff\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2013-01-11 05:10:38 -07:00
|
|
|
|
2014-06-17 17:16:32 -06:00
|
|
|
/* Userspace owns the policy, drop the kernel 'no_poweroff' request. */
|
|
|
|
retval = dev_pm_qos_remove_request(port_dev->req);
|
|
|
|
if (retval >= 0) {
|
|
|
|
kfree(port_dev->req);
|
|
|
|
port_dev->req = NULL;
|
|
|
|
}
|
|
|
|
return 0;
|
2013-01-11 05:10:38 -07:00
|
|
|
}
|
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
void usb_hub_remove_port_device(struct usb_hub *hub, int port1)
|
2013-01-11 05:10:38 -07:00
|
|
|
{
|
2014-05-20 19:08:28 -06:00
|
|
|
struct usb_port *port_dev = hub->ports[port1 - 1];
|
|
|
|
struct usb_port *peer;
|
2013-01-11 05:10:38 -07:00
|
|
|
|
2014-05-20 19:08:28 -06:00
|
|
|
peer = port_dev->peer;
|
|
|
|
if (peer)
|
|
|
|
unlink_peers(port_dev, peer);
|
|
|
|
device_unregister(&port_dev->dev);
|
|
|
|
}
|