Android usb子系统的 电源管理 流程分析
对的处理器是高通MSM8260，主要是针对一些挂起唤醒流程进行分析，以便对整个usb框架流程更好的理解。
由于linux中的电源管理比较复杂，我就找了一个统一的接口，也就是 要想操纵usb的电源管理 必定要调的函数。顺便说下，跟踪代码最好的方法是用WARN_ON(1)打调用栈。
先看电源管理子系统的一些初始化：
/*系统初始化所用的结构体*/
struct device {
.....
struct dev_pm_info power; //电源管理结构体
.....
};
struct device {
.....
struct dev_pm_info power; //电源管理结构体
.....
};
/*该结构体定义如下*/
struct dev_pm_info {
pm_message_t power_state;
unsigned int can_wakeup:1; //can_wakeup标志 表示设备（或驱动）物理上 支持唤醒事件
unsigned int should_wakeup:1; //should_wakeup标志 控制设备是否应该尝试启用他的唤醒机制
unsigned async_suspend:1;
enum dpm_state status; /* Owned by the PM core */
#ifdef CONFIG_PM_SLEEP
struct list_head entry; //链接到dpm_list链表的节点
struct completion completion;
#endif
#ifdef CONFIG_PM_RUNTIME
struct timer_list suspend_timer; //处理自动挂起的timer
unsigned long timer_expires;
struct work_struct work; //请求处理用的work
wait_queue_head_t wait_queue; //等待队列头
spinlock_t lock;
atomic_t usage_count;
atomic_t child_count;
unsigned int disable_depth:3;
unsigned int ignore_children:1;
unsigned int idle_notification:1;
unsigned int request_pending:1;
unsigned int deferred_resume:1;
unsigned int run_wake:1;
unsigned int runtime_auto:1;
enum rpm_request request;
enum rpm_status runtime_status;
int runtime_error;
#endif
};
pm_message_t power_state;
unsigned int can_wakeup:1; //can_wakeup标志 表示设备（或驱动）物理上 支持唤醒事件
unsigned int should_wakeup:1; //should_wakeup标志 控制设备是否应该尝试启用他的唤醒机制
unsigned async_suspend:1;
enum dpm_state status; /* Owned by the PM core */
#ifdef CONFIG_PM_SLEEP
struct list_head entry; //链接到dpm_list链表的节点
struct completion completion;
#endif
#ifdef CONFIG_PM_RUNTIME
struct timer_list suspend_timer; //处理自动挂起的timer
unsigned long timer_expires;
struct work_struct work; //请求处理用的work
wait_queue_head_t wait_queue; //等待队列头
spinlock_t lock;
atomic_t usage_count;
atomic_t child_count;
unsigned int disable_depth:3;
unsigned int ignore_children:1;
unsigned int idle_notification:1;
unsigned int request_pending:1;
unsigned int deferred_resume:1;
unsigned int run_wake:1;
unsigned int runtime_auto:1;
enum rpm_request request;
enum rpm_status runtime_status;
int runtime_error;
#endif
};
/*在设备加入设备驱动模型时，对设备进行初始化*/
device_initialize(&dev->dev);
void device_initialize(struct device *dev)
{
............
device_pm_init(dev); //继续进行初始化
...............
}
{
............
device_pm_init(dev); //继续进行初始化
...............
}
void device_pm_init(struct device *dev)
{
dev->power.status = DPM_ON;
init_completion(&dev->power.completion);
complete_all(&dev->power.completion);
pm_runtime_init(dev); //调用该函数继续进行初始化
}
{
dev->power.status = DPM_ON;
init_completion(&dev->power.completion);
complete_all(&dev->power.completion);
pm_runtime_init(dev); //调用该函数继续进行初始化
}
void pm_runtime_init(struct device *dev)
{
spin_lock_init(&dev->power.lock);
dev->power.runtime_status = RPM_SUSPENDED;
dev->power.idle_notification = false;
dev->power.idle_notification = false;
dev->power.disable_depth = 1; //初始化时，disable该pm runtime功能
atomic_set(&dev->power.usage_count, 0);
atomic_set(&dev->power.usage_count, 0);
dev->power.runtime_error = 0;
atomic_set(&dev->power.child_count, 0);
pm_suspend_ignore_children(dev, false);
dev->power.runtime_auto = true;
pm_suspend_ignore_children(dev, false);
dev->power.runtime_auto = true;
dev->power.request_pending = false;
dev->power.request = RPM_REQ_NONE;
dev->power.deferred_resume = false;
INIT_WORK(&dev->power.work, pm_runtime_work); //处理autosuspend请求用的work
dev->power.request = RPM_REQ_NONE;
dev->power.deferred_resume = false;
INIT_WORK(&dev->power.work, pm_runtime_work); //处理autosuspend请求用的work
/*处理work请求定时器*/
dev->power.timer_expires = 0;
setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,(unsigned long)dev);
dev->power.timer_expires = 0;
setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,(unsigned long)dev);
init_waitqueue_head(&dev->power.wait_queue);//初始化等待队列
}
}
***************************************************************
/*注册的usb总线级别的操作*/
static int usb_runtime_suspend(struct device *dev)//usb的挂机函数
{
int status = 0;
/*注册的usb总线级别的操作*/
static int usb_runtime_suspend(struct device *dev)//usb的挂机函数
{
int status = 0;
/* A USB device can be suspended if it passes the various autosuspend
* checks. Runtime suspend for a USB device means suspending all the
* interfaces and then the device itself.
*/
if (is_usb_device(dev)) {//针对usb设备
struct usb_device *udev = to_usb_device(dev);
* checks. Runtime suspend for a USB device means suspending all the
* interfaces and then the device itself.
*/
if (is_usb_device(dev)) {//针对usb设备
struct usb_device *udev = to_usb_device(dev);
if (autosuspend_check(udev) != 0)//是否支持自动挂起？
return -EAGAIN;
return -EAGAIN;
status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);// 如果不支持，则继续挂机流程
/* If an interface fails the suspend, adjust the last_busy
* time so that we don't get another suspend attempt right
* away.
*/
if (status) {
udev->last_busy = jiffies + (udev->autosuspend_delay == 0 ? HZ/2 : 0);
}
* time so that we don't get another suspend attempt right
* away.
*/
if (status) {
udev->last_busy = jiffies + (udev->autosuspend_delay == 0 ? HZ/2 : 0);
}
/* Prevent the parent from suspending immediately after */
else if (udev->parent) {
udev->parent->last_busy = jiffies;
}
}
else if (udev->parent) {
udev->parent->last_busy = jiffies;
}
}
/* Runtime suspend for a USB interface doesn't mean anything. */
return status;
}
return status;
}
static int usb_runtime_resume(struct device *dev)//usb的唤醒函数
{
/* Runtime resume for a USB device means resuming both the device
* and all its interfaces.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
int status;
{
/* Runtime resume for a USB device means resuming both the device
* and all its interfaces.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
int status;
status = usb_resume_both(udev, PMSG_AUTO_RESUME);
udev->last_busy = jiffies;
return status;
}
udev->last_busy = jiffies;
return status;
}
/* Runtime resume for a USB interface doesn't mean anything. */
return 0;
}
return 0;
}
static int usb_runtime_idle(struct device *dev)//usb设备的idle函数
{
/* An idle USB device can be suspended if it passes the various
* autosuspend checks. An idle interface can be suspended at
* any time.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
{
/* An idle USB device can be suspended if it passes the various
* autosuspend checks. An idle interface can be suspended at
* any time.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
if (autosuspend_check(udev) != 0)//支持自动挂起
return 0;
}
return 0;
}
pm_runtime_suspend(dev);
return 0;
}
return 0;
}
static struct dev_pm_ops usb_bus_pm_ops = {
.runtime_suspend = usb_runtime_suspend,
.runtime_resume = usb_runtime_resume,
.runtime_idle = usb_runtime_idle,
};
.runtime_suspend = usb_runtime_suspend,
.runtime_resume = usb_runtime_resume,
.runtime_idle = usb_runtime_idle,
};
struct bus_type usb_bus_type = {
.name = "usb",
.match = usb_device_match,
.uevent = usb_uevent,
.pm = &usb_bus_pm_ops,
};
.name = "usb",
.match = usb_device_match,
.uevent = usb_uevent,
.pm = &usb_bus_pm_ops,
};
上面是系统和usb子系统的电源管理初始化部分。
/**************************************************************************/
usb子系统电源管理的调用过程，必须要调用下面两个函数，就从这两个函数开始跟起。
/*驱动调用的接口开始，传入的是usb设备结构体或者usb接口设备结构体*/
static inline int pm_runtime_put(struct device *dev)
{
return __pm_runtime_put(dev, false);
}
static inline int pm_runtime_put(struct device *dev)
{
return __pm_runtime_put(dev, false);
}
static inline int pm_runtime_put_sync(struct device *dev)
{
return __pm_runtime_put(dev, true);
}
{
return __pm_runtime_put(dev, true);
}
上面两个函数一个是同步的一个是不同步的。先跟同步的：
/*当sync为true时，走的如下流程*/
int __pm_runtime_put(struct device *dev, bool sync)
{
int retval = 0;
if (atomic_dec_and_test(&dev->power.usage_count))
retval = sync ? pm_runtime_idle(dev) : pm_request_idle(dev);
int __pm_runtime_put(struct device *dev, bool sync)
{
int retval = 0;
if (atomic_dec_and_test(&dev->power.usage_count))
retval = sync ? pm_runtime_idle(dev) : pm_request_idle(dev);
return retval;
}
}
int pm_runtime_idle(struct device *dev)
{
int retval;
{
int retval;
spin_lock_irq(&dev->power.lock);
retval = __pm_runtime_idle(dev);
spin_unlock_irq(&dev->power.lock);
retval = __pm_runtime_idle(dev);
spin_unlock_irq(&dev->power.lock);
return retval;
}
}
static int __pm_runtime_idle(struct device *dev)
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
dev->power.idle_notification = true;
if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
dev->bus->pm->runtime_idle(dev);//调用usb总线的idle函数
spin_lock_irq(&dev->power.lock);
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
dev->type->pm->runtime_idle(dev);
spin_lock_irq(&dev->power.lock);
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
dev->class->pm->runtime_idle(dev);
spin_lock_irq(&dev->power.lock);
}
}
dev->power.idle_notification = false;
wake_up_all(&dev->power.wait_queue);
wake_up_all(&dev->power.wait_queue);
out:
return retval;
}
return retval;
}
/*usb总线的idle函数如下*/
static int usb_runtime_idle(struct device *dev)
{
/* An idle USB device can be suspended if it passes the various
* autosuspend checks. An idle interface can be suspended at
* any time.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
{
/* An idle USB device can be suspended if it passes the various
* autosuspend checks. An idle interface can be suspended at
* any time.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
if (autosuspend_check(udev) != 0)//检测是否自动挂起，如果是自动挂起的话，走自动挂起流程
return 0;
}
return 0;
}
pm_runtime_suspend(dev);//如果不是自动挂起，则继续suspend
return 0;
}
return 0;
}
int pm_runtime_suspend(struct device *dev)
{
int retval;
{
int retval;
spin_lock_irq(&dev->power.lock);
retval = __pm_runtime_suspend(dev, false);
spin_unlock_irq(&dev->power.lock);
retval = __pm_runtime_suspend(dev, false);
spin_unlock_irq(&dev->power.lock);
return retval;
}
}
int __pm_runtime_suspend(struct device *dev, bool from_wq)
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
dev_dbg(dev, "__pm_runtime_suspend()%s!\n",
from_wq ? " from workqueue" : "");
from_wq ? " from workqueue" : "");
repeat:
/* Other scheduled or pending requests need to be canceled. */
pm_runtime_cancel_pending(dev);
pm_runtime_cancel_pending(dev);
if (dev->power.runtime_status == RPM_SUSPENDING) {
DEFINE_WAIT(wait);
DEFINE_WAIT(wait);
if (from_wq) {
retval = -EINPROGRESS;
goto out;
}
retval = -EINPROGRESS;
goto out;
}
/* Wait for the other suspend running in parallel with us. */
for (;;) {
prepare_to_wait(&dev->power.wait_queue, &wait, TASK_UNINTERRUPTIBLE);
if (dev->power.runtime_status != RPM_SUSPENDING)
break;
for (;;) {
prepare_to_wait(&dev->power.wait_queue, &wait, TASK_UNINTERRUPTIBLE);
if (dev->power.runtime_status != RPM_SUSPENDING)
break;
spin_unlock_irq(&dev->power.lock);
schedule();
spin_lock_irq(&dev->power.lock);
}
finish_wait(&dev->power.wait_queue, &wait);
goto repeat;
}
}
finish_wait(&dev->power.wait_queue, &wait);
goto repeat;
}
dev->power.runtime_status = RPM_SUSPENDING;
dev->power.deferred_resume = false;
dev->power.deferred_resume = false;
if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
retval = dev->bus->pm->runtime_suspend(dev);//调用总线的runtime suspend函数
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
retval = dev->type->pm->runtime_suspend(dev);
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
retval = dev->class->pm->runtime_suspend(dev);
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else {
retval = -ENOSYS;
}
dev->power.runtime_error = retval;
} else {
retval = -ENOSYS;
}
wake_up_all(&dev->power.wait_queue);
if (dev->power.deferred_resume) {
__pm_runtime_resume(dev, false);
retval = -EAGAIN;
goto out;
}
__pm_runtime_resume(dev, false);
retval = -EAGAIN;
goto out;
}
if (notify)
__pm_runtime_idle(dev);
__pm_runtime_idle(dev);
if (parent && !parent->power.ignore_children) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
pm_request_idle(parent);
spin_lock_irq(&dev->power.lock);
}
}
out:
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
return retval;
}
}
static int usb_runtime_suspend(struct device *dev)
{
int status = 0;
{
int status = 0;
/* A USB device can be suspended if it passes the various autosuspend
* checks. Runtime suspend for a USB device means suspending all the
* interfaces and then the device itself.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
* checks. Runtime suspend for a USB device means suspending all the
* interfaces and then the device itself.
*/
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
if (autosuspend_check(udev) != 0)//是否自動挂起，如果是走自动挂起流程
return -EAGAIN;
return -EAGAIN;
status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);//否则继续suspend
/* If an interface fails the suspend, adjust the last_busy
* time so that we don't get another suspend attempt right
* away.
*/
if (status) {
udev->last_busy = jiffies +(udev->autosuspend_delay == 0 ? HZ/2 : 0);
}
* time so that we don't get another suspend attempt right
* away.
*/
if (status) {
udev->last_busy = jiffies +(udev->autosuspend_delay == 0 ? HZ/2 : 0);
}
/* Prevent the parent from suspending immediately after */
else if (udev->parent) {
udev->parent->last_busy = jiffies;
}
}
else if (udev->parent) {
udev->parent->last_busy = jiffies;
}
}
/* Runtime suspend for a USB interface doesn't mean anything. */
return status;
}
return status;
}
static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
{
int status = 0;
int i = 0, n = 0;
struct usb_interface *intf;
{
int status = 0;
int i = 0, n = 0;
struct usb_interface *intf;
if (udev->state == USB_STATE_NOTATTACHED || udev->state == USB_STATE_SUSPENDED)
goto done;
goto done;
/* Suspend all the interfaces and then udev itself */
if (udev->actconfig) {//挂起所有的接口
n = udev->actconfig->desc.bNumInterfaces;
for (i = n - 1; i >= 0; --i) {
intf = udev->actconfig->interface[i];
status = usb_suspend_interface(udev, intf, msg);
if (status != 0)
break;
}
}
if (status == 0)
status = usb_suspend_device(udev, msg);//挂起该设备本身
if (udev->actconfig) {//挂起所有的接口
n = udev->actconfig->desc.bNumInterfaces;
for (i = n - 1; i >= 0; --i) {
intf = udev->actconfig->interface[i];
status = usb_suspend_interface(udev, intf, msg);
if (status != 0)
break;
}
}
if (status == 0)
status = usb_suspend_device(udev, msg);//挂起该设备本身
/* If the suspend failed, resume interfaces that did get suspended */
if (status != 0) {
msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
while (++i < n) {
intf = udev->actconfig->interface[i];
usb_resume_interface(udev, intf, msg, 0);
}
if (status != 0) {
msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
while (++i < n) {
intf = udev->actconfig->interface[i];
usb_resume_interface(udev, intf, msg, 0);
}
/* If the suspend succeeded then prevent any more URB submissions
* and flush any outstanding URBs.
*/
} else {
udev->can_submit = 0;
for (i = 0; i < 16; ++i) {
usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
}
}
* and flush any outstanding URBs.
*/
} else {
udev->can_submit = 0;
for (i = 0; i < 16; ++i) {
usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
}
}
done:
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
{
struct usb_device_driver *udriver;
int status = 0;
{
struct usb_device_driver *udriver;
int status = 0;
if (udev->state == USB_STATE_NOTATTACHED ||
udev->state == USB_STATE_SUSPENDED)
goto done;
udev->state == USB_STATE_SUSPENDED)
goto done;
/* For devices that don't have a driver, we do a generic suspend. */
if (udev->dev.driver)
udriver = to_usb_device_driver(udev->dev.driver);
else {
udev->do_remote_wakeup = 0;
udriver = &usb_generic_driver;
}
status = udriver->suspend(udev, msg);//调用通用的设备驱动挂起函数
if (udev->dev.driver)
udriver = to_usb_device_driver(udev->dev.driver);
else {
udev->do_remote_wakeup = 0;
udriver = &usb_generic_driver;
}
status = udriver->suspend(udev, msg);//调用通用的设备驱动挂起函数
done:
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
static int generic_suspend(struct usb_device *udev, pm_message_t msg)
{
int rc;
{
int rc;
/* Normal USB devices suspend through their upstream port.
* Root hubs don't have upstream ports to suspend,
* so we have to shut down their downstream HC-to-USB
* interfaces manually by doing a bus (or "global") suspend.
*/
if (!udev->parent)//针对root hub的
rc = hcd_bus_suspend(udev, msg);//挂起root hub
* Root hubs don't have upstream ports to suspend,
* so we have to shut down their downstream HC-to-USB
* interfaces manually by doing a bus (or "global") suspend.
*/
if (!udev->parent)//针对root hub的
rc = hcd_bus_suspend(udev, msg);//挂起root hub
/* Non-root devices don't need to do anything for FREEZE or PRETHAW */
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);//挂起每个端口设备
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);//挂起每个端口设备
return rc;
}
}
*********************************************************************
下面是自动挂起的流程（上面的蓝色字体标出调用的地方），最终也会走到generic_suspend，相当于两条小溪最终汇成一起。
/* Internal routine to check whether we may autosuspend a device. */
static int autosuspend_check(struct usb_device *udev)
{
int w, i;
struct usb_interface *intf;
unsigned long suspend_time, j;
static int autosuspend_check(struct usb_device *udev)
{
int w, i;
struct usb_interface *intf;
unsigned long suspend_time, j;
/* Fail if autosuspend is disabled, or any interfaces are in use, or
* any interface drivers require remote wakeup but it isn't available.
*/
w = 0;
if (udev->actconfig) {
for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
intf = udev->actconfig->interface[i];
* any interface drivers require remote wakeup but it isn't available.
*/
w = 0;
if (udev->actconfig) {
for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
intf = udev->actconfig->interface[i];
/* We don't need to check interfaces that are
* disabled for runtime PM. Either they are unbound
* or else their drivers don't support autosuspend
* and so they are permanently active.
*/
if (intf->dev.power.disable_depth)
continue;
if (atomic_read(&intf->dev.power.usage_count) > 0)
return -EBUSY;
w |= intf->needs_remote_wakeup;
* disabled for runtime PM. Either they are unbound
* or else their drivers don't support autosuspend
* and so they are permanently active.
*/
if (intf->dev.power.disable_depth)
continue;
if (atomic_read(&intf->dev.power.usage_count) > 0)
return -EBUSY;
w |= intf->needs_remote_wakeup;
/* Don't allow autosuspend if the device will need
* a reset-resume and any of its interface drivers
* doesn't include support or needs remote wakeup.
*/
if (udev->quirks & USB_QUIRK_RESET_RESUME) {
struct usb_driver *driver;
* a reset-resume and any of its interface drivers
* doesn't include support or needs remote wakeup.
*/
if (udev->quirks & USB_QUIRK_RESET_RESUME) {
struct usb_driver *driver;
driver = to_usb_driver(intf->dev.driver);
if (!driver->reset_resume ||
intf->needs_remote_wakeup)
return -EOPNOTSUPP;
}
}
}
if (w && !device_can_wakeup(&udev->dev)) {
dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
return -EOPNOTSUPP;
}
udev->do_remote_wakeup = w;
if (!driver->reset_resume ||
intf->needs_remote_wakeup)
return -EOPNOTSUPP;
}
}
}
if (w && !device_can_wakeup(&udev->dev)) {
dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
return -EOPNOTSUPP;
}
udev->do_remote_wakeup = w;
/* If everything is okay but the device hasn't been idle for long
* enough, queue a delayed autosuspend request.
*/
j = ACCESS_ONCE(jiffies);
suspend_time = udev->last_busy + udev->autosuspend_delay;
if (time_before(j, suspend_time)) {
pm_schedule_suspend(&udev->dev, jiffies_to_msecs(round_jiffies_up_relative(suspend_time - j)));//调度
return -EAGAIN;
}
return 0;
}
* enough, queue a delayed autosuspend request.
*/
j = ACCESS_ONCE(jiffies);
suspend_time = udev->last_busy + udev->autosuspend_delay;
if (time_before(j, suspend_time)) {
pm_schedule_suspend(&udev->dev, jiffies_to_msecs(round_jiffies_up_relative(suspend_time - j)));//调度
return -EAGAIN;
}
return 0;
}
/**
* pm_schedule_suspend - Set up a timer to submit a suspend request in future.
* @dev: Device to suspend.
* @delay: Time to wait before submitting a suspend request, in milliseconds.
*/
int pm_schedule_suspend(struct device *dev, unsigned int delay)
{
unsigned long flags;
int retval = 0;
* pm_schedule_suspend - Set up a timer to submit a suspend request in future.
* @dev: Device to suspend.
* @delay: Time to wait before submitting a suspend request, in milliseconds.
*/
int pm_schedule_suspend(struct device *dev, unsigned int delay)
{
unsigned long flags;
int retval = 0;
spin_lock_irqsave(&dev->power.lock, flags);
if (dev->power.runtime_error) {
retval = -EINVAL;
goto out;
}
retval = -EINVAL;
goto out;
}
if (!delay) {
retval = __pm_request_suspend(dev);//如果没有delay，则立即执行
goto out;
}
retval = __pm_request_suspend(dev);//如果没有delay，则立即执行
goto out;
}
pm_runtime_deactivate_timer(dev);
if (dev->power.request_pending) {
/*
* Pending resume requests take precedence over us, but any
* other pending requests have to be canceled.
*/
if (dev->power.request == RPM_REQ_RESUME) {
retval = -EAGAIN;
goto out;
}
dev->power.request = RPM_REQ_NONE;
}
/*
* Pending resume requests take precedence over us, but any
* other pending requests have to be canceled.
*/
if (dev->power.request == RPM_REQ_RESUME) {
retval = -EAGAIN;
goto out;
}
dev->power.request = RPM_REQ_NONE;
}
if (dev->power.runtime_status == RPM_SUSPENDED)
retval = 1;
else if (atomic_read(&dev->power.usage_count) > 0
|| dev->power.disable_depth > 0)
retval = -EAGAIN;
else if (!pm_children_suspended(dev))
retval = -EBUSY;
if (retval)
goto out;
retval = 1;
else if (atomic_read(&dev->power.usage_count) > 0
|| dev->power.disable_depth > 0)
retval = -EAGAIN;
else if (!pm_children_suspended(dev))
retval = -EBUSY;
if (retval)
goto out;
dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
if (!dev->power.timer_expires)
dev->power.timer_expires = 1;
mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);//如果有超时，等待定时器到期，执行处理函数pm_suspend_timer_fn
if (!dev->power.timer_expires)
dev->power.timer_expires = 1;
mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);//如果有超时，等待定时器到期，执行处理函数pm_suspend_timer_fn
out:
spin_unlock_irqrestore(&dev->power.lock, flags);
spin_unlock_irqrestore(&dev->power.lock, flags);
return retval;
}
}
/*定时器到期处理函数*/
static void pm_suspend_timer_fn(unsigned long data)
{
struct device *dev = (struct device *)data;
unsigned long flags;
unsigned long expires;
{
struct device *dev = (struct device *)data;
unsigned long flags;
unsigned long expires;
spin_lock_irqsave(&dev->power.lock, flags);
expires = dev->power.timer_expires;
/* If 'expire' is after 'jiffies' we've been called too early. */
if (expires > 0 && !time_after(expires, jiffies)) {
dev->power.timer_expires = 0;
__pm_request_suspend(dev);//定时器到时，执行该函数
}
/* If 'expire' is after 'jiffies' we've been called too early. */
if (expires > 0 && !time_after(expires, jiffies)) {
dev->power.timer_expires = 0;
__pm_request_suspend(dev);//定时器到时，执行该函数
}
spin_unlock_irqrestore(&dev->power.lock, flags);
}
}
/*无论是定时器超时，还是直接调用，都会调用下面该函数*/
static int __pm_request_suspend(struct device *dev)
{
int retval = 0;
static int __pm_request_suspend(struct device *dev)
{
int retval = 0;
if (dev->power.runtime_error)
return -EINVAL;
return -EINVAL;
if (dev->power.runtime_status == RPM_SUSPENDED)
retval = 1;
else if (atomic_read(&dev->power.usage_count) > 0
|| dev->power.disable_depth > 0)
retval = -EAGAIN;
else if (dev->power.runtime_status == RPM_SUSPENDING)
retval = -EINPROGRESS;
else if (!pm_children_suspended(dev))
retval = -EBUSY;
if (retval < 0)
return retval;
retval = 1;
else if (atomic_read(&dev->power.usage_count) > 0
|| dev->power.disable_depth > 0)
retval = -EAGAIN;
else if (dev->power.runtime_status == RPM_SUSPENDING)
retval = -EINPROGRESS;
else if (!pm_children_suspended(dev))
retval = -EBUSY;
if (retval < 0)
return retval;
pm_runtime_deactivate_timer(dev);
if (dev->power.request_pending) {
/*
* Pending resume requests take precedence over us, but we can
* overtake any other pending request.
*/
if (dev->power.request == RPM_REQ_RESUME)
retval = -EAGAIN;
else if (dev->power.request != RPM_REQ_SUSPEND)
dev->power.request = retval ?
RPM_REQ_NONE : RPM_REQ_SUSPEND;
return retval;
} else if (retval) {
return retval;
}
/*
* Pending resume requests take precedence over us, but we can
* overtake any other pending request.
*/
if (dev->power.request == RPM_REQ_RESUME)
retval = -EAGAIN;
else if (dev->power.request != RPM_REQ_SUSPEND)
dev->power.request = retval ?
RPM_REQ_NONE : RPM_REQ_SUSPEND;
return retval;
} else if (retval) {
return retval;
}
dev->power.request = RPM_REQ_SUSPEND;//请求状态为suspend
dev->power.request_pending = true;
queue_work(pm_wq, &dev->power.work);//调度work
dev->power.request_pending = true;
queue_work(pm_wq, &dev->power.work);//调度work
return 0;
}
}
static void pm_runtime_work(struct work_struct *work)
{
struct device *dev = container_of(work, struct device, power.work);
enum rpm_request req;
struct device *dev = container_of(work, struct device, power.work);
enum rpm_request req;
spin_lock_irq(&dev->power.lock);
if (!dev->power.request_pending)
goto out;
goto out;
req = dev->power.request;
dev->power.request = RPM_REQ_NONE;
dev->power.request_pending = false;
dev->power.request = RPM_REQ_NONE;
dev->power.request_pending = false;
switch (req) {
case RPM_REQ_NONE:
break;
case RPM_REQ_IDLE:
__pm_runtime_idle(dev);
break;
case RPM_REQ_SUSPEND:
__pm_runtime_suspend(dev, true); //调用suspend函数
break;
case RPM_REQ_RESUME:
__pm_runtime_resume(dev, true);
break;
}
case RPM_REQ_NONE:
break;
case RPM_REQ_IDLE:
__pm_runtime_idle(dev);
break;
case RPM_REQ_SUSPEND:
__pm_runtime_suspend(dev, true); //调用suspend函数
break;
case RPM_REQ_RESUME:
__pm_runtime_resume(dev, true);
break;
}
out:
spin_unlock_irq(&dev->power.lock);
}
spin_unlock_irq(&dev->power.lock);
}
int __pm_runtime_suspend(struct device *dev, bool from_wq)
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
dev_dbg(dev, "__pm_runtime_suspend()%s!\n",from_wq ? " from workqueue" : "");
...................
if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
retval = dev->bus->pm->runtime_suspend(dev);//调用usb总线的runtime_suspend函数
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
}
...................
dev->power.runtime_error = retval;
}
...................
out:
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
return retval;
}
}
static int usb_runtime_suspend(struct device *dev)
{
int status = 0;
{
int status = 0;
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
struct usb_device *udev = to_usb_device(dev);
if (autosuspend_check(udev) != 0)
return -EAGAIN;
return -EAGAIN;
status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);//3
...............
return status;
}
return status;
}
static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
{
int status = 0;
int i = 0, n = 0;
struct usb_interface *intf;
{
int status = 0;
int i = 0, n = 0;
struct usb_interface *intf;
if (udev->state == USB_STATE_NOTATTACHED ||
udev->state == USB_STATE_SUSPENDED)
goto done;
udev->state == USB_STATE_SUSPENDED)
goto done;
/* Suspend all the interfaces and then udev itself */
if (udev->actconfig) {//挂起所以端口
n = udev->actconfig->desc.bNumInterfaces;
for (i = n - 1; i >= 0; --i) {
intf = udev->actconfig->interface[i];
status = usb_suspend_interface(udev, intf, msg);
if (status != 0)
break;
}
}
if (status == 0)
status = usb_suspend_device(udev, msg);//挂起usb设备本身
..............
} else {
if (udev->actconfig) {//挂起所以端口
n = udev->actconfig->desc.bNumInterfaces;
for (i = n - 1; i >= 0; --i) {
intf = udev->actconfig->interface[i];
status = usb_suspend_interface(udev, intf, msg);
if (status != 0)
break;
}
}
if (status == 0)
status = usb_suspend_device(udev, msg);//挂起usb设备本身
..............
} else {
udev->can_submit = 0;
for (i = 0; i < 16; ++i) {
usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
}
}
for (i = 0; i < 16; ++i) {
usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
}
}
done:
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
{
if (udev->dev.driver)
udriver = to_usb_device_driver(udev->dev.driver);
else {
udev->do_remote_wakeup = 0;
udriver = &usb_generic_driver;
}
status = udriver->suspend(udev, msg);//5
{
if (udev->dev.driver)
udriver = to_usb_device_driver(udev->dev.driver);
else {
udev->do_remote_wakeup = 0;
udriver = &usb_generic_driver;
}
status = udriver->suspend(udev, msg);//5
done:
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
return status;
}
struct usb_device_driver usb_generic_driver = {
.name = "usb",
.probe = generic_probe,
.disconnect = generic_disconnect,
#ifdef CONFIG_PM
.suspend = generic_suspend,//6
.resume = generic_resume,
#endif
.supports_autosuspend = 1,
};
.name = "usb",
.probe = generic_probe,
.disconnect = generic_disconnect,
#ifdef CONFIG_PM
.suspend = generic_suspend,//6
.resume = generic_resume,
#endif
.supports_autosuspend = 1,
};
static int generic_suspend(struct usb_device *udev, pm_message_t msg)
{
int rc;
{
int rc;
if (!udev->parent)
rc = hcd_bus_suspend(udev, msg);//7
rc = hcd_bus_suspend(udev, msg);//7
/* Non-root devices don't need to do anything for FREEZE or PRETHAW */
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);
return rc;
}
}
***************************************************
/*通用usb设备的suspend函数，上面的自动挂起和正常挂起都会走*/
static int generic_suspend(struct usb_device *udev, pm_message_t msg)
{
int rc;
static int generic_suspend(struct usb_device *udev, pm_message_t msg)
{
int rc;
/* Normal USB devices suspend through their upstream port.
* Root hubs don't have upstream ports to suspend,
* so we have to shut down their downstream HC-to-USB
* interfaces manually by doing a bus (or "global") suspend.
*/
if (!udev->parent)//针对root hub
rc = hcd_bus_suspend(udev, msg);//挂起root hub的下流口
* Root hubs don't have upstream ports to suspend,
* so we have to shut down their downstream HC-to-USB
* interfaces manually by doing a bus (or "global") suspend.
*/
if (!udev->parent)//针对root hub
rc = hcd_bus_suspend(udev, msg);//挂起root hub的下流口
/* Non-root devices don't need to do anything for FREEZE or PRETHAW */
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);//关闭usb设备的上流口
else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
rc = 0;
else
rc = usb_port_suspend(udev, msg);//关闭usb设备的上流口
return rc;
}
}
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
{
struct usb_hub *hub = hdev_to_hub(udev->parent);
int port1 = udev->portnum;
int status;
{
struct usb_hub *hub = hdev_to_hub(udev->parent);
int port1 = udev->portnum;
int status;
// dev_dbg(hub->intfdev, "suspend port %d\n", port1);
/* enable remote wakeup when appropriate; this lets the device
* wake up the upstream hub (including maybe the root hub).
*
* NOTE: OTG devices may issue remote wakeup (or SRP) even when
* we don't explicitly enable it here.
*/
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,
NULL, 0,
USB_CTRL_SET_TIMEOUT);
}
* wake up the upstream hub (including maybe the root hub).
*
* NOTE: OTG devices may issue remote wakeup (or SRP) even when
* we don't explicitly enable it here.
*/
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,
NULL, 0,
USB_CTRL_SET_TIMEOUT);
}
/* see 7.1.7.6 */
status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);
/* device has up to 10 msec to fully suspend */
dev_dbg(&udev->dev, "usb %ssuspend\n",(msg.event & PM_EVENT_AUTO ? "auto-" : ""));
usb_set_device_state(udev, USB_STATE_SUSPENDED);//设置usb设备为挂起状态
msleep(10);
}
return status;
}
status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);
/* device has up to 10 msec to fully suspend */
dev_dbg(&udev->dev, "usb %ssuspend\n",(msg.event & PM_EVENT_AUTO ? "auto-" : ""));
usb_set_device_state(udev, USB_STATE_SUSPENDED);//设置usb设备为挂起状态
msleep(10);
}
return status;
}
/*挂起root hub*/
int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
{
struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
int status;
int old_state = hcd->state;
{
struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
int status;
int old_state = hcd->state;
dev_dbg(&rhdev->dev, "bus %s%s\n",
(msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
if (!hcd->driver->bus_suspend) {
status = -ENOENT;
} else {
hcd->state = HC_STATE_QUIESCING;
status = hcd->driver->bus_suspend(hcd);//调用主机控制器driver的bus suspend
}
if (status == 0) {
usb_set_device_state(rhdev, USB_STATE_SUSPENDED);//设置root hub设备的状态为suspend状态
hcd->state = HC_STATE_SUSPENDED;
} else {
hcd->state = old_state;
dev_dbg(&rhdev->dev, "bus %s fail, err %d\n","suspend", status);
}
return status;
}
(msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
if (!hcd->driver->bus_suspend) {
status = -ENOENT;
} else {
hcd->state = HC_STATE_QUIESCING;
status = hcd->driver->bus_suspend(hcd);//调用主机控制器driver的bus suspend
}
if (status == 0) {
usb_set_device_state(rhdev, USB_STATE_SUSPENDED);//设置root hub设备的状态为suspend状态
hcd->state = HC_STATE_SUSPENDED;
} else {
hcd->state = old_state;
dev_dbg(&rhdev->dev, "bus %s fail, err %d\n","suspend", status);
}
return status;
}
static struct hc_driver msm_hc_driver = {
.description = hcd_name,
.product_desc = "Qualcomm On-Chip EHCI Host Controller",
.hcd_priv_size = sizeof(struct msmusb_hcd),
.description = hcd_name,
.product_desc = "Qualcomm On-Chip EHCI Host Controller",
.hcd_priv_size = sizeof(struct msmusb_hcd),
/*
* generic hardware linkage
*/
.irq = ehci_msm_irq,
.flags = HCD_USB2,
* generic hardware linkage
*/
.irq = ehci_msm_irq,
.flags = HCD_USB2,
.reset = ehci_msm_reset,
.start = ehci_msm_run,
.start = ehci_msm_run,
.stop = ehci_stop,
.shutdown = ehci_shutdown,
.shutdown = ehci_shutdown,
/*
* managing i/o requests and associated device resources
*/
.urb_enqueue = ehci_urb_enqueue,
.urb_dequeue = ehci_urb_dequeue,
.endpoint_disable = ehci_endpoint_disable,
* managing i/o requests and associated device resources
*/
.urb_enqueue = ehci_urb_enqueue,
.urb_dequeue = ehci_urb_dequeue,
.endpoint_disable = ehci_endpoint_disable,
/*
* scheduling support
*/
.get_frame_number = ehci_get_frame,
* scheduling support
*/
.get_frame_number = ehci_get_frame,
/*
* root hub support
*/
.hub_status_data = ehci_hub_status_data,
.hub_control = ehci_hub_control,
.bus_suspend = ehci_msm_bus_suspend,//调用该suspend函数
.bus_resume = ehci_msm_bus_resume,
.relinquish_port = ehci_relinquish_port,
* root hub support
*/
.hub_status_data = ehci_hub_status_data,
.hub_control = ehci_hub_control,
.bus_suspend = ehci_msm_bus_suspend,//调用该suspend函数
.bus_resume = ehci_msm_bus_resume,
.relinquish_port = ehci_relinquish_port,
.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
};
};
static int ehci_msm_bus_suspend(struct usb_hcd *hcd)
{
int ret;
struct msmusb_hcd *mhcd = hcd_to_mhcd(hcd);
struct device *dev = hcd->self.controller;
{
int ret;
struct msmusb_hcd *mhcd = hcd_to_mhcd(hcd);
struct device *dev = hcd->self.controller;
ret = ehci_bus_suspend(hcd);//root hub挂起
if (ret) {
pr_err("ehci_bus suspend faield\n");
return ret;
}
if (ret) {
pr_err("ehci_bus suspend faield\n");
return ret;
}
/*下面是挂起otg控制器*/
if (PHY_TYPE(mhcd->pdata->phy_info) == USB_PHY_INTEGRATED)
ret = otg_set_suspend(mhcd->xceiv, 1);//otg挂起，调用该函数
else
ret = usb_lpm_enter(hcd);
if (PHY_TYPE(mhcd->pdata->phy_info) == USB_PHY_INTEGRATED)
ret = otg_set_suspend(mhcd->xceiv, 1);//otg挂起，调用该函数
else
ret = usb_lpm_enter(hcd);
pm_runtime_put_noidle(dev);
pm_runtime_suspend(dev);
wake_unlock(&mhcd->wlock);
return ret;
}
pm_runtime_suspend(dev);
wake_unlock(&mhcd->wlock);
return ret;
}
static inline int otg_set_suspend(struct otg_transceiver *otg, int suspend)
{
if (otg->set_suspend != NULL)
return otg->set_suspend(otg, suspend);
else
return 0;
}
{
if (otg->set_suspend != NULL)
return otg->set_suspend(otg, suspend);
else
return 0;
}
dev->otg.set_suspend = msm_otg_set_suspend;
static int msm_otg_set_suspend(struct otg_transceiver *xceiv, int suspend)
{
struct msm_otg *dev = container_of(xceiv, struct msm_otg, otg);
enum usb_otg_state state;
unsigned long flags;
if (!dev || (dev != the_msm_otg))
return -ENODEV;
return -ENODEV;
spin_lock_irqsave(&dev->lock, flags);
state = dev->otg.state;
spin_unlock_irqrestore(&dev->lock, flags);
state = dev->otg.state;
spin_unlock_irqrestore(&dev->lock, flags);
pr_debug("suspend request in state: %s\n",
state_string(state));
state_string(state));
if (suspend) {
switch (state) {
#ifndef CONFIG_MSM_OTG_ENABLE_A_WAIT_BCON_TIMEOUT
case OTG_STATE_A_WAIT_BCON:
if (test_bit(ID_A, &dev->inputs))
msm_otg_set_power(xceiv, USB_IDCHG_MIN - 100);
msm_otg_put_suspend(dev);//如果没有usb设备连接，则进入该函数
break;
#endif
case OTG_STATE_A_HOST:
clear_bit(A_BUS_REQ, &dev->inputs);
wake_lock(&dev->wlock);
queue_work(dev->wq, &dev->sm_work);
break;
case OTG_STATE_B_PERIPHERAL:
if (xceiv->gadget->b_hnp_enable) {
set_bit(A_BUS_SUSPEND, &dev->inputs);
set_bit(B_BUS_REQ, &dev->inputs);
wake_lock(&dev->wlock);
queue_work(dev->wq, &dev->sm_work);
}
break;
case OTG_STATE_A_PERIPHERAL:
msm_otg_start_timer(dev, TA_BIDL_ADIS,
A_BIDL_ADIS);
break;
default:
break;
}
} else {
unsigned long timeout;
switch (state) {
#ifndef CONFIG_MSM_OTG_ENABLE_A_WAIT_BCON_TIMEOUT
case OTG_STATE_A_WAIT_BCON:
if (test_bit(ID_A, &dev->inputs))
msm_otg_set_power(xceiv, USB_IDCHG_MIN - 100);
msm_otg_put_suspend(dev);//如果没有usb设备连接，则进入该函数
break;
#endif
case OTG_STATE_A_HOST:
clear_bit(A_BUS_REQ, &dev->inputs);
wake_lock(&dev->wlock);
queue_work(dev->wq, &dev->sm_work);
break;
case OTG_STATE_B_PERIPHERAL:
if (xceiv->gadget->b_hnp_enable) {
set_bit(A_BUS_SUSPEND, &dev->inputs);
set_bit(B_BUS_REQ, &dev->inputs);
wake_lock(&dev->wlock);
queue_work(dev->wq, &dev->sm_work);
}
break;
case OTG_STATE_A_PERIPHERAL:
msm_otg_start_timer(dev, TA_BIDL_ADIS,
A_BIDL_ADIS);
break;
default:
break;
}
} else {
unsigned long timeout;
switch (state) {
case OTG_STATE_A_PERIPHERAL:
/* A-peripheral observed activity on bus.
* clear A_BIDL_ADIS timer.
*/
msm_otg_del_timer(dev);
break;
case OTG_STATE_A_SUSPEND:
/* Remote wakeup or resume */
set_bit(A_BUS_REQ, &dev->inputs);
spin_lock_irqsave(&dev->lock, flags);
dev->otg.state = OTG_STATE_A_HOST;
spin_unlock_irqrestore(&dev->lock, flags);
if (test_bit(ID_A, &dev->inputs) &&
(get_aca_bmaxpower(dev) < USB_IDCHG_MIN))
msm_otg_set_power(xceiv,
USB_IDCHG_MIN - get_aca_bmaxpower(dev));
break;
default:
break;
}
case OTG_STATE_A_PERIPHERAL:
/* A-peripheral observed activity on bus.
* clear A_BIDL_ADIS timer.
*/
msm_otg_del_timer(dev);
break;
case OTG_STATE_A_SUSPEND:
/* Remote wakeup or resume */
set_bit(A_BUS_REQ, &dev->inputs);
spin_lock_irqsave(&dev->lock, flags);
dev->otg.state = OTG_STATE_A_HOST;
spin_unlock_irqrestore(&dev->lock, flags);
if (test_bit(ID_A, &dev->inputs) &&
(get_aca_bmaxpower(dev) < USB_IDCHG_MIN))
msm_otg_set_power(xceiv,
USB_IDCHG_MIN - get_aca_bmaxpower(dev));
break;
default:
break;
}
if (suspend == atomic_read(&dev->in_lpm))
return 0;
return 0;
disable_irq(dev->irq);
if (dev->pmic_vbus_notif_supp)
if (can_phy_power_collapse(dev) &&
dev->pdata->ldo_enable)
dev->pdata->ldo_enable(1);
if (dev->pmic_vbus_notif_supp)
if (can_phy_power_collapse(dev) &&
dev->pdata->ldo_enable)
dev->pdata->ldo_enable(1);
msm_otg_get_resume(dev);
if (!is_phy_clk_disabled())
goto out;
goto out;
timeout = jiffies + usecs_to_jiffies(100);
enable_phy_clk();
while (is_phy_clk_disabled()) {
if (time_after(jiffies, timeout)) {
pr_err("%s: Unable to wakeup phy\n", __func__);
/* Reset both phy and link */
otg_reset(&dev->otg, 1);
break;
}
udelay(10);
}
if (dev->pmic_id_notif_supp) {
dev->pdata->pmic_id_notif_init(
&msm_otg_set_id_state, 0);
dev->pmic_id_notif_supp = 0;
enable_idgnd(dev);
}
out:
enable_idabc(dev);
enable_irq(dev->irq);
enable_phy_clk();
while (is_phy_clk_disabled()) {
if (time_after(jiffies, timeout)) {
pr_err("%s: Unable to wakeup phy\n", __func__);
/* Reset both phy and link */
otg_reset(&dev->otg, 1);
break;
}
udelay(10);
}
if (dev->pmic_id_notif_supp) {
dev->pdata->pmic_id_notif_init(
&msm_otg_set_id_state, 0);
dev->pmic_id_notif_supp = 0;
enable_idgnd(dev);
}
out:
enable_idabc(dev);
enable_irq(dev->irq);
}
return 0;
}
}
//上面是主机控制器调用到的该流程.
//设备控制器直接调用该函数是设备进入suspend状态
/***************************************************************/
static void msm_otg_put_suspend(struct msm_otg *dev)
{
#ifdef CONFIG_PM_RUNTIME
pm_runtime_put_sync(dev->otg.dev);//调用该函数，注意：传入的是平台设备
if (!atomic_read(&dev->in_lpm))
pm_runtime_get_sync(dev->otg.dev);
#else
msm_otg_suspend(dev);
#endif
}
/***************************************************************/
static void msm_otg_put_suspend(struct msm_otg *dev)
{
#ifdef CONFIG_PM_RUNTIME
pm_runtime_put_sync(dev->otg.dev);//调用该函数，注意：传入的是平台设备
if (!atomic_read(&dev->in_lpm))
pm_runtime_get_sync(dev->otg.dev);
#else
msm_otg_suspend(dev);
#endif
}
static inline int pm_runtime_put_sync(struct device *dev)
{
return __pm_runtime_put(dev, true);//调用该函数
}
{
return __pm_runtime_put(dev, true);//调用该函数
}
int __pm_runtime_put(struct device *dev, bool sync)
{
int retval = 0;
{
int retval = 0;
if (atomic_dec_and_test(&dev->power.usage_count))
retval = sync ? pm_runtime_idle(dev)/*调用该函数*/: pm_request_idle(dev);
retval = sync ? pm_runtime_idle(dev)/*调用该函数*/: pm_request_idle(dev);
return retval;
}
}
int pm_runtime_idle(struct device *dev)
{
int retval;
{
int retval;
spin_lock_irq(&dev->power.lock);
retval = __pm_runtime_idle(dev);//调用该函数
spin_unlock_irq(&dev->power.lock);
retval = __pm_runtime_idle(dev);//调用该函数
spin_unlock_irq(&dev->power.lock);
return retval;
}
}
static int __pm_runtime_idle(struct device *dev)
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
int retval = 0;
...............
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
int retval = 0;
...............
dev->power.idle_notification = true;
if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
dev->bus->pm->runtime_idle(dev);//调用该函数
spin_lock_irq(&dev->power.lock);
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
} else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
dev->type->pm->runtime_idle(dev);
spin_lock_irq(&dev->power.lock);
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_idle) {
spin_unlock_irq(&dev->power.lock);
dev->class->pm->runtime_idle(dev);
spin_lock_irq(&dev->power.lock);
}
}
dev->power.idle_notification = false;
wake_up_all(&dev->power.wait_queue);
wake_up_all(&dev->power.wait_queue);
out:
return retval;
}
return retval;
}
static const struct dev_pm_ops platform_dev_pm_ops = {
.prepare = platform_pm_prepare,
.complete = platform_pm_complete,
.suspend = platform_pm_suspend,
.resume = platform_pm_resume,
.freeze = platform_pm_freeze,
.thaw = platform_pm_thaw,
.poweroff = platform_pm_poweroff,
.restore = platform_pm_restore,
.suspend_noirq = platform_pm_suspend_noirq,
.resume_noirq = platform_pm_resume_noirq,
.freeze_noirq = platform_pm_freeze_noirq,
.thaw_noirq = platform_pm_thaw_noirq,
.poweroff_noirq = platform_pm_poweroff_noirq,
.restore_noirq = platform_pm_restore_noirq,
.runtime_suspend = platform_pm_runtime_suspend,
.runtime_resume = platform_pm_runtime_resume,
.runtime_idle = platform_pm_runtime_idle,//调用该处的函数
};
.prepare = platform_pm_prepare,
.complete = platform_pm_complete,
.suspend = platform_pm_suspend,
.resume = platform_pm_resume,
.freeze = platform_pm_freeze,
.thaw = platform_pm_thaw,
.poweroff = platform_pm_poweroff,
.restore = platform_pm_restore,
.suspend_noirq = platform_pm_suspend_noirq,
.resume_noirq = platform_pm_resume_noirq,
.freeze_noirq = platform_pm_freeze_noirq,
.thaw_noirq = platform_pm_thaw_noirq,
.poweroff_noirq = platform_pm_poweroff_noirq,
.restore_noirq = platform_pm_restore_noirq,
.runtime_suspend = platform_pm_runtime_suspend,
.runtime_resume = platform_pm_runtime_resume,
.runtime_idle = platform_pm_runtime_idle,//调用该处的函数
};
struct bus_type platform_bus_type = {
.name = "platform",
.dev_attrs = platform_dev_attrs,
.match = platform_match,
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
.name = "platform",
.dev_attrs = platform_dev_attrs,
.match = platform_match,
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
int __weak platform_pm_runtime_idle(struct device *dev)
{
return pm_generic_runtime_idle(dev);//调用该函数
};
{
return pm_generic_runtime_idle(dev);//调用该函数
};
int pm_generic_runtime_idle(struct device *dev)
{
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
{
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
if (pm && pm->runtime_idle) {
int ret = pm->runtime_idle(dev);
if (ret)
return ret;
}
int ret = pm->runtime_idle(dev);
if (ret)
return ret;
}
pm_runtime_suspend(dev);//调用该函数
return 0;
}
return 0;
}
int pm_runtime_suspend(struct device *dev)
{
int retval;
{
int retval;
spin_lock_irq(&dev->power.lock);
retval = __pm_runtime_suspend(dev, false);//调用该函数
spin_unlock_irq(&dev->power.lock);
retval = __pm_runtime_suspend(dev, false);//调用该函数
spin_unlock_irq(&dev->power.lock);
return retval;
}
}
int __pm_runtime_suspend(struct device *dev, bool from_wq)
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
__releases(&dev->power.lock) __acquires(&dev->power.lock)
{
struct device *parent = NULL;
bool notify = false;
int retval = 0;
dev_dbg(dev, "__pm_runtime_suspend()%s!\n",from_wq ? " from workqueue" : "");
repeat:
dev->power.runtime_status = RPM_SUSPENDING;
dev->power.deferred_resume = false;
dev->power.runtime_status = RPM_SUSPENDING;
dev->power.deferred_resume = false;
if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
retval = dev->bus->pm->runtime_suspend(dev); //调用平台总线的suspend函数
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->type && dev->type->pm
&& dev->type->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->type && dev->type->pm
&& dev->type->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
retval = dev->type->pm->runtime_suspend(dev);
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else if (dev->class && dev->class->pm
&& dev->class->pm->runtime_suspend) {
spin_unlock_irq(&dev->power.lock);
retval = dev->class->pm->runtime_suspend(dev);
spin_lock_irq(&dev->power.lock);
dev->power.runtime_error = retval;
} else {
retval = -ENOSYS;
}
dev->power.runtime_error = retval;
} else {
retval = -ENOSYS;
}
if (notify)
__pm_runtime_idle(dev);
__pm_runtime_idle(dev);
if (parent && !parent->power.ignore_children) {
spin_unlock_irq(&dev->power.lock);
spin_unlock_irq(&dev->power.lock);
pm_request_idle(parent);
spin_lock_irq(&dev->power.lock);
}
}
out:
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
return retval;
}
}
int __weak platform_pm_runtime_suspend(struct device *dev)
{
return pm_generic_runtime_suspend(dev);
};
{
return pm_generic_runtime_suspend(dev);
};
int pm_generic_runtime_suspend(struct device *dev)
{
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
int ret;
{
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
int ret;
ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : -EINVAL;//调用平台驱动的runtime_suspend函数
return ret;
}
}
/*平台驱动的注册函数*/
/*******************************************************************/
static int msm_otg_runtime_suspend(struct device *dev)
{
struct msm_otg *otg = the_msm_otg;
static int msm_otg_runtime_suspend(struct device *dev)
{
struct msm_otg *otg = the_msm_otg;
dev_dbg(dev, "pm_runtime: suspending...\n");
msm_otg_suspend(otg);
return 0;
}
msm_otg_suspend(otg);
return 0;
}
static int msm_otg_runtime_resume(struct device *dev)
{
struct msm_otg *otg = the_msm_otg;
{
struct msm_otg *otg = the_msm_otg;
dev_dbg(dev, "pm_runtime: resuming...\n");
msm_otg_resume(otg);
return 0;
}
msm_otg_resume(otg);
return 0;
}
static int msm_otg_runtime_idle(struct device *dev)
{
dev_dbg(dev, "pm_runtime: idling...\n");
return 0;
}
{
dev_dbg(dev, "pm_runtime: idling...\n");
return 0;
}
static struct dev_pm_ops msm_otg_dev_pm_ops = {
.runtime_suspend = msm_otg_runtime_suspend,
.runtime_resume = msm_otg_runtime_resume,
.runtime_idle = msm_otg_runtime_idle,
};
.runtime_suspend = msm_otg_runtime_suspend,
.runtime_resume = msm_otg_runtime_resume,
.runtime_idle = msm_otg_runtime_idle,
};
static struct platform_driver msm_otg_driver = {
.remove = __exit_p(msm_otg_remove),
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
.pm = &msm_otg_dev_pm_ops,
},
};
/*******************************************************************/
.remove = __exit_p(msm_otg_remove),
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
.pm = &msm_otg_dev_pm_ops,
},
};
/*******************************************************************/
static int msm_otg_suspend(struct msm_otg *dev)
{
unsigned long timeout;
bool host_bus_suspend;
unsigned ret;
enum chg_type chg_type = atomic_read(&dev->chg_type);
unsigned long flags;
disable_irq(dev->irq);
if (atomic_read(&dev->in_lpm))
goto out;
if (atomic_read(&dev->in_lpm))
goto out;
atomic_set(&dev->in_lpm, 1);//设置low power mode为1,唤醒的时候要判断该标记
...............
if (dev->pdata->config_vddcx)
dev->pdata->config_vddcx(0);
pr_info("%s: usb in low power mode\n", __func__);
dev->pdata->config_vddcx(0);
pr_info("%s: usb in low power mode\n", __func__);
return 0;
}
到此整个睡眠流程分析完了。
}
到此整个睡眠流程分析完了。
