android 休眠唤醒机制分析(三) — suspend

最新推荐文章于 2024-08-16 09:27:44 发布
最新推荐文章于 2024-08-16 09:27:44 发布
阅读量1.5k 收藏 5
点赞数
分类专栏： Linux 文章标签： 休眠唤醒

转自http://blog.csdn.net/g_salamander/article/details/7988340

前面我们分析了休眠的第一个阶段即浅度休眠，现在我们继续看休眠的第二个阶段 — 深度休眠。在深度休眠的过程中系统会首先冻结所有可以冻结的进程，然后依次挂起所有设备的电源，挂起顺序与设备注册的顺序相反，这样保证了设备之间电源的依赖性；直至最后进入省电模式，等待用户或者RTC唤醒；在唤醒过程中则会按照设备注册的顺序依次恢复每个设备的电源进入正常工作状态，解冻相关的进程，然后再进行浅度休眠的唤醒流程。

1、深度休眠入口

根据wake_lock一节的分析我们知道driver层进入深度休眠的入口有4个，分别为expire_timer、wake_lock、wake_lock_timeout、wake_unlock，这几个入口函数将根据相应的条件启动suspend_work里面的pm_suspend()函数进入深度休眠流程，代码在linux/kernel/power/suspend.c中：

[cpp] view plain copy print ?
  1. // 进入深度休眠流程  
  2. int enter_state(suspend_state_t state)  
  3. {  
  4.     int error;  
  5.     // 判断平台是否支持该状态  
  6.     if (!valid_state(state))  
  7.         return -ENODEV;  
  8.   
  9.     if (!mutex_trylock(&pm_mutex))  
  10.         return -EBUSY;  
  11.     // 同步缓存  
  12.     printk(KERN_INFO "PM: Syncing filesystems ... ");  
  13.     sys_sync();  
  14.     printk("done.\n");  
  15.   
  16.     pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);  
  17.     // 做好休眠准备  
  18.     error = suspend_prepare();  
  19.     if (error)  
  20.         goto Unlock;  
  21.     // suspend_test  
  22.     if (suspend_test(TEST_FREEZER))  
  23.         goto Finish;  
  24.   
  25.     pr_debug("PM: Entering %s sleep\n", pm_states[state]);  
  26.     // 设备休眠  
  27.     error = suspend_devices_and_enter(state);  
  28.   
  29.  Finish:  
  30.     pr_debug("PM: Finishing wakeup.\n");  
  31.     suspend_finish();  
  32.  Unlock:  
  33.     mutex_unlock(&pm_mutex);  
  34.     return error;  
  35. }  
  36.   
  37. int pm_suspend(suspend_state_t state)  
  38. {  
  39.     if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)  
  40.         return enter_state(state);  
  41.     return -EINVAL;  
  42. }  
  43. EXPORT_SYMBOL(pm_suspend);  
// 进入深度休眠流程
int enter_state(suspend_state_t state)
{
	int error;
	// 判断平台是否支持该状态
	if (!valid_state(state))
		return -ENODEV;

	if (!mutex_trylock(&pm_mutex))
		return -EBUSY;
	// 同步缓存
	printk(KERN_INFO "PM: Syncing filesystems ... ");
	sys_sync();
	printk("done.\n");

	pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
	// 做好休眠准备
	error = suspend_prepare();
	if (error)
		goto Unlock;
	// suspend_test
	if (suspend_test(TEST_FREEZER))
		goto Finish;

	pr_debug("PM: Entering %s sleep\n", pm_states[state]);
	// 设备休眠
	error = suspend_devices_and_enter(state);

 Finish:
	pr_debug("PM: Finishing wakeup.\n");
	suspend_finish();
 Unlock:
	mutex_unlock(&pm_mutex);
	return error;
}

int pm_suspend(suspend_state_t state)
{
	if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
		return enter_state(state);
	return -EINVAL;
}
EXPORT_SYMBOL(pm_suspend);

在enter_state()中首先进入状态的判断，根据平台的特性判断是否支持此状态；然后再同步缓存；接着调用suspend_prepare()冻结大部分进程；然后再通过suspend_devices_and_enter()开始挂起设备。

2、冻结进程

[cpp] view plain copy print ?
  1. static int suspend_prepare(void)  
  2. {  
  3.     int error;  
  4.   
  5.     if (!suspend_ops || !suspend_ops->enter)  
  6.         return -EPERM;  
  7.   
  8.     pm_prepare_console();  
  9.   
  10.     // 通知进行休眠准备  
  11.     error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);  
  12.     if (error)  
  13.         goto Finish;  
  14.     // 禁止usermodehelper  
  15.     error = usermodehelper_disable();  
  16.     if (error)  
  17.         goto Finish;  
  18.     // 冻结所有可以冻结的进程  
  19.     error = suspend_freeze_processes();  
  20.     if (!error)  
  21.         return 0;  
  22.   
  23.     // 解冻所有进程  
  24.     suspend_thaw_processes();  
  25.     // 使能usermodehelper  
  26.     usermodehelper_enable();  
  27.  Finish:  
  28.     // 通知休眠结束  
  29.     pm_notifier_call_chain(PM_POST_SUSPEND);  
  30.     pm_restore_console();  
  31.     return error;  
  32. }  
static int suspend_prepare(void)
{
	int error;

	if (!suspend_ops || !suspend_ops->enter)
		return -EPERM;

	pm_prepare_console();

	// 通知进行休眠准备
	error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
	if (error)
		goto Finish;
	// 禁止usermodehelper
	error = usermodehelper_disable();
	if (error)
		goto Finish;
	// 冻结所有可以冻结的进程
	error = suspend_freeze_processes();
	if (!error)
		return 0;

	// 解冻所有进程
	suspend_thaw_processes();
	// 使能usermodehelper
	usermodehelper_enable();
 Finish:
 	// 通知休眠结束
	pm_notifier_call_chain(PM_POST_SUSPEND);
	pm_restore_console();
	return error;
}

这里有一个notifier机制后面要专门分析下。

3、挂起设备

[cpp] view plain copy print ?
  1. int suspend_devices_and_enter(suspend_state_t state)  
  2. {  
  3.     int error;  
  4.   
  5.     if (!suspend_ops)  
  6.         return -ENOSYS;  
  7.     // 处理器的休眠开始函数  
  8.     if (suspend_ops->begin) {  
  9.         error = suspend_ops->begin(state);  
  10.         if (error)  
  11.             goto Close;  
  12.     }  
  13.     // 休眠串口  
  14.     suspend_console();  
  15.     suspend_test_start();  
  16.     // 设备休眠  
  17.     error = dpm_suspend_start(PMSG_SUSPEND);  
  18.     if (error) {  
  19.         printk(KERN_ERR "PM: Some devices failed to suspend\n");  
  20.         goto Recover_platform;  
  21.     }  
  22.     suspend_test_finish("suspend devices");  
  23.     if (suspend_test(TEST_DEVICES))  
  24.         goto Recover_platform;  
  25.     // 处理器休眠  
  26.     suspend_enter(state);  
  27.   
  28.  Resume_devices:  
  29.     suspend_test_start();  
  30.     // 设备唤醒  
  31.     dpm_resume_end(PMSG_RESUME);  
  32.     suspend_test_finish("resume devices");  
  33.     // 唤醒串口  
  34.     resume_console();  
  35.  Close:  
  36.     // 处理器的休眠结束函数  
  37.     if (suspend_ops->end)  
  38.         suspend_ops->end();  
  39.     return error;  
  40.   
  41.  Recover_platform:  
  42.     if (suspend_ops->recover)  
  43.         suspend_ops->recover();  
  44.     goto Resume_devices;  
  45. }  
int suspend_devices_and_enter(suspend_state_t state)
{
	int error;

	if (!suspend_ops)
		return -ENOSYS;
	// 处理器的休眠开始函数
	if (suspend_ops->begin) {
		error = suspend_ops->begin(state);
		if (error)
			goto Close;
	}
	// 休眠串口
	suspend_console();
	suspend_test_start();
	// 设备休眠
	error = dpm_suspend_start(PMSG_SUSPEND);
	if (error) {
		printk(KERN_ERR "PM: Some devices failed to suspend\n");
		goto Recover_platform;
	}
	suspend_test_finish("suspend devices");
	if (suspend_test(TEST_DEVICES))
		goto Recover_platform;
	// 处理器休眠
	suspend_enter(state);

 Resume_devices:
	suspend_test_start();
	// 设备唤醒
	dpm_resume_end(PMSG_RESUME);
	suspend_test_finish("resume devices");
	// 唤醒串口
	resume_console();
 Close:
 	// 处理器的休眠结束函数
	if (suspend_ops->end)
		suspend_ops->end();
	return error;

 Recover_platform:
	if (suspend_ops->recover)
		suspend_ops->recover();
	goto Resume_devices;
}

可以看到设备挂起流程先从处理器自身开始，平台一般不需要做特殊的处理；接着关闭串口，然后调用dpm_suspend_start()开始挂起设备，如果成功挂起所有设备则调用suspend_enter()挂起处理器。挂起设备部分的代码在linux/driver/base/power/main.c中

[cpp] view plain copy print ?
  1. int dpm_suspend_start(pm_message_t state)  
  2. {  
  3.     int error;  
  4.   
  5.     might_sleep();  
  6.     error = dpm_prepare(state);  
  7.     if (!error)  
  8.         error = dpm_suspend(state);  
  9.     return error;  
  10. }  
  11. EXPORT_SYMBOL_GPL(dpm_suspend_start);  
int dpm_suspend_start(pm_message_t state)
{
	int error;

	might_sleep();
	error = dpm_prepare(state);
	if (!error)
		error = dpm_suspend(state);
	return error;
}
EXPORT_SYMBOL_GPL(dpm_suspend_start);

挂起设备分为2个步骤，首先执行设备的prepare函数，然后再执行suspend函数。

[cpp] view plain copy print ?
  1. // 函数将会调用所有的非sysdev设备的prepare()接口  
  2. static int dpm_prepare(pm_message_t state)  
  3. {  
  4.     struct list_head list;  
  5.     int error = 0;  
  6.   
  7.     INIT_LIST_HEAD(&list);  
  8.     mutex_lock(&dpm_list_mtx);  
  9.     transition_started = true;  
  10.     // 遍历设备链表  
  11.     while (!list_empty(&dpm_list)) {  
  12.         // 从最先初始化的节点开始遍历  
  13.         struct device *dev = to_device(dpm_list.next);  
  14.         // 获取设备  
  15.         get_device(dev);  
  16.         // 更新设备状态  
  17.         dev->power.status = DPM_PREPARING;  
  18.         mutex_unlock(&dpm_list_mtx);  
  19.   
  20.         pm_runtime_get_noresume(dev);  
  21.         // 在系统休眠期间有可能受到唤醒请求  
  22.         if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) {  
  23.             /* Wake-up requested during system sleep transition. */  
  24.             pm_runtime_put_noidle(dev);  
  25.             error = -EBUSY;  
  26.         } else {  // 执行prepare()函数  
  27.             error = device_prepare(dev, state);  
  28.         }  
  29.   
  30.         mutex_lock(&dpm_list_mtx);  
  31.         // 如果出错则跳出循环  
  32.         if (error) {  
  33.             dev->power.status = DPM_ON;  
  34.             if (error == -EAGAIN) {  
  35.                 put_device(dev);  
  36.                 error = 0;  
  37.                 continue;  
  38.             }  
  39.             printk(KERN_ERR "PM: Failed to prepare device %s "  
  40.                 "for power transition: error %d\n",  
  41.                 kobject_name(&dev->kobj), error);  
  42.             put_device(dev);  
  43.             break;  
  44.         }  
  45.         // 更新状态  
  46.         dev->power.status = DPM_SUSPENDING;  
  47.         if (!list_empty(&dev->power.entry))  
  48.             // 将设备节点移动到list链表中  
  49.             list_move_tail(&dev->power.entry, &list);  
  50.         put_device(dev);  
  51.     }  
  52.     // 拼接链表  
  53.     list_splice(&list, &dpm_list);  
  54.     mutex_unlock(&dpm_list_mtx);  
  55.     return error;  
  56. }  
// 函数将会调用所有的非sysdev设备的prepare()接口
static int dpm_prepare(pm_message_t state)
{
	struct list_head list;
	int error = 0;

	INIT_LIST_HEAD(&list);
	mutex_lock(&dpm_list_mtx);
	transition_started = true;
	// 遍历设备链表
	while (!list_empty(&dpm_list)) {
		// 从最先初始化的节点开始遍历
		struct device *dev = to_device(dpm_list.next);
		// 获取设备
		get_device(dev);
		// 更新设备状态
		dev->power.status = DPM_PREPARING;
		mutex_unlock(&dpm_list_mtx);

		pm_runtime_get_noresume(dev);
		// 在系统休眠期间有可能受到唤醒请求
		if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) {
			/* Wake-up requested during system sleep transition. */
			pm_runtime_put_noidle(dev);
			error = -EBUSY;
		} else {  // 执行prepare()函数
			error = device_prepare(dev, state);
		}

		mutex_lock(&dpm_list_mtx);
		// 如果出错则跳出循环
		if (error) {
			dev->power.status = DPM_ON;
			if (error == -EAGAIN) {
				put_device(dev);
				error = 0;
				continue;
			}
			printk(KERN_ERR "PM: Failed to prepare device %s "
				"for power transition: error %d\n",
				kobject_name(&dev->kobj), error);
			put_device(dev);
			break;
		}
		// 更新状态
		dev->power.status = DPM_SUSPENDING;
		if (!list_empty(&dev->power.entry))
			// 将设备节点移动到list链表中
			list_move_tail(&dev->power.entry, &list);
		put_device(dev);
	}
	// 拼接链表
	list_splice(&list, &dpm_list);
	mutex_unlock(&dpm_list_mtx);
	return error;
}

可以看到函数将遍历dpm_list链表，并执行每个设备的prepare函数，内核规定prepare函数的实现不能改变硬件的状态；系统中每一个设备注册时都将被加入dpm_list链表的尾部，所以链表排序为设备注册的顺序。

[cpp] view plain copy print ?
  1. static int dpm_suspend(pm_message_t state)  
  2. {  
  3.     struct list_head list;  
  4.     int error = 0;  
  5.   
  6.     INIT_LIST_HEAD(&list);  
  7.     mutex_lock(&dpm_list_mtx);  
  8.     while (!list_empty(&dpm_list)) {  
  9.         // 逆序遍历链表,即先suspend后注册的设备,符合设备与父设备电源挂起的先后原则  
  10.         struct device *dev = to_device(dpm_list.prev);  
  11.   
  12.         get_device(dev);  
  13.         mutex_unlock(&dpm_list_mtx);  
  14.   
  15.         dpm_drv_wdset(dev);  
  16.         error = device_suspend(dev, state);  
  17.         dpm_drv_wdclr(dev);  
  18.   
  19.         mutex_lock(&dpm_list_mtx);  
  20.         if (error) {  
  21.             pm_dev_err(dev, state, "", error);  
  22.             put_device(dev);  
  23.             break;  
  24.         }  
  25.         dev->power.status = DPM_OFF;  
  26.         if (!list_empty(&dev->power.entry))  
  27.             list_move(&dev->power.entry, &list);  
  28.         put_device(dev);  
  29.     }  
  30.     list_splice(&list, dpm_list.prev);  
  31.     mutex_unlock(&dpm_list_mtx);  
  32.     return error;  
  33. }  
static int dpm_suspend(pm_message_t state)
{
	struct list_head list;
	int error = 0;

	INIT_LIST_HEAD(&list);
	mutex_lock(&dpm_list_mtx);
	while (!list_empty(&dpm_list)) {
		// 逆序遍历链表,即先suspend后注册的设备,符合设备与父设备电源挂起的先后原则
		struct device *dev = to_device(dpm_list.prev);

		get_device(dev);
		mutex_unlock(&dpm_list_mtx);

		dpm_drv_wdset(dev);
		error = device_suspend(dev, state);
		dpm_drv_wdclr(dev);

		mutex_lock(&dpm_list_mtx);
		if (error) {
			pm_dev_err(dev, state, "", error);
			put_device(dev);
			break;
		}
		dev->power.status = DPM_OFF;
		if (!list_empty(&dev->power.entry))
			list_move(&dev->power.entry, &list);
		put_device(dev);
	}
	list_splice(&list, dpm_list.prev);
	mutex_unlock(&dpm_list_mtx);
	return error;
}

函数将设备按照注册顺序反向挂起，挂起执行的流程如下：

[cpp] view plain copy print ?
  1. static int device_suspend(struct device *dev, pm_message_t state)  
  2. {  
  3.     int error = 0;  
  4.   
  5.     down(&dev->sem);  
  6.   
  7.     if (dev->class) {  // 类的suspend优先  
  8.         if (dev->class->pm) {  
  9.             pm_dev_dbg(dev, state, "class ");  
  10.             error = pm_op(dev, dev->class->pm, state);  
  11.         } else if (dev->class->suspend) {  
  12.             pm_dev_dbg(dev, state, "legacy class ");  
  13.             error = dev->class->suspend(dev, state);  
  14.             suspend_report_result(dev->class->suspend, error);  
  15.         }  
  16.         if (error)  
  17.             goto End;  
  18.     }  
  19.   
  20.     if (dev->type) {  // device_type次之  
  21.         if (dev->type->pm) {  
  22.             pm_dev_dbg(dev, state, "type ");  
  23.             error = pm_op(dev, dev->type->pm, state);  
  24.         }  
  25.         if (error)  
  26.             goto End;  
  27.     }  
  28.   
  29.     if (dev->bus) {  // bus优先级最低  
  30.         if (dev->bus->pm) {  
  31.             pm_dev_dbg(dev, state, "");  
  32.             error = pm_op(dev, dev->bus->pm, state);  
  33.         } else if (dev->bus->suspend) {  
  34.             pm_dev_dbg(dev, state, "legacy ");  
  35.             error = dev->bus->suspend(dev, state);  
  36.             suspend_report_result(dev->bus->suspend, error);  
  37.         }  
  38.     }  
  39.  End:  
  40.     up(&dev->sem);  
  41.   
  42.     return error;  
  43. }  
static int device_suspend(struct device *dev, pm_message_t state)
{
	int error = 0;

	down(&dev->sem);

	if (dev->class) {  // 类的suspend优先
		if (dev->class->pm) {
			pm_dev_dbg(dev, state, "class ");
			error = pm_op(dev, dev->class->pm, state);
		} else if (dev->class->suspend) {
			pm_dev_dbg(dev, state, "legacy class ");
			error = dev->class->suspend(dev, state);
			suspend_report_result(dev->class->suspend, error);
		}
		if (error)
			goto End;
	}

	if (dev->type) {  // device_type次之
		if (dev->type->pm) {
			pm_dev_dbg(dev, state, "type ");
			error = pm_op(dev, dev->type->pm, state);
		}
		if (error)
			goto End;
	}

	if (dev->bus) {  // bus优先级最低
		if (dev->bus->pm) {
			pm_dev_dbg(dev, state, "");
			error = pm_op(dev, dev->bus->pm, state);
		} else if (dev->bus->suspend) {
			pm_dev_dbg(dev, state, "legacy ");
			error = dev->bus->suspend(dev, state);
			suspend_report_result(dev->bus->suspend, error);
		}
	}
 End:
	up(&dev->sem);

	return error;
}

可以看到类中的suspend优先级最高，之后是device_type的，最后是bus的，大部分设备只注册了bus下的suspend。
4、挂起处理器

[cpp] view plain copy print ?
  1. static int suspend_enter(suspend_state_t state)  
  2. {  
  3.     int error;  
  4.     // 处理器的休眠准备函数  
  5.     if (suspend_ops->prepare) {  
  6.         error = suspend_ops->prepare();  
  7.         if (error)  
  8.             return error;  
  9.     }  
  10.     // 执行非sysdev的late suspend函数  
  11.     error = dpm_suspend_noirq(PMSG_SUSPEND);  
  12.     if (error) {  
  13.         printk(KERN_ERR "PM: Some devices failed to power down\n");  
  14.         goto Platfrom_finish;  
  15.     }  
  16.     // 处理器休眠最后的准备  
  17.     if (suspend_ops->prepare_late) {  
  18.         error = suspend_ops->prepare_late();  
  19.         if (error)  
  20.             goto Power_up_devices;  
  21.     }  
  22.   
  23.     if (suspend_test(TEST_PLATFORM))  
  24.         goto Platform_wake;  
  25.     // 关闭非启动cpu  
  26.     error = disable_nonboot_cpus();  
  27.     if (error || suspend_test(TEST_CPUS))  
  28.         goto Enable_cpus;  
  29.     // 挂起中断  
  30.     arch_suspend_disable_irqs();  
  31.     BUG_ON(!irqs_disabled());  
  32.     // 挂起sysdev  
  33.     error = sysdev_suspend(PMSG_SUSPEND);  
  34.     if (!error) {  
  35.         if (!suspend_test(TEST_CORE))  
  36.             // 处理器的休眠进入函数,休眠流程运行至此  
  37.             error = suspend_ops->enter(state);  
  38.         // 唤醒sysdev  
  39.         sysdev_resume();  
  40.     }  
  41.     // 使能中断  
  42.     arch_suspend_enable_irqs();  
  43.     BUG_ON(irqs_disabled());  
  44.   
  45.  Enable_cpus:  
  46.     // 使能非启动cpu  
  47.     enable_nonboot_cpus();  
  48.   
  49.  Platform_wake:  
  50.     // 处理器开始唤醒  
  51.     if (suspend_ops->wake)  
  52.         suspend_ops->wake();  
  53.   
  54.  Power_up_devices:  
  55.     // 执行非sysdev的early resume函数  
  56.     dpm_resume_noirq(PMSG_RESUME);  
  57.   
  58.  Platfrom_finish:  
  59.     // 处理器休眠结束  
  60.     if (suspend_ops->finish)  
  61.         suspend_ops->finish();  
  62.   
  63.     return error;  
  64. }  
static int suspend_enter(suspend_state_t state)
{
	int error;
	// 处理器的休眠准备函数
	if (suspend_ops->prepare) {
		error = suspend_ops->prepare();
		if (error)
			return error;
	}
	// 执行非sysdev的late suspend函数
	error = dpm_suspend_noirq(PMSG_SUSPEND);
	if (error) {
		printk(KERN_ERR "PM: Some devices failed to power down\n");
		goto Platfrom_finish;
	}
	// 处理器休眠最后的准备
	if (suspend_ops->prepare_late) {
		error = suspend_ops->prepare_late();
		if (error)
			goto Power_up_devices;
	}

	if (suspend_test(TEST_PLATFORM))
		goto Platform_wake;
	// 关闭非启动cpu
	error = disable_nonboot_cpus();
	if (error || suspend_test(TEST_CPUS))
		goto Enable_cpus;
	// 挂起中断
	arch_suspend_disable_irqs();
	BUG_ON(!irqs_disabled());
	// 挂起sysdev
	error = sysdev_suspend(PMSG_SUSPEND);
	if (!error) {
		if (!suspend_test(TEST_CORE))
			// 处理器的休眠进入函数,休眠流程运行至此
			error = suspend_ops->enter(state);
		// 唤醒sysdev
		sysdev_resume();
	}
	// 使能中断
	arch_suspend_enable_irqs();
	BUG_ON(irqs_disabled());

 Enable_cpus:
 	// 使能非启动cpu
	enable_nonboot_cpus();

 Platform_wake:
 	// 处理器开始唤醒
	if (suspend_ops->wake)
		suspend_ops->wake();

 Power_up_devices:
 	// 执行非sysdev的early resume函数
	dpm_resume_noirq(PMSG_RESUME);

 Platfrom_finish:
 	// 处理器休眠结束
	if (suspend_ops->finish)
		suspend_ops->finish();

	return error;
}

在这个阶段首先看处理器是否需要做一些准备，接下来执行非sysdev的late suspend函数，然后处理器做休眠前最后的准备、关闭非启动cpu、挂起中断，再挂起sysdev，最后进入处理器的挂起函数，至此休眠流程结束，处理器等待用户或者RTC唤醒。

附1、late suspend

在这里我们看到了一种新的suspend机制 — late suspend，是在所有的suspend执行完后再开始执行，接口为dev->bus->pm->suspend_noirq；这样early_suspend、suspend以及late suspend构成了suspend的三部曲，late suspend是在中断关闭的情况下进行的；前面我们分析的wake_lock就有用到，用于检测在suspend阶段是否有锁被激活。late suspend的实现如下：

[cpp] view plain copy print ?
  1. int dpm_suspend_noirq(pm_message_t state)  
  2. {  
  3.     struct device *dev;  
  4.     int error = 0;  
  5.   
  6.     suspend_device_irqs();  // 关闭除唤醒系统以外的所有中断  
  7.     mutex_lock(&dpm_list_mtx);  
  8.     list_for_each_entry_reverse(dev, &dpm_list, power.entry) {  
  9.         // 执行所有设备的late suspend函数  
  10.         error = device_suspend_noirq(dev, state);  
  11.         if (error) {  
  12.             pm_dev_err(dev, state, " late", error);  
  13.             break;  
  14.         }  
  15.         dev->power.status = DPM_OFF_IRQ;  
  16.     }  
  17.     mutex_unlock(&dpm_list_mtx);  
  18.     if (error)  
  19.         dpm_resume_noirq(resume_event(state));  
  20.     return error;  
  21. }  
  22. EXPORT_SYMBOL_GPL(dpm_suspend_noirq);  
int dpm_suspend_noirq(pm_message_t state)
{
	struct device *dev;
	int error = 0;

	suspend_device_irqs();  // 关闭除唤醒系统以外的所有中断
	mutex_lock(&dpm_list_mtx);
	list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
		// 执行所有设备的late suspend函数
		error = device_suspend_noirq(dev, state);
		if (error) {
			pm_dev_err(dev, state, " late", error);
			break;
		}
		dev->power.status = DPM_OFF_IRQ;
	}
	mutex_unlock(&dpm_list_mtx);
	if (error)
		dpm_resume_noirq(resume_event(state));
	return error;
}
EXPORT_SYMBOL_GPL(dpm_suspend_noirq);

附2、中断关闭流程

在late suspend机制中我们看到了休眠流程中关闭系统中断的地方：

[cpp] view plain copy print ?
  1. void suspend_device_irqs(void)  
  2. {  
  3.     struct irq_desc *desc;  
  4.     int irq;  
  5.   
  6.     for_each_irq_desc(irq, desc) {  // 遍历系统的中断  
  7.         unsigned long flags;  
  8.   
  9.         spin_lock_irqsave(&desc->lock, flags);  
  10.         __disable_irq(desc, irq, true);  // 关闭中断  
  11.         spin_unlock_irqrestore(&desc->lock, flags);  
  12.     }  
  13.   
  14.     for_each_irq_desc(irq, desc)  
  15.         if (desc->status & IRQ_SUSPENDED)  
  16.             synchronize_irq(irq);  
  17. }  
  18. EXPORT_SYMBOL_GPL(suspend_device_irqs);  
void suspend_device_irqs(void)
{
	struct irq_desc *desc;
	int irq;

	for_each_irq_desc(irq, desc) {  // 遍历系统的中断
		unsigned long flags;

		spin_lock_irqsave(&desc->lock, flags);
		__disable_irq(desc, irq, true);  // 关闭中断
		spin_unlock_irqrestore(&desc->lock, flags);
	}

	for_each_irq_desc(irq, desc)
		if (desc->status & IRQ_SUSPENDED)
			synchronize_irq(irq);
}
EXPORT_SYMBOL_GPL(suspend_device_irqs);

函数调用了__disable_irq()来关闭中断，我们看一下这个函数的实现：

[cpp] view plain copy print ?
  1. void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)  
  2. {  
  3.     if (suspend) {  
  4.         // 如果中断没有被激活或者中断的IRQF_TIMER标志被置位则不关闭中断  
  5.         // 在以后的内核版本中这个标志位被换成了IRQF_NO_SUSPEND  
  6.         // 新版的IRQF_TIMER = (__IRQF_TIMER | IRQF_NO_SUSPEND)  
  7.         if (!desc->action || (desc->action->flags & IRQF_TIMER))  
  8.             return;  
  9.         desc->status |= IRQ_SUSPENDED;  
  10.     }  
  11.     // 判断中断是否被打开  
  12.     if (!desc->depth++) {  
  13.         // 更新标志位  
  14.         desc->status |= IRQ_DISABLED;  
  15.         // 关闭中断  
  16.         desc->chip->disable(irq);  
  17.     }  
  18. }  
void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
{
	if (suspend) {
		// 如果中断没有被激活或者中断的IRQF_TIMER标志被置位则不关闭中断
		// 在以后的内核版本中这个标志位被换成了IRQF_NO_SUSPEND
		// 新版的IRQF_TIMER = (__IRQF_TIMER | IRQF_NO_SUSPEND)
		if (!desc->action || (desc->action->flags & IRQF_TIMER))
			return;
		desc->status |= IRQ_SUSPENDED;
	}
	// 判断中断是否被打开
	if (!desc->depth++) {
		// 更新标志位
		desc->status |= IRQ_DISABLED;
		// 关闭中断
		desc->chip->disable(irq);
	}
}

可以看到如果该中断没有被激活或者中断的IRQF_TIMER标志被置位就不会关闭中断，在新的内核版本中增加了专门的 IRQF_NO_SUSPEND 标志位，用来置位在休眠状态下唤醒系统的中断，如RTC、按键等；如果是其他中断则将打开的中断关闭掉。



qwaszx523
关注
专栏目录
android 休眠唤醒机制分析(一) — wake_lock
嵌入式技术博客
09-14 5万+
Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。本文主要分析driver层wake_lock的实现。 一、wake_lock 定义和接口 enum { WAKE_LOCK_SUSP
Android休眠唤醒机制
11-30 2813
1、背景介绍：     睡眠/唤醒是嵌入式Linux非常重要的组成部分,因为优秀的睡眠唤醒机制可以是嵌入式设备尽可能的进入休眠状态，来延长电池的续航时间（这在移动终端消费类电子设备中是非常重要和有意义的！！）。但标准的Linux睡眠唤醒机制有其自身的一些缺陷（所有模块必须同时睡下或者唤醒），在某些情况下，这会导致能耗的白白浪费。因此Android在标准Linux睡眠唤醒的机制上作了新的改动(wa
android 两个suspend的返回值进行判断
最新发布
weixin_29517217的博客
08-16 42
Android中使用两个Suspend函数的返回值进行判断 在Android开发中，尤其是使用Kotlin语言时，suspend函数为我们提供了一种优雅的异步编程方式。通过挂起函数，开发者可以编写易于理解与维护的代码，但在实际应用中，我们常常需要根据多个挂起函数的返回值来进行判断和决策。本文将详细探讨如何在Android中...
Android休眠唤醒机制简介（二）
huangchengzhong的专栏
12-01 607
Android休眠唤醒机制简介（二）  (2012-11-29 16:32:52) 转载▼ 标签：  文件   感觉   简介   作用   思路 分类： Android待机流程 ************************************************************
Android进阶技巧之Android休眠机制
m0_58479348的博客
04-13 4005
一、休眠概述 休眠，简而言之就是设备在不需要工作的时候把一些部件、外设关掉(掉电或让它进入低功耗模式)。 为什么要休眠呢？一言以蔽之：省电。 休眠分主动休眠和被动休眠。主动休眠：比如我电脑不用了，就通过设置让系统进入休眠模式；被动休眠：系统检测到自己闲的慌，为了节约故，自己就休眠去了。 废话不叙。 文末有福利！！！ 二、Android休眠 休眠是内核的核心工作，而Android是基于Linux内核的，所以Android休眠和内核有着千丝万缕的联系；由于Android的特殊应用场景：移动设备，所以Androi
android休眠唤醒java_Android休眠唤醒机制简介（二）
weixin_31560425的博客
02-27 796
下面我将分别以两条路线(第一：获得wakelock唤醒锁。第二：系统进入睡眠。)来分别说明各自的流程，让读者对android睡眠唤醒机制有更深入的理解！第一部分：获得wakelock唤醒锁比如在应用程序中，当获得wakelock唤醒锁的时候，它首先是调用/android/frameworks/base/core/java/android/os/PowerManager类中的public voida...
android 休眠唤醒机制分析(一) — wake_lock【转】
zzb2760715357的博客
01-03 570
本文转载自:https://blog.csdn.net/dragon101788/article/details/41984935 Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。本文主要...
android 休眠唤醒机制分析(二) — early_suspend
热门推荐
嵌入式技术博客
09-15 1万+
early_suspend是Android休眠流程的第一阶段即浅度休眠，不会受到wake_lock的阻止，一般用于关闭lcd、tp等设备为运行的应用节约电能。Android的PowerManagerService会根据用户的操作情况调整电源状态，如果需要休眠则会调用到HAL层的set_screen_state()接口，在set_screen_state()中会向/sys/power/state节点
Linux与Android休眠唤醒机制解析
Linux内核的休眠流程涉及多个关键文件，包括`kernel/power/main.c`、`kernel/arch/xxx/mach-xxx/pm.c`和`driver/base/power/main.c`等，这些源码提供了深入理解休眠唤醒机制的入口。 在Android系统中，休眠机制有...
android休眠唤醒java_Android休眠唤醒机制
weixin_34746715的博客
02-27 210
Android在Linux内核原有的睡眠唤醒模块基础上，主要增加了下面三个机制• Wake Lock 唤醒锁机制；• Early Suspend 预挂起机制；• Late Resume 迟唤醒机制；其基本原理：当启动一个应用程序的时候，它可以申请一个wake_lock唤醒锁，每当申请成功后都会在内核中注册一下(通知系统内核，现在已经有锁被申请，系统内核的wake_lock_store把它加入锁中)...
Android的休眠唤醒机制wake_lock机制
zhangha0的博客
02-07 841
wakel_lock：Android的一种休眠唤醒机制   使用场景：在LCD或TP关闭的时候，依然需要运行的关键代码，如电量统计、charger探测、音乐播放等，即使在休眠状态下也是需要正常运行的   主要思想：只要系统中存在有效锁，就阻止AP(可认为是ARM处理器)进入休眠状态，即不让处理器挂起，只有系统中所有锁都被释放之后系统才进入休眠状态   分类：suspend休眠锁、Idl
android 休眠唤醒机制分析(一)
Fybon的专栏
08-27 2322
Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。本文主要分析driver层wake_lock的实现。 一、wake_lock 定义和接口 [cpp] view
Android睡眠唤醒机制--系统架构
MyArrow的专栏
11-01 1万+
一、简介      Android在Linux内核原有的睡眠唤醒模块上基础上，主要增加了下面三个机制：      • Wake Lock 唤醒锁机制；      • Early Suspend 预挂起机制；      • Late Resume 迟唤醒机制；      其基本原理：当启动一个应用程序的时候，它可以申请一个wake_lock唤醒锁，每当申请成功之后都会在内核中注册一下（通知
Android kotlin实战之协程suspend详解与使用
03-02 3681
Kotlin 是一门仅在标准库中提供最基本底层 API 以便各种其他库能够利用协程的语言。与许多其他具有类似功能的语言不同，async与await在 Kotlin 中并不是关键字，甚至都不是标准库的一部分。此外，Kotlin 的挂起函数概念为异步操作提供了比 future 与 promise 更安全、更不易出错的抽象。
Android知识点 121 —— AlarmManager与RTC唤醒
编程到管理、技术到产品
10-26 1815
原文链接： 返回知识列表：Android知识列表 RTC时钟概念：实时时钟的缩写是RTC(Real_Time Clock)。RTC 是集成电路，通常称为时钟芯片。 实时时钟芯片是日常生活中应用最为广泛的消费类电子产品之一。它为人们提供精确的实时时间,或者为电子系统提供精确的时间基准,目前实时时钟芯片大多采用精度较高的晶体振荡器作为时钟源。有些时钟芯片为了在主电源掉电时，还可以工作，需要外加电池供电。 只有一个RTC时钟。当设置AlarmManager的时候，是将时钟设置到RTC时钟当中。An..
安卓CPU休眠Timer不执行
cjoo的博客
04-29 6197
在开发中，有时我们需要在后台循环执行一些操作（比如：即时通讯心跳包的发送）。 xml布局文件： RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="mat
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值