自学教程：C++ suspend_test函数代码示例

/** *	suspend_enter - enter the desired system sleep state. *	@state:		state to enter * *	This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state){	int error;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			return error;	}	error = device_power_down(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;	error = disable_nonboot_cpus();	if (error || suspend_test(TEST_CPUS))		goto Enable_cpus;	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = sysdev_suspend(PMSG_SUSPEND);	if (!error) {		if (!suspend_test(TEST_CORE))			error = suspend_ops->enter(state);		sysdev_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	if (suspend_ops->wake)		suspend_ops->wake(); Power_up_devices:	device_power_up(PMSG_RESUME); Platfrom_finish:	if (suspend_ops->finish)		suspend_ops->finish();	return error;}

/** *	suspend_enter - enter the desired system sleep state. *	@state:		state to enter * *	This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state){	int error;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_noirq(PMSG_SUSPEND);	if (error) {;		goto Platform_finish;	}	if (suspend_ops->prepare_late) {		error = suspend_ops->prepare_late();		if (error)			goto Platform_wake;	}	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	error = disable_nonboot_cpus();	if (error || suspend_test(TEST_CPUS))		goto Platform_wake;	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = syscore_suspend();	if (!error) {		if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) {			error = suspend_ops->enter(state);			events_check_enabled = false;		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Platform_wake:	if (suspend_ops->wake)		suspend_ops->wake();	dpm_resume_noirq(PMSG_RESUME); Platform_finish:	if (suspend_ops->finish)		suspend_ops->finish();	return error;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error, ftrace_save;	if (!suspend_ops)		return -ENOSYS;	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_save = __ftrace_enabled_save();	suspend_test_start();	error = device_suspend(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;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Resume_devices;	}	if (suspend_test(TEST_PLATFORM))		goto Finish;	error = disable_nonboot_cpus();	if (!error && !suspend_test(TEST_CPUS))		suspend_enter(state);	enable_nonboot_cpus(); Finish:	if (suspend_ops->finish)		suspend_ops->finish(); Resume_devices:	suspend_test_start();	device_resume(PMSG_RESUME);	suspend_test_finish("resume devices");	__ftrace_enabled_restore(ftrace_save);	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

static int plug_secondary_cpus(void *data){	if (!(suspend_test(TEST_FREEZER) ||	      suspend_test(TEST_DEVICES) ||	      suspend_test(TEST_PLATFORM)))		enable_nonboot_cpus();	complete(&second_cpu_complete);	return 0;}

/** *	enter_state - Do common work of entering low-power state. *	@state:		pm_state structure for state we're entering. * *	Make sure we're the only ones trying to enter a sleep state. Fail *	if someone has beat us to it, since we don't want anything weird to *	happen when we wake up. *	Then, do the setup for suspend, enter the state, and cleaup (after *	we've woken up). */int enter_state(suspend_state_t state){	int error;	if (!valid_state(state))		return -ENODEV;	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	run_suspend();		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;	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();	run_resume(); Unlock:	mutex_unlock(&pm_mutex);	return error;}

/** *	suspend_enter - enter the desired system sleep state. *	@state:		state to enter * *	This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state){	int error = 0;	device_pm_lock();	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	if ((error = device_power_down(PMSG_SUSPEND))) {		printk(KERN_ERR "PM: Some devices failed to power down/n");		goto Done;	}	error = sysdev_suspend(PMSG_SUSPEND);	if (!error) {		if (!suspend_test(TEST_CORE))			error = suspend_ops->enter(state);		sysdev_resume();	}	device_power_up(PMSG_RESUME); Done:	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled());	device_pm_unlock();	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	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;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);#ifdef CONFIG_MACH_LGE_325_BOARD_VZW#ifdef CONFIG_LGE_LOG_SERVICE    if(sleep_enter == 1){	    struct timespec ts;	    struct rtc_time tm;	    getnstimeofday(&ts);	    rtc_time_to_tm(ts.tv_sec, &tm);	    printk(KERN_UTC_WAKEUP "%d-%02d-%02d %02d:%02d:%02d.%06lu/n",	                    tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,	                    tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec/1000);	    sleep_enter = 0;	}#endif#endif	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	suspend_test_start();	/* time stamp for start of device suspend */	time_stamp_in_suspend_flow(DEV_SUS, true);	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;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again());	if (wakeup)		error = -EBUSY; Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	/* time stamp for end of device resume */	time_stamp_in_suspend_flow(DEV_RES, false);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	} else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin) {		error = freeze_ops->begin();		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		log_suspend_abort_reason("Some devices failed to suspend");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& platform_suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)		freeze_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** *	enter_state - Do common work of entering low-power state. *	@state:		pm_state structure for state we're entering. * *	Make sure we're the only ones trying to enter a sleep state. Fail *	if someone has beat us to it, since we don't want anything weird to *	happen when we wake up. *	Then, do the setup for suspend, enter the state, and cleaup (after *	we've woken up). */int enter_state(suspend_state_t state){	int error;	struct task_struct *cpu_task;	if (!valid_state(state))		return -ENODEV;	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	/*	 * Assure that previous started thread is completed before	 * attempting to suspend again.	 */	error = wait_for_completion_timeout(&second_cpu_complete,					    msecs_to_jiffies(500));	WARN_ON(error == 0);#ifdef CONFIG_PM_SYNC_CTRL	if (pm_sync_active) {;		sys_sync();;	}#else;	sys_sync();;#endif	pr_debug("PM: Preparing system for %s sleep/n", pm_states[state]);	error = suspend_prepare();	if (error)		goto Unlock;	if (suspend_test(TEST_FREEZER))		goto Finish;	pr_debug("PM: Entering %s sleep/n", pm_states[state]);	pm_restrict_gfp_mask();	error = suspend_devices_and_enter(state);	pm_restore_gfp_mask(); Finish:	pr_debug("PM: Finishing wakeup./n");	suspend_finish(); Unlock:	cpu_task = kthread_run(plug_secondary_cpus,			       NULL, "cpu-plug");	BUG_ON(IS_ERR(cpu_task));	mutex_unlock(&pm_mutex);	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){    int error;    bool wakeup = false;    if (!suspend_ops)        return -ENOSYS;    trace_machine_suspend(state);    if (suspend_ops->begin) {        error = suspend_ops->begin(state);        if (error)            goto Close;    }    suspend_console();    suspend_test_start();    error = dpm_suspend_start(PMSG_SUSPEND);    /*OPPO 2012-11-27 zhzhyon Add for reason*/#ifdef CONFIG_VENDOR_EDIT    if(has_wake_lock(WAKE_LOCK_SUSPEND))    {        goto Resume_devices;    }#endif    /*OPPO 2012-11-27 zhzhyon Add end*/    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;    do {        error = suspend_enter(state, &wakeup);    } while (!error && !wakeup             && suspend_ops->suspend_again && suspend_ops->suspend_again());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();    trace_machine_suspend(PWR_EVENT_EXIT);    return error;Recover_platform:    if (suspend_ops->recover)        suspend_ops->recover();    goto Resume_devices;}

/** * enter_state - Do common work needed to enter system sleep state. * @state: System sleep state to enter. * * Make sure that no one else is trying to put the system into a sleep state. * Fail if that's not the case.  Otherwise, prepare for system suspend, make the * system enter the given sleep state and clean up after wakeup. */static int enter_state(suspend_state_t state){	int error;	if (state == PM_SUSPEND_FREEZE) {#ifdef CONFIG_PM_DEBUG		if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {			pr_warning("PM: Unsupported test mode for freeze state,"				   "please choose none/freezer/devices/platform./n");			return -EAGAIN;		}#endif	} else if (!valid_state(state)) {		return -EINVAL;	}	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	if (state == PM_SUSPEND_FREEZE)		freeze_begin();#ifdef CONFIG_HAS_EARLYSUSPEND	if (suspendsync)		suspend_sys_sync_queue();#else	if (suspendsync) {		printk(KERN_INFO "PM: Syncing filesystems ... ");		sys_sync();		printk("done./n");	}#endif	pr_debug("PM: Preparing system for %s sleep/n", pm_states[state].label);	error = suspend_prepare(state);	if (error)		goto Unlock;	if (suspend_test(TEST_FREEZER))		goto Finish;	pr_debug("PM: Entering %s sleep/n", pm_states[state].label);	pm_restrict_gfp_mask();	error = suspend_devices_and_enter(state);	pm_restore_gfp_mask(); Finish:	pr_debug("PM: Finishing wakeup./n");	suspend_finish(); Unlock:	mutex_unlock(&pm_mutex);	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;#ifdef CONFIG_TOI	drop_pagecache();#endif 	trace_machine_suspend(state);	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	ftrace_stop();	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;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	ftrace_start();	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * enter_state - Do common work needed to enter system sleep state. * @state: System sleep state to enter. * * Make sure that no one else is trying to put the system into a sleep state. * Fail if that's not the case.  Otherwise, prepare for system suspend, make the * system enter the given sleep state and clean up after wakeup. */static int enter_state(suspend_state_t state){	int error;	trace_suspend_resume(TPS("suspend_enter"), state, true);	if (state == PM_SUSPEND_TO_IDLE) {#ifdef CONFIG_PM_DEBUG		if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {			pr_warn("Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform./n");			return -EAGAIN;		}#endif	} else if (!valid_state(state)) {		return -EINVAL;	}	if (!mutex_trylock(&system_transition_mutex))		return -EBUSY;	if (state == PM_SUSPEND_TO_IDLE)		s2idle_begin();#ifndef CONFIG_SUSPEND_SKIP_SYNC	trace_suspend_resume(TPS("sync_filesystems"), 0, true);	pr_info("Syncing filesystems ... ");	ksys_sync();	pr_cont("done./n");	trace_suspend_resume(TPS("sync_filesystems"), 0, false);#endif	pm_pr_dbg("Preparing system for sleep (%s)/n", mem_sleep_labels[state]);	pm_suspend_clear_flags();	error = suspend_prepare(state);	if (error)		goto Unlock;	if (suspend_test(TEST_FREEZER))		goto Finish;	trace_suspend_resume(TPS("suspend_enter"), state, false);	pm_pr_dbg("Suspending system (%s)/n", mem_sleep_labels[state]);	pm_restrict_gfp_mask();	error = suspend_devices_and_enter(state);	pm_restore_gfp_mask(); Finish:	events_check_enabled = false;	pm_pr_dbg("Finishing wakeup./n");	suspend_finish(); Unlock:	mutex_unlock(&system_transition_mutex);	return error;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (need_suspend_ops(state) && !suspend_ops)		return -ENOSYS;	if (need_suspend_ops(state) && suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	} else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin) {		error = freeze_ops->begin();		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		pr_err("PM: Some devices failed to suspend, or early wake event detected/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && need_suspend_ops(state)		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	resume_console(); Close:	if (need_suspend_ops(state) && suspend_ops->end)		suspend_ops->end();	else if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)		freeze_ops->end();	return error; Recover_platform:	if (need_suspend_ops(state) && suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	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;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup		&& suspend_ops->suspend_again && suspend_ops->suspend_again()); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);#ifdef CONFIG_ZTE_PLATFORM_RECORD_APP_AWAKE_SUSPEND_TIME	pr_info("Resume DONE /n");	//LHX_PM_20110113 add log to indicate resume finish	record_sleep_awake_time(false);		//LHX_PM_20110324_01 add code to record how long the APP sleeps or keeps awake #endif	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * enter_state - Do common work needed to enter system sleep state. * @state: System sleep state to enter. * * Make sure that no one else is trying to put the system into a sleep state. * Fail if that's not the case.  Otherwise, prepare for system suspend, make the * system enter the given sleep state and clean up after wakeup. */static int enter_state(suspend_state_t state){	int error;	trace_suspend_resume(TPS("suspend_enter"), state, true);	if (state == PM_SUSPEND_FREEZE) {#ifdef CONFIG_PM_DEBUG		if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {			pr_warning("PM: Unsupported test mode for suspend to idle,"				   "please choose none/freezer/devices/platform./n");			return -EAGAIN;		}#endif	} else if (!valid_state(state)) {		return -EINVAL;	}	if (!mutex_trylock(&pm_mutex))		return -EBUSY;	if (state == PM_SUSPEND_FREEZE)		freeze_begin();	trace_suspend_resume(TPS("sync_filesystems"), 0, true);	printk(KERN_INFO "PM: Syncing filesystems ... ");	sys_sync();	printk("done./n");	trace_suspend_resume(TPS("sync_filesystems"), 0, false);	pr_debug("PM: Preparing system for sleep (%s)/n", pm_states[state]);	error = suspend_prepare(state);	if (error)		goto Unlock;	if (suspend_test(TEST_FREEZER))		goto Finish;	trace_suspend_resume(TPS("suspend_enter"), state, false);	pr_debug("PM: Suspending system (%s)/n", pm_states[state]);	pm_restrict_gfp_mask();	error = suspend_devices_and_enter(state);	pm_restore_gfp_mask(); Finish:	pr_debug("PM: Finishing wakeup./n");	suspend_finish(); Unlock:	mutex_unlock(&pm_mutex);	return error;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */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);#ifdef CONFIG_WMT_SPITS2_SUPPORT		/*Disable TS interrupt*/	wmt_ts_pre_suspend(PMSG_SUSPEND);#endif	suspend_test_finish("resume devices");	resume_console();	printk("WMT wake up event %x/n",WMT_WAKE_UP_EVENT);	WMT_WAKE_UP_EVENT = 0; Close:	if (suspend_ops->end)		suspend_ops->end();	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	if (suspend_ops->begin) {		error = suspend_ops->begin(state);		if (error)			goto Close;	}	suspend_console();	suspend_test_start();	suspend_expire_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to suspend/n");		goto Recover_platform;	}	suspend_expire_finish("suspend devices");	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	suspend_enter(state); Resume_devices:	suspend_test_start();	suspend_expire_start();	dpm_resume_end(PMSG_RESUME);	suspend_expire_finish("resume devices");	suspend_test_finish("resume devices");	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

/** * suspend_devices_and_enter - Suspend devices and enter system sleep state. * @state: System sleep state to enter. */int suspend_devices_and_enter(suspend_state_t state){	int error;	bool wakeup = false;	if (!sleep_state_supported(state))		return -ENOSYS;	pm_suspend_target_state = state;	error = platform_suspend_begin(state);	if (error)		goto Close;	suspend_console();	suspend_test_start();	error = dpm_suspend_start(PMSG_SUSPEND);	if (error) {		pr_err("Some devices failed to suspend, or early wake event detected/n");		goto Recover_platform;	}	suspend_test_finish("suspend devices");	if (suspend_test(TEST_DEVICES))		goto Recover_platform;	do {		error = suspend_enter(state, &wakeup);	} while (!error && !wakeup && platform_suspend_again(state)); Resume_devices:	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	suspend_test_finish("resume devices");	trace_suspend_resume(TPS("resume_console"), state, true);	resume_console();	trace_suspend_resume(TPS("resume_console"), state, false); Close:	platform_resume_end(state);	pm_suspend_target_state = PM_SUSPEND_ON;	return error; Recover_platform:	platform_recover(state);	goto Resume_devices;}

/** * enter_state - Do common work needed to enter system sleep state. * @state: System sleep state to enter. * * Make sure that no one else is trying to put the system into a sleep state. * Fail if that's not the case.  Otherwise, prepare for system suspend, make the * system enter the given sleep state and clean up after wakeup. */static int enter_state(suspend_state_t state){    int error;    if (!valid_state(state))        return -ENODEV;    if (!mutex_trylock(&pm_mutex))        return -EBUSY;    if (state == PM_SUSPEND_FREEZE)        freeze_begin();#ifndef CONFIG_ARCH_HI3630    printk(KERN_INFO "PM: Syncing filesystems ... ");    sys_sync();    printk("done./n");#else    hisi_sys_sync_queue();#endif    pr_debug("PM: Preparing system for %s sleep/n", pm_states[state]);    error = suspend_prepare(state);    if (error)        goto Unlock;    if (suspend_test(TEST_FREEZER))        goto Finish;    pr_debug("PM: Entering %s sleep/n", pm_states[state]);    pm_restrict_gfp_mask();    error = suspend_devices_and_enter(state);    pm_restore_gfp_mask();Finish:    pr_debug("PM: Finishing wakeup./n");    suspend_finish();Unlock:    mutex_unlock(&pm_mutex);    return error;}

/** *	suspend_devices_and_enter - suspend devices and enter the desired system *				    sleep state. *	@state:		  state to enter */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();	pm_restrict_gfp_mask();	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);	ktime_resume_endtime=ktime_get();	printk(KERN_ERR "<POWER>resume6[peripheral resume]take %llu ns/n",ktime_to_ns(ktime_sub(ktime_resume_endtime, ktime_resume_fromtime)));	ktime_resume_fromtime=ktime_resume_endtime;	suspend_test_finish("resume devices");	pm_restore_gfp_mask();	resume_console(); Close:	if (suspend_ops->end)		suspend_ops->end();	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}