adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 19:26:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

USB: remove the auto_pm flag

Browse source 
This patch (as1302) removes the auto_pm flag from struct usb_device.
The flag's only purpose was to distinguish between autosuspends and
external suspends, but that information is now available in the
pm_message_t argument passed to suspend methods.

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 2009-11-13 11:53:59 -05:00 committed by Greg Kroah-Hartman
parent 576a362ad2
commit fb34d53752
8 changed files with 14 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Documentation/usb/power-management.txt
View file

@ -423,15 +423,16 @@ an URB had completed too recently.
External suspend calls should never be allowed to fail in this way, External suspend calls should never be allowed to fail in this way,
only autosuspend calls. The driver can tell them apart by checking only autosuspend calls. The driver can tell them apart by checking
udev->auto_pm; this flag will be set to 1 for internal PM events the PM_EVENT_AUTO bit in the message.event argument to the suspend
(autosuspend or autoresume) and 0 for external PM events. method; this bit will be set for internal PM events (autosuspend) and
clear for external PM events.
Many of the ingredients in the autosuspend framework are oriented Many of the ingredients in the autosuspend framework are oriented
towards interfaces: The usb_interface structure contains the towards interfaces: The usb_interface structure contains the
pm_usage_cnt field, and the usb_autopm_* routines take an interface pm_usage_cnt field, and the usb_autopm_* routines take an interface
pointer as their argument. But somewhat confusingly, a few of the pointer as their argument. But somewhat confusingly, a few of the
pieces (usb_mark_last_busy() and udev->auto_pm) use the usb_device pieces (i.e., usb_mark_last_busy()) use the usb_device structure
structure instead. Drivers need to keep this straight; they can call instead. Drivers need to keep this straight; they can call
interface_to_usbdev() to find the device structure for a given interface_to_usbdev() to find the device structure for a given
interface. interface.

2
drivers/bluetooth/btusb.c
View file

@ -1066,7 +1066,7 @@ static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
return 0; return 0;
spin_lock_irq(&data->txlock); spin_lock_irq(&data->txlock);
if (!(interface_to_usbdev(intf)->auto_pm && data->tx_in_flight)) { if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) {
set_bit(BTUSB_SUSPENDING, &data->flags); set_bit(BTUSB_SUSPENDING, &data->flags);
spin_unlock_irq(&data->txlock); spin_unlock_irq(&data->txlock);
} else { } else {

8
drivers/hid/usbhid/hid-core.c
View file

@ -1253,10 +1253,9 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
{ {
struct hid_device *hid = usb_get_intfdata(intf); struct hid_device *hid = usb_get_intfdata(intf);
struct usbhid_device *usbhid = hid->driver_data; struct usbhid_device *usbhid = hid->driver_data;
struct usb_device *udev = interface_to_usbdev(intf);
int status; int status;
if (udev->auto_pm) { if (message.event & PM_EVENT_AUTO) {
spin_lock_irq(&usbhid->lock); /* Sync with error handler */ spin_lock_irq(&usbhid->lock); /* Sync with error handler */
if (!test_bit(HID_RESET_PENDING, &usbhid->iofl) if (!test_bit(HID_RESET_PENDING, &usbhid->iofl)
&& !test_bit(HID_CLEAR_HALT, &usbhid->iofl) && !test_bit(HID_CLEAR_HALT, &usbhid->iofl)
@ -1281,7 +1280,7 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
return -EIO; return -EIO;
} }
if (!ignoreled && udev->auto_pm) { if (!ignoreled && (message.event & PM_EVENT_AUTO)) {
spin_lock_irq(&usbhid->lock); spin_lock_irq(&usbhid->lock);
if (test_bit(HID_LED_ON, &usbhid->iofl)) { if (test_bit(HID_LED_ON, &usbhid->iofl)) {
spin_unlock_irq(&usbhid->lock); spin_unlock_irq(&usbhid->lock);
@ -1294,7 +1293,8 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
hid_cancel_delayed_stuff(usbhid); hid_cancel_delayed_stuff(usbhid);
hid_cease_io(usbhid); hid_cease_io(usbhid);
if (udev->auto_pm && test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) { if ((message.event & PM_EVENT_AUTO) &&
test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) {
/* lost race against keypresses */ /* lost race against keypresses */
status = hid_start_in(hid); status = hid_start_in(hid);
if (status < 0) if (status < 0)

7
drivers/net/wimax/i2400m/usb.c
View file

@ -579,7 +579,7 @@ void i2400mu_disconnect(struct usb_interface *iface)
* *
* As well, the device might refuse going to sleep for whichever * As well, the device might refuse going to sleep for whichever
* reason. In this case we just fail. For system suspend/hibernate, * reason. In this case we just fail. For system suspend/hibernate,
* we *can't* fail. We look at usb_dev->auto_pm to see if the * we *can't* fail. We check PM_EVENT_AUTO to see if the
* suspend call comes from the USB stack or from the system and act * suspend call comes from the USB stack or from the system and act
* in consequence. * in consequence.
* *
@ -591,14 +591,11 @@ int i2400mu_suspend(struct usb_interface *iface, pm_message_t pm_msg)
int result = 0; int result = 0;
struct device *dev = &iface->dev; struct device *dev = &iface->dev;
struct i2400mu *i2400mu = usb_get_intfdata(iface); struct i2400mu *i2400mu = usb_get_intfdata(iface);
#ifdef CONFIG_PM
struct usb_device *usb_dev = i2400mu->usb_dev;
#endif
unsigned is_autosuspend = 0; unsigned is_autosuspend = 0;
struct i2400m *i2400m = &i2400mu->i2400m; struct i2400m *i2400m = &i2400mu->i2400m;
#ifdef CONFIG_PM #ifdef CONFIG_PM
if (usb_dev->auto_pm > 0) if (pm_msg.event & PM_EVENT_AUTO)
is_autosuspend = 1; is_autosuspend = 1;
#endif #endif

4
drivers/usb/core/driver.c
View file

@ -1341,7 +1341,6 @@ static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
int status = 0; int status = 0;
usb_pm_lock(udev); usb_pm_lock(udev);
udev->auto_pm = 1;
udev->pm_usage_cnt += inc_usage_cnt; udev->pm_usage_cnt += inc_usage_cnt;
WARN_ON(udev->pm_usage_cnt < 0); WARN_ON(udev->pm_usage_cnt < 0);
if (inc_usage_cnt) if (inc_usage_cnt)
@ -1473,7 +1472,6 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
if (intf->condition == USB_INTERFACE_UNBOUND) if (intf->condition == USB_INTERFACE_UNBOUND)
status = -ENODEV; status = -ENODEV;
else { else {
udev->auto_pm = 1;
atomic_add(inc_usage_cnt, &intf->pm_usage_cnt); atomic_add(inc_usage_cnt, &intf->pm_usage_cnt);
udev->last_busy = jiffies; udev->last_busy = jiffies;
if (inc_usage_cnt >= 0 && if (inc_usage_cnt >= 0 &&
@ -1707,7 +1705,6 @@ int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
do_unbind_rebind(udev, DO_UNBIND); do_unbind_rebind(udev, DO_UNBIND);
usb_pm_lock(udev); usb_pm_lock(udev);
udev->auto_pm = 0;
status = usb_suspend_both(udev, msg); status = usb_suspend_both(udev, msg);
usb_pm_unlock(udev); usb_pm_unlock(udev);
return status; return status;
@ -1730,7 +1727,6 @@ int usb_external_resume_device(struct usb_device *udev, pm_message_t msg)
int status; int status;
usb_pm_lock(udev); usb_pm_lock(udev);
udev->auto_pm = 0;
status = usb_resume_both(udev, msg); status = usb_resume_both(udev, msg);
udev->last_busy = jiffies; udev->last_busy = jiffies;
usb_pm_unlock(udev); usb_pm_unlock(udev);

2
drivers/usb/serial/option.c
View file

@ -1313,7 +1313,7 @@ static int option_suspend(struct usb_serial *serial, pm_message_t message)
dbg("%s entered", __func__); dbg("%s entered", __func__);
if (serial->dev->auto_pm) { if (message.event & PM_EVENT_AUTO) {
spin_lock_irq(&intfdata->susp_lock); spin_lock_irq(&intfdata->susp_lock);
b = intfdata->in_flight; b = intfdata->in_flight;
spin_unlock_irq(&intfdata->susp_lock); spin_unlock_irq(&intfdata->susp_lock);

2
drivers/usb/serial/sierra.c
View file

@ -1005,7 +1005,7 @@ static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
struct sierra_intf_private *intfdata; struct sierra_intf_private *intfdata;
int b; int b;
if (serial->dev->auto_pm) { if (message.event & PM_EVENT_AUTO) {
intfdata = serial->private; intfdata = serial->private;
spin_lock_irq(&intfdata->susp_lock); spin_lock_irq(&intfdata->susp_lock);
b = intfdata->in_flight; b = intfdata->in_flight;

2
include/linux/usb.h
View file

@ -429,7 +429,6 @@ struct usb_tt;
* @last_busy: time of last use * @last_busy: time of last use
* @autosuspend_delay: in jiffies * @autosuspend_delay: in jiffies
* @connect_time: time device was first connected * @connect_time: time device was first connected
* @auto_pm: autosuspend/resume in progress
* @do_remote_wakeup: remote wakeup should be enabled * @do_remote_wakeup: remote wakeup should be enabled
* @reset_resume: needs reset instead of resume * @reset_resume: needs reset instead of resume
* @autosuspend_disabled: autosuspend disabled by the user * @autosuspend_disabled: autosuspend disabled by the user
@ -514,7 +513,6 @@ struct usb_device {
int autosuspend_delay; int autosuspend_delay;
unsigned long connect_time; unsigned long connect_time;
unsigned auto_pm:1;
unsigned do_remote_wakeup:1; unsigned do_remote_wakeup:1;
unsigned reset_resume:1; unsigned reset_resume:1;
unsigned autosuspend_disabled:1; unsigned autosuspend_disabled:1;