usbcore: add autosuspend/autoresume infrastructure

This patch (as739) adds the basic infrastructure for USB autosuspend
and autoresume.  The main features are:

	PM usage counters added to struct usb_device and struct
	usb_interface, indicating whether it's okay to autosuspend
	them or they are currently in use.

	Flag added to usb_device indicating whether the current
	suspend/resume operation originated from outside or as an
	autosuspend/autoresume.

	Flag added to usb_driver indicating whether the driver
	supports autosuspend.  If not, no device bound to the driver
	will be autosuspended.

	Mutex added to usb_device for protecting PM operations.
	Unlike the device semaphore, the locking rule for the pm_mutex
	is that you must acquire the locks going _up_ the device tree.

	New routines handling autosuspend/autoresume requests for
	interfaces and devices.

	Suspend and resume requests are propagated up the device tree
	(but not outside the USB subsystem).

	work_struct added to usb_device, for carrying out delayed
	autosuspend requests.

	Autoresume added (and autosuspend prevented) during probe and
	disconnect.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Alan Stern 2006-08-30 15:47:02 -04:00 committed by Greg Kroah-Hartman
parent b6956ffa59
commit 645daaab0b
5 changed files with 493 additions and 45 deletions

View File

@ -157,12 +157,13 @@ static int usb_probe_device(struct device *dev)
udev = to_usb_device(dev);
/* FIXME: resume a suspended device */
if (udev->state == USB_STATE_SUSPENDED)
return -EHOSTUNREACH;
/* TODO: Add real matching code */
/* The device should always appear to be in use
* unless the driver suports autosuspend.
*/
udev->pm_usage_cnt = !(udriver->supports_autosuspend);
error = udriver->probe(udev);
return error;
}
@ -182,6 +183,7 @@ static int usb_probe_interface(struct device *dev)
{
struct usb_driver *driver = to_usb_driver(dev->driver);
struct usb_interface *intf;
struct usb_device *udev;
const struct usb_device_id *id;
int error = -ENODEV;
@ -191,10 +193,7 @@ static int usb_probe_interface(struct device *dev)
return error;
intf = to_usb_interface(dev);
/* FIXME we'd much prefer to just resume it ... */
if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED)
return -EHOSTUNREACH;
udev = interface_to_usbdev(intf);
id = usb_match_id(intf, driver->id_table);
if (!id)
@ -202,18 +201,31 @@ static int usb_probe_interface(struct device *dev)
if (id) {
dev_dbg(dev, "%s - got id\n", __FUNCTION__);
error = usb_autoresume_device(udev, 1);
if (error)
return error;
/* Interface "power state" doesn't correspond to any hardware
* state whatsoever. We use it to record when it's bound to
* a driver that may start I/0: it's not frozen/quiesced.
*/
mark_active(intf);
intf->condition = USB_INTERFACE_BINDING;
/* The interface should always appear to be in use
* unless the driver suports autosuspend.
*/
intf->pm_usage_cnt = !(driver->supports_autosuspend);
error = driver->probe(intf, id);
if (error) {
mark_quiesced(intf);
intf->needs_remote_wakeup = 0;
intf->condition = USB_INTERFACE_UNBOUND;
} else
intf->condition = USB_INTERFACE_BOUND;
usb_autosuspend_device(udev, 1);
}
return error;
@ -224,9 +236,15 @@ static int usb_unbind_interface(struct device *dev)
{
struct usb_driver *driver = to_usb_driver(dev->driver);
struct usb_interface *intf = to_usb_interface(dev);
struct usb_device *udev;
int error;
intf->condition = USB_INTERFACE_UNBINDING;
/* Autoresume for set_interface call below */
udev = interface_to_usbdev(intf);
error = usb_autoresume_device(udev, 1);
/* release all urbs for this interface */
usb_disable_interface(interface_to_usbdev(intf), intf);
@ -237,8 +255,13 @@ static int usb_unbind_interface(struct device *dev)
intf->altsetting[0].desc.bInterfaceNumber,
0);
usb_set_intfdata(intf, NULL);
intf->condition = USB_INTERFACE_UNBOUND;
mark_quiesced(intf);
intf->needs_remote_wakeup = 0;
if (!error)
usb_autosuspend_device(udev, 1);
return 0;
}
@ -267,14 +290,19 @@ int usb_driver_claim_interface(struct usb_driver *driver,
struct usb_interface *iface, void* priv)
{
struct device *dev = &iface->dev;
struct usb_device *udev = interface_to_usbdev(iface);
if (dev->driver)
return -EBUSY;
dev->driver = &driver->drvwrap.driver;
usb_set_intfdata(iface, priv);
mutex_lock_nested(&udev->pm_mutex, udev->level);
iface->condition = USB_INTERFACE_BOUND;
mark_active(iface);
iface->pm_usage_cnt = !(driver->supports_autosuspend);
mutex_unlock(&udev->pm_mutex);
/* if interface was already added, bind now; else let
* the future device_add() bind it, bypassing probe()
@ -304,6 +332,7 @@ void usb_driver_release_interface(struct usb_driver *driver,
struct usb_interface *iface)
{
struct device *dev = &iface->dev;
struct usb_device *udev = interface_to_usbdev(iface);
/* this should never happen, don't release something that's not ours */
if (!dev->driver || dev->driver != &driver->drvwrap.driver)
@ -321,8 +350,12 @@ void usb_driver_release_interface(struct usb_driver *driver,
dev->driver = NULL;
usb_set_intfdata(iface, NULL);
mutex_lock_nested(&udev->pm_mutex, udev->level);
iface->condition = USB_INTERFACE_UNBOUND;
mark_quiesced(iface);
iface->needs_remote_wakeup = 0;
mutex_unlock(&udev->pm_mutex);
}
EXPORT_SYMBOL(usb_driver_release_interface);
@ -751,7 +784,7 @@ EXPORT_SYMBOL_GPL_FUTURE(usb_deregister);
#ifdef CONFIG_PM
/* Caller has locked udev */
/* Caller has locked udev->pm_mutex */
static int suspend_device(struct usb_device *udev, pm_message_t msg)
{
struct usb_device_driver *udriver;
@ -763,6 +796,7 @@ static int suspend_device(struct usb_device *udev, pm_message_t msg)
/* For devices that don't have a driver, we do a standard suspend. */
if (udev->dev.driver == NULL) {
udev->do_remote_wakeup = 0;
status = usb_port_suspend(udev);
goto done;
}
@ -771,12 +805,13 @@ static int suspend_device(struct usb_device *udev, pm_message_t msg)
status = udriver->suspend(udev, msg);
done:
// dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
if (status == 0)
udev->dev.power.power_state.event = msg.event;
return status;
}
/* Caller has locked udev */
/* Caller has locked udev->pm_mutex */
static int resume_device(struct usb_device *udev)
{
struct usb_device_driver *udriver;
@ -796,12 +831,13 @@ static int resume_device(struct usb_device *udev)
status = udriver->resume(udev);
done:
// dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
if (status == 0)
udev->dev.power.power_state.event = PM_EVENT_ON;
return status;
}
/* Caller has locked intf's usb_device */
/* Caller has locked intf's usb_device's pm_mutex */
static int suspend_interface(struct usb_interface *intf, pm_message_t msg)
{
struct usb_driver *driver;
@ -812,31 +848,33 @@ static int suspend_interface(struct usb_interface *intf, pm_message_t msg)
!is_active(intf))
goto done;
if (intf->dev.driver == NULL) /* This can't happen */
if (intf->condition == USB_INTERFACE_UNBOUND) /* This can't happen */
goto done;
driver = to_usb_driver(intf->dev.driver);
if (driver->suspend && driver->resume) {
status = driver->suspend(intf, msg);
if (status)
if (status == 0)
mark_quiesced(intf);
else if (!interface_to_usbdev(intf)->auto_pm)
dev_err(&intf->dev, "%s error %d\n",
"suspend", status);
else
mark_quiesced(intf);
} else {
// FIXME else if there's no suspend method, disconnect...
// Not possible if auto_pm is set...
dev_warn(&intf->dev, "no suspend for driver %s?\n",
driver->name);
mark_quiesced(intf);
}
done:
// dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
if (status == 0)
intf->dev.power.power_state.event = msg.event;
return status;
}
/* Caller has locked intf's usb_device */
/* Caller has locked intf's usb_device's pm_mutex */
static int resume_interface(struct usb_interface *intf)
{
struct usb_driver *driver;
@ -846,8 +884,12 @@ static int resume_interface(struct usb_interface *intf)
is_active(intf))
goto done;
/* Don't let autoresume interfere with unbinding */
if (intf->condition == USB_INTERFACE_UNBINDING)
goto done;
/* Can't resume it if it doesn't have a driver. */
if (intf->dev.driver == NULL) {
if (intf->condition == USB_INTERFACE_UNBOUND) {
status = -ENOTCONN;
goto done;
}
@ -867,18 +909,88 @@ static int resume_interface(struct usb_interface *intf)
}
done:
// dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
if (status == 0)
intf->dev.power.power_state.event = PM_EVENT_ON;
return status;
}
/* Caller has locked udev */
/**
* usb_suspend_both - suspend a USB device and its interfaces
* @udev: the usb_device to suspend
* @msg: Power Management message describing this state transition
*
* This is the central routine for suspending USB devices. It calls the
* suspend methods for all the interface drivers in @udev and then calls
* the suspend method for @udev itself. If an error occurs at any stage,
* all the interfaces which were suspended are resumed so that they remain
* in the same state as the device.
*
* If an autosuspend is in progress (@udev->auto_pm is set), the routine
* checks first to make sure that neither the device itself or any of its
* active interfaces is in use (pm_usage_cnt is greater than 0). If they
* are, the autosuspend fails.
*
* If the suspend succeeds, the routine recursively queues an autosuspend
* request for @udev's parent device, thereby propagating the change up
* the device tree. If all of the parent's children are now suspended,
* the parent will autosuspend in turn.
*
* The suspend method calls are subject to mutual exclusion under control
* of @udev's pm_mutex. Many of these calls are also under the protection
* of @udev's device lock (including all requests originating outside the
* USB subsystem), but autosuspend requests generated by a child device or
* interface driver may not be. Usbcore will insure that the method calls
* do not arrive during bind, unbind, or reset operations. However, drivers
* must be prepared to handle suspend calls arriving at unpredictable times.
* The only way to block such calls is to do an autoresume (preventing
* autosuspends) while holding @udev's device lock (preventing outside
* suspends).
*
* The caller must hold @udev->pm_mutex.
*
* This routine can run only in process context.
*/
int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
{
int status = 0;
int i = 0;
struct usb_interface *intf;
struct usb_device *parent = udev->parent;
cancel_delayed_work(&udev->autosuspend);
if (udev->state == USB_STATE_NOTATTACHED)
return 0;
if (udev->state == USB_STATE_SUSPENDED)
return 0;
udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
/* For autosuspend, fail fast if anything is in use.
* Also fail if any interfaces require remote wakeup but it
* isn't available. */
if (udev->auto_pm) {
if (udev->pm_usage_cnt > 0)
return -EBUSY;
if (udev->actconfig) {
for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
intf = udev->actconfig->interface[i];
if (!is_active(intf))
continue;
if (intf->pm_usage_cnt > 0)
return -EBUSY;
if (intf->needs_remote_wakeup &&
!udev->do_remote_wakeup) {
dev_dbg(&udev->dev,
"remote wakeup needed for autosuspend\n");
return -EOPNOTSUPP;
}
}
i = 0;
}
}
/* Suspend all the interfaces and then udev itself */
if (udev->actconfig) {
for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
intf = udev->actconfig->interface[i];
@ -896,40 +1008,282 @@ int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
intf = udev->actconfig->interface[i];
resume_interface(intf);
}
}
/* If the suspend succeeded, propagate it up the tree */
} else if (parent)
usb_autosuspend_device(parent, 0);
// dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
return status;
}
/* Caller has locked udev */
/**
* usb_resume_both - resume a USB device and its interfaces
* @udev: the usb_device to resume
*
* This is the central routine for resuming USB devices. It calls the
* the resume method for @udev and then calls the resume methods for all
* the interface drivers in @udev.
*
* Before starting the resume, the routine calls itself recursively for
* the parent device of @udev, thereby propagating the change up the device
* tree and assuring that @udev will be able to resume. If the parent is
* unable to resume successfully, the routine fails.
*
* The resume method calls are subject to mutual exclusion under control
* of @udev's pm_mutex. Many of these calls are also under the protection
* of @udev's device lock (including all requests originating outside the
* USB subsystem), but autoresume requests generated by a child device or
* interface driver may not be. Usbcore will insure that the method calls
* do not arrive during bind, unbind, or reset operations. However, drivers
* must be prepared to handle resume calls arriving at unpredictable times.
* The only way to block such calls is to do an autoresume (preventing
* other autoresumes) while holding @udev's device lock (preventing outside
* resumes).
*
* The caller must hold @udev->pm_mutex.
*
* This routine can run only in process context.
*/
int usb_resume_both(struct usb_device *udev)
{
int status;
int status = 0;
int i;
struct usb_interface *intf;
struct usb_device *parent = udev->parent;
/* Can't resume if the parent is suspended */
if (udev->parent && udev->parent->state == USB_STATE_SUSPENDED) {
dev_warn(&udev->dev, "can't resume; parent is suspended\n");
return -EHOSTUNREACH;
cancel_delayed_work(&udev->autosuspend);
if (udev->state == USB_STATE_NOTATTACHED)
return -ENODEV;
/* Propagate the resume up the tree, if necessary */
if (udev->state == USB_STATE_SUSPENDED) {
if (parent) {
mutex_lock_nested(&parent->pm_mutex, parent->level);
parent->auto_pm = 1;
status = usb_resume_both(parent);
} else {
/* We can't progagate beyond the USB subsystem,
* so if a root hub's controller is suspended
* then we're stuck. */
if (udev->dev.parent->power.power_state.event !=
PM_EVENT_ON)
status = -EHOSTUNREACH;
}
if (status == 0 && udev->state == USB_STATE_SUSPENDED)
status = resume_device(udev);
if (parent)
mutex_unlock(&parent->pm_mutex);
}
status = resume_device(udev);
/* Now the parent won't suspend until we are finished */
if (status == 0 && udev->actconfig) {
for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
intf = udev->actconfig->interface[i];
resume_interface(intf);
}
}
// dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
return status;
}
#ifdef CONFIG_USB_SUSPEND
/**
* usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
* @udev - the usb_device to autosuspend
* @dec_usage_cnt - flag to decrement @udev's PM-usage counter
*
* This routine should be called when a core subsystem is finished using
* @udev and wants to allow it to autosuspend. Examples would be when
* @udev's device file in usbfs is closed or after a configuration change.
*
* @dec_usage_cnt should be 1 if the subsystem previously incremented
* @udev's usage counter (such as by passing 1 to usb_autoresume_device);
* otherwise it should be 0.
*
* If the usage counter for @udev or any of its active interfaces is greater
* than 0, the autosuspend request will not be queued. (If an interface
* driver does not support autosuspend then its usage counter is permanently
* positive.) Likewise, if an interface driver requires remote-wakeup
* capability during autosuspend but remote wakeup is disabled, the
* autosuspend will fail.
*
* Often the caller will hold @udev's device lock, but this is not
* necessary.
*
* This routine can run only in process context.
*/
void usb_autosuspend_device(struct usb_device *udev, int dec_usage_cnt)
{
mutex_lock_nested(&udev->pm_mutex, udev->level);
udev->pm_usage_cnt -= dec_usage_cnt;
if (udev->pm_usage_cnt <= 0)
schedule_delayed_work(&udev->autosuspend,
USB_AUTOSUSPEND_DELAY);
mutex_unlock(&udev->pm_mutex);
// dev_dbg(&udev->dev, "%s: cnt %d\n",
// __FUNCTION__, udev->pm_usage_cnt);
}
/**
* usb_autoresume_device - immediately autoresume a USB device and its interfaces
* @udev - the usb_device to autoresume
* @inc_usage_cnt - flag to increment @udev's PM-usage counter
*
* This routine should be called when a core subsystem wants to use @udev
* and needs to guarantee that it is not suspended. In addition, the
* caller can prevent @udev from being autosuspended subsequently. (Note
* that this will not prevent suspend events originating in the PM core.)
* Examples would be when @udev's device file in usbfs is opened (autosuspend
* should be prevented until the file is closed) or when a remote-wakeup
* request is received (later autosuspends should not be prevented).
*
* @inc_usage_cnt should be 1 to increment @udev's usage counter and prevent
* autosuspends. This prevention will persist until the usage counter is
* decremented again (such as by passing 1 to usb_autosuspend_device).
* Otherwise @inc_usage_cnt should be 0 to leave the usage counter unchanged.
* Regardless, if the autoresume fails then the usage counter is not
* incremented.
*
* Often the caller will hold @udev's device lock, but this is not
* necessary (and attempting it might cause deadlock).
*
* This routine can run only in process context.
*/
int usb_autoresume_device(struct usb_device *udev, int inc_usage_cnt)
{
int status;
mutex_lock_nested(&udev->pm_mutex, udev->level);
udev->pm_usage_cnt += inc_usage_cnt;
udev->auto_pm = 1;
status = usb_resume_both(udev);
if (status != 0)
udev->pm_usage_cnt -= inc_usage_cnt;
mutex_unlock(&udev->pm_mutex);
// dev_dbg(&udev->dev, "%s: status %d cnt %d\n",
// __FUNCTION__, status, udev->pm_usage_cnt);
return status;
}
/**
* usb_autopm_put_interface - decrement a USB interface's PM-usage counter
* @intf - the usb_interface whose counter should be decremented
*
* This routine should be called by an interface driver when it is
* finished using @intf and wants to allow it to autosuspend. A typical
* example would be a character-device driver when its device file is
* closed.
*
* The routine decrements @intf's usage counter. When the counter reaches
* 0, a delayed autosuspend request for @intf's device is queued. When
* the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
* the other usage counters for the sibling interfaces and @intf's
* usb_device, the device and all its interfaces will be autosuspended.
*
* Note that @intf->pm_usage_cnt is owned by the interface driver. The
* core will not change its value other than the increment and decrement
* in usb_autopm_get_interface and usb_autopm_put_interface. The driver
* may use this simple counter-oriented discipline or may set the value
* any way it likes.
*
* If the driver has set @intf->needs_remote_wakeup then autosuspend will
* take place only if the device's remote-wakeup facility is enabled.
*
* Suspend method calls queued by this routine can arrive at any time
* while @intf is resumed and its usage counter is equal to 0. They are
* not protected by the usb_device's lock but only by its pm_mutex.
* Drivers must provide their own synchronization.
*
* This routine can run only in process context.
*/
void usb_autopm_put_interface(struct usb_interface *intf)
{
struct usb_device *udev = interface_to_usbdev(intf);
mutex_lock_nested(&udev->pm_mutex, udev->level);
if (intf->condition != USB_INTERFACE_UNBOUND) {
if (--intf->pm_usage_cnt <= 0)
schedule_delayed_work(&udev->autosuspend,
USB_AUTOSUSPEND_DELAY);
}
mutex_unlock(&udev->pm_mutex);
// dev_dbg(&intf->dev, "%s: cnt %d\n",
// __FUNCTION__, intf->pm_usage_cnt);
}
EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
/**
* usb_autopm_get_interface - increment a USB interface's PM-usage counter
* @intf - the usb_interface whose counter should be incremented
*
* This routine should be called by an interface driver when it wants to
* use @intf and needs to guarantee that it is not suspended. In addition,
* the routine prevents @intf from being autosuspended subsequently. (Note
* that this will not prevent suspend events originating in the PM core.)
* This prevention will persist until usb_autopm_put_interface() is called
* or @intf is unbound. A typical example would be a character-device
* driver when its device file is opened.
*
* The routine increments @intf's usage counter. So long as the counter
* is greater than 0, autosuspend will not be allowed for @intf or its
* usb_device. When the driver is finished using @intf it should call
* usb_autopm_put_interface() to decrement the usage counter and queue
* a delayed autosuspend request (if the counter is <= 0).
*
* Note that @intf->pm_usage_cnt is owned by the interface driver. The
* core will not change its value other than the increment and decrement
* in usb_autopm_get_interface and usb_autopm_put_interface. The driver
* may use this simple counter-oriented discipline or may set the value
* any way it likes.
*
* Resume method calls generated by this routine can arrive at any time
* while @intf is suspended. They are not protected by the usb_device's
* lock but only by its pm_mutex. Drivers must provide their own
* synchronization.
*
* This routine can run only in process context.
*/
int usb_autopm_get_interface(struct usb_interface *intf)
{
struct usb_device *udev = interface_to_usbdev(intf);
int status;
mutex_lock_nested(&udev->pm_mutex, udev->level);
if (intf->condition == USB_INTERFACE_UNBOUND)
status = -ENODEV;
else {
++intf->pm_usage_cnt;
udev->auto_pm = 1;
status = usb_resume_both(udev);
if (status != 0)
--intf->pm_usage_cnt;
}
mutex_unlock(&udev->pm_mutex);
// dev_dbg(&intf->dev, "%s: status %d cnt %d\n",
// __FUNCTION__, status, intf->pm_usage_cnt);
return status;
}
EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
#endif /* CONFIG_USB_SUSPEND */
static int usb_suspend(struct device *dev, pm_message_t message)
{
int status;
if (is_usb_device(dev))
status = usb_suspend_both(to_usb_device(dev), message);
else
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
mutex_lock_nested(&udev->pm_mutex, udev->level);
udev->auto_pm = 0;
status = usb_suspend_both(udev, message);
mutex_unlock(&udev->pm_mutex);
} else
status = 0;
return status;
}
@ -939,7 +1293,12 @@ static int usb_resume(struct device *dev)
int status;
if (is_usb_device(dev)) {
status = usb_resume_both(to_usb_device(dev));
struct usb_device *udev = to_usb_device(dev);
mutex_lock_nested(&udev->pm_mutex, udev->level);
udev->auto_pm = 0;
status = usb_resume_both(udev);
mutex_unlock(&udev->pm_mutex);
/* Rebind drivers that had no suspend method? */
} else

View File

@ -1017,19 +1017,22 @@ void usb_set_device_state(struct usb_device *udev,
if (udev->state == USB_STATE_NOTATTACHED)
; /* do nothing */
else if (new_state != USB_STATE_NOTATTACHED) {
udev->state = new_state;
/* root hub wakeup capabilities are managed out-of-band
* and may involve silicon errata ... ignore them here.
*/
if (udev->parent) {
if (new_state == USB_STATE_CONFIGURED)
if (udev->state == USB_STATE_SUSPENDED
|| new_state == USB_STATE_SUSPENDED)
; /* No change to wakeup settings */
else if (new_state == USB_STATE_CONFIGURED)
device_init_wakeup(&udev->dev,
(udev->actconfig->desc.bmAttributes
& USB_CONFIG_ATT_WAKEUP));
else if (new_state != USB_STATE_SUSPENDED)
else
device_init_wakeup(&udev->dev, 0);
}
udev->state = new_state;
} else
recursively_mark_NOTATTACHED(udev);
spin_unlock_irqrestore(&device_state_lock, flags);
@ -1507,7 +1510,7 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
* NOTE: OTG devices may issue remote wakeup (or SRP) even when
* we don't explicitly enable it here.
*/
if (device_may_wakeup(&udev->dev)) {
if (udev->do_remote_wakeup) {
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
USB_DEVICE_REMOTE_WAKEUP, 0,
@ -1533,7 +1536,8 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
USB_CTRL_SET_TIMEOUT);
} else {
/* device has up to 10 msec to fully suspend */
dev_dbg(&udev->dev, "usb suspend\n");
dev_dbg(&udev->dev, "usb %ssuspend\n",
udev->auto_pm ? "auto-" : "");
usb_set_device_state(udev, USB_STATE_SUSPENDED);
msleep(10);
}
@ -1573,7 +1577,8 @@ static int __usb_port_suspend (struct usb_device *udev, int port1)
status = hub_port_suspend(hdev_to_hub(udev->parent), port1,
udev);
else {
dev_dbg(&udev->dev, "usb suspend\n");
dev_dbg(&udev->dev, "usb %ssuspend\n",
udev->auto_pm ? "auto-" : "");
usb_set_device_state(udev, USB_STATE_SUSPENDED);
}
return status;
@ -1687,7 +1692,8 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
/* drive resume for at least 20 msec */
if (udev)
dev_dbg(&udev->dev, "RESUME\n");
dev_dbg(&udev->dev, "usb %sresume\n",
udev->auto_pm ? "auto-" : "");
msleep(25);
#define LIVE_FLAGS ( USB_PORT_STAT_POWER \
@ -1754,8 +1760,11 @@ int usb_port_resume(struct usb_device *udev)
// NOTE this fails if parent is also suspended...
status = hub_port_resume(hdev_to_hub(udev->parent),
udev->portnum, udev);
} else
} else {
dev_dbg(&udev->dev, "usb %sresume\n",
udev->auto_pm ? "auto-" : "");
status = finish_port_resume(udev);
}
if (status < 0)
dev_dbg(&udev->dev, "can't resume, status %d\n", status);
return status;
@ -1765,19 +1774,23 @@ static int remote_wakeup(struct usb_device *udev)
{
int status = 0;
/* don't repeat RESUME sequence if this device
* was already woken up by some other task
*/
/* All this just to avoid sending a port-resume message
* to the parent hub! */
usb_lock_device(udev);
mutex_lock_nested(&udev->pm_mutex, udev->level);
if (udev->state == USB_STATE_SUSPENDED) {
dev_dbg(&udev->dev, "RESUME (wakeup)\n");
dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
/* TRSMRCY = 10 msec */
msleep(10);
status = finish_port_resume(udev);
if (status == 0)
udev->dev.power.power_state.event = PM_EVENT_ON;
}
mutex_unlock(&udev->pm_mutex);
if (status == 0)
usb_resume_both(udev);
usb_autoresume_device(udev, 0);
usb_unlock_device(udev);
return status;
}
@ -1834,7 +1847,9 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
== PM_EVENT_ON
#endif
) {
dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);
if (!hdev->auto_pm)
dev_dbg(&intf->dev, "port %d nyet suspended\n",
port1);
return -EBUSY;
}
}
@ -2587,7 +2602,7 @@ static void hub_events(void)
* stub "device" node was never suspended.
*/
if (i)
usb_resume_both(hdev);
usb_autoresume_device(hdev, 0);
/* If this is an inactive or suspended hub, do nothing */
if (hub->quiescing)
@ -2993,6 +3008,9 @@ int usb_reset_composite_device(struct usb_device *udev,
return -EINVAL;
}
/* Prevent autosuspend during the reset */
usb_autoresume_device(udev, 1);
if (iface && iface->condition != USB_INTERFACE_BINDING)
iface = NULL;
@ -3034,6 +3052,7 @@ int usb_reset_composite_device(struct usb_device *udev,
}
}
usb_autosuspend_device(udev, 1);
return ret;
}
EXPORT_SYMBOL(usb_reset_composite_device);

View File

@ -168,6 +168,10 @@ static void usb_release_dev(struct device *dev)
udev = to_usb_device(dev);
#ifdef CONFIG_PM
cancel_delayed_work(&udev->autosuspend);
flush_scheduled_work();
#endif
usb_destroy_configuration(udev);
usb_put_hcd(bus_to_hcd(udev->bus));
kfree(udev->product);
@ -176,6 +180,21 @@ static void usb_release_dev(struct device *dev)
kfree(udev);
}
#ifdef CONFIG_PM
/* usb_autosuspend_work - callback routine to autosuspend a USB device */
static void usb_autosuspend_work(void *_udev)
{
struct usb_device *udev = _udev;
mutex_lock_nested(&udev->pm_mutex, udev->level);
udev->auto_pm = 1;
usb_suspend_both(udev, PMSG_SUSPEND);
mutex_unlock(&udev->pm_mutex);
}
#endif
/**
* usb_alloc_dev - usb device constructor (usbcore-internal)
* @parent: hub to which device is connected; null to allocate a root hub
@ -251,6 +270,10 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
dev->parent = parent;
INIT_LIST_HEAD(&dev->filelist);
#ifdef CONFIG_PM
mutex_init(&dev->pm_mutex);
INIT_WORK(&dev->autosuspend, usb_autosuspend_work, dev);
#endif
return dev;
}

View File

@ -49,6 +49,20 @@ static inline int usb_resume_both(struct usb_device *udev)
#endif
#ifdef CONFIG_USB_SUSPEND
#define USB_AUTOSUSPEND_DELAY (HZ*2)
extern void usb_autosuspend_device(struct usb_device *udev, int dec_busy_cnt);
extern int usb_autoresume_device(struct usb_device *udev, int inc_busy_cnt);
#else
#define usb_autosuspend_device(udev, dec_busy_cnt) do {} while (0)
#define usb_autoresume_device(udev, inc_busy_cnt) 0
#endif
extern struct bus_type usb_bus_type;
extern struct usb_device_driver usb_generic_driver;

View File

@ -19,6 +19,7 @@
#include <linux/fs.h> /* for struct file_operations */
#include <linux/completion.h> /* for struct completion */
#include <linux/sched.h> /* for current && schedule_timeout */
#include <linux/mutex.h> /* for struct mutex */
struct usb_device;
struct usb_driver;
@ -103,8 +104,12 @@ enum usb_interface_condition {
* @condition: binding state of the interface: not bound, binding
* (in probe()), bound to a driver, or unbinding (in disconnect())
* @is_active: flag set when the interface is bound and not suspended.
* @needs_remote_wakeup: flag set when the driver requires remote-wakeup
* capability during autosuspend.
* @dev: driver model's view of this device
* @class_dev: driver model's class view of this device.
* @pm_usage_cnt: PM usage counter for this interface; autosuspend is not
* allowed unless the counter is 0.
*
* USB device drivers attach to interfaces on a physical device. Each
* interface encapsulates a single high level function, such as feeding
@ -144,9 +149,11 @@ struct usb_interface {
* bound to */
enum usb_interface_condition condition; /* state of binding */
unsigned is_active:1; /* the interface is not suspended */
unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
struct device dev; /* interface specific device info */
struct class_device *class_dev;
int pm_usage_cnt; /* usage counter for autosuspend */
};
#define to_usb_interface(d) container_of(d, struct usb_interface, dev)
#define interface_to_usbdev(intf) \
@ -372,6 +379,15 @@ struct usb_device {
int maxchild; /* Number of ports if hub */
struct usb_device *children[USB_MAXCHILDREN];
#ifdef CONFIG_PM
struct work_struct autosuspend; /* for delayed autosuspends */
struct mutex pm_mutex; /* protects PM operations */
int pm_usage_cnt; /* usage counter for autosuspend */
unsigned auto_pm:1; /* autosuspend/resume in progress */
unsigned do_remote_wakeup:1; /* remote wakeup should be enabled */
#endif
};
#define to_usb_device(d) container_of(d, struct usb_device, dev)
@ -392,6 +408,17 @@ extern int usb_reset_composite_device(struct usb_device *dev,
extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
/* USB autosuspend and autoresume */
#ifdef CONFIG_USB_SUSPEND
extern int usb_autopm_get_interface(struct usb_interface *intf);
extern void usb_autopm_put_interface(struct usb_interface *intf);
#else
#define usb_autopm_get_interface(intf) 0
#define usb_autopm_put_interface(intf) do {} while (0)
#endif
/*-------------------------------------------------------------------------*/
/* for drivers using iso endpoints */
@ -593,6 +620,8 @@ struct usbdrv_wrap {
* @drvwrap: Driver-model core structure wrapper.
* @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
* added to this driver by preventing the sysfs file from being created.
* @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
* for interfaces bound to this driver.
*
* USB interface drivers must provide a name, probe() and disconnect()
* methods, and an id_table. Other driver fields are optional.
@ -631,6 +660,7 @@ struct usb_driver {
struct usb_dynids dynids;
struct usbdrv_wrap drvwrap;
unsigned int no_dynamic_id:1;
unsigned int supports_autosuspend:1;
};
#define to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
@ -648,6 +678,8 @@ struct usb_driver {
* @suspend: Called when the device is going to be suspended by the system.
* @resume: Called when the device is being resumed by the system.
* @drvwrap: Driver-model core structure wrapper.
* @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
* for devices bound to this driver.
*
* USB drivers must provide all the fields listed above except drvwrap.
*/
@ -660,6 +692,7 @@ struct usb_device_driver {
int (*suspend) (struct usb_device *udev, pm_message_t message);
int (*resume) (struct usb_device *udev);
struct usbdrv_wrap drvwrap;
unsigned int supports_autosuspend:1;
};
#define to_usb_device_driver(d) container_of(d, struct usb_device_driver, \
drvwrap.driver)