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

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	int error;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_end(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down/n");		goto Platform_finish;	}	/* time stamp for end of device suspend */	time_stamp_in_suspend_flow(DEV_SUS, false);	if (suspend_ops->prepare_late) {		error = suspend_ops->prepare_late();		if (error)			goto Platform_wake;	}	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	/* time stamp for start of disabling non-boot cpus */	time_stamp_in_suspend_flow(NB_CPU_OFF, true);	error = disable_nonboot_cpus();	/* time stamp for end of disabling non-boot cpus */	time_stamp_in_suspend_flow(NB_CPU_OFF, false);	if (error || suspend_test(TEST_CPUS))		goto Enable_cpus;	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			error = suspend_ops->enter(state);			events_check_enabled = false;		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	/* time stamp for start of enabling non-boot cpus */	time_stamp_in_suspend_flow(NB_CPU_ON, true);	enable_nonboot_cpus();	/* time stamp for end of enabling non-boot cpus */	time_stamp_in_suspend_flow(NB_CPU_ON, false); Platform_wake:	if (suspend_ops->wake)		suspend_ops->wake();	/* time stamp for start of device resume */	time_stamp_in_suspend_flow(DEV_RES, true);	dpm_resume_start(PMSG_RESUME); Platform_finish:	if (suspend_ops->finish)		suspend_ops->finish();	return error;}

/** * resume_target_kernel - Restore system state from a hibernation image. * @platform_mode: Whether or not to use the platform driver. * * Execute device drivers' "noirq" and "late" freeze callbacks, restore the * contents of highmem that have not been restored yet from the image and run * the low-level code that will restore the remaining contents of memory and * switch to the just restored target kernel. */static int resume_target_kernel(bool platform_mode){	int error;	error = dpm_suspend_end(PMSG_QUIESCE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down, "			"aborting resume/n");		return error;	}	error = platform_pre_restore(platform_mode);	if (error)		goto Cleanup;	error = disable_nonboot_cpus();	if (error)		goto Enable_cpus;	clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);	local_irq_disable();	error = syscore_suspend();	if (error)		goto Enable_irqs;	save_processor_state();	error = restore_highmem();	if (!error) {		error = swsusp_arch_resume();		/*		 * The code below is only ever reached in case of a failure.		 * Otherwise, execution continues at the place where		 * swsusp_arch_suspend() was called.		 */		BUG_ON(!error);		/*		 * This call to restore_highmem() reverts the changes made by		 * the previous one.		 */		restore_highmem();	}	/*	 * The only reason why swsusp_arch_resume() can fail is memory being	 * very tight, so we have to free it as soon as we can to avoid	 * subsequent failures.	 */	swsusp_free();	restore_processor_state();	touch_softlockup_watchdog();	syscore_resume(); Enable_irqs:	clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);	local_irq_enable(); Enable_cpus:	enable_nonboot_cpus(); Cleanup:	platform_restore_cleanup(platform_mode);	dpm_resume_start(PMSG_RECOVER);	return error;}

/** * hibernation_platform_enter - Power off the system using the platform driver. */int hibernation_platform_enter(void){	int error;	if (!hibernation_ops)		return -ENOSYS;	/*	 * We have cancelled the power transition by running	 * hibernation_ops->finish() before saving the image, so we should let	 * the firmware know that we're going to enter the sleep state after all	 */	error = hibernation_ops->begin();	if (error)		goto Close;	entering_platform_hibernation = true;	suspend_console();	error = dpm_suspend_start(PMSG_HIBERNATE);	if (error) {		if (hibernation_ops->recover)			hibernation_ops->recover();		goto Resume_devices;	}	error = dpm_suspend_end(PMSG_HIBERNATE);	if (error)		goto Resume_devices;	error = hibernation_ops->prepare();	if (error)		goto Platform_finish;	error = disable_nonboot_cpus();	if (error)		goto Platform_finish;	clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);	local_irq_disable();	syscore_suspend();	if (pm_wakeup_pending()) {		error = -EAGAIN;		goto Power_up;	}	hibernation_ops->enter();	/* We should never get here */	while (1); Power_up:	syscore_resume();	clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);	local_irq_enable();	enable_nonboot_cpus(); Platform_finish:	hibernation_ops->finish();	dpm_resume_start(PMSG_RESTORE); Resume_devices:	entering_platform_hibernation = false;	dpm_resume_end(PMSG_RESTORE);	resume_console(); Close:	hibernation_ops->end();	return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	int error;	error = platform_suspend_prepare(state);	if (error)		goto Platform_finish;	error = dpm_suspend_late(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: late suspend of devices failed/n");		goto Platform_finish;	}	error = platform_suspend_prepare_late(state);	if (error)		goto Devices_early_resume;	error = dpm_suspend_noirq(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: noirq suspend of devices failed/n");		goto Platform_early_resume;	}	error = platform_suspend_prepare_noirq(state);	if (error)		goto Platform_wake;	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	/*	 * PM_SUSPEND_FREEZE equals	 * frozen processes + suspended devices + idle processors.	 * Thus we should invoke freeze_enter() soon after	 * all the devices are suspended.	 */	if (state == PM_SUSPEND_FREEZE) {		trace_suspend_resume(TPS("machine_suspend"), state, true);		freeze_enter();		trace_suspend_resume(TPS("machine_suspend"), state, false);		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 = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			trace_suspend_resume(TPS("machine_suspend"),				state, true);			error = suspend_ops->enter(state);			trace_suspend_resume(TPS("machine_suspend"),				state, false);			events_check_enabled = false;		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	platform_resume_noirq(state);	dpm_resume_noirq(PMSG_RESUME); Platform_early_resume:	platform_resume_early(state); Devices_early_resume:	dpm_resume_early(PMSG_RESUME); Platform_finish:	platform_resume_finish(state);	return error;}

/** * create_image - Create a hibernation image. * @platform_mode: Whether or not to use the platform driver. * * Execute device drivers' "late" and "noirq" freeze callbacks, create a * hibernation image and run the drivers' "noirq" and "early" thaw callbacks. * * Control reappears in this routine after the subsequent restore. */static int create_image(int platform_mode){	int error;	error = dpm_suspend_end(PMSG_FREEZE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down, "			"aborting hibernation/n");		return error;	}	error = platform_pre_snapshot(platform_mode);	if (error || hibernation_test(TEST_PLATFORM))		goto Platform_finish;	error = disable_nonboot_cpus();	if (error || hibernation_test(TEST_CPUS))		goto Enable_cpus;	clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);	local_irq_disable();	error = syscore_suspend();	if (error) {		printk(KERN_ERR "PM: Some system devices failed to power down, "			"aborting hibernation/n");		goto Enable_irqs;	}	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())		goto Power_up;	in_suspend = 1;	save_processor_state();	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);	error = swsusp_arch_suspend();	trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);	if (error)		printk(KERN_ERR "PM: Error %d creating hibernation image/n",			error);	/* Restore control flow magically appears here */	restore_processor_state();	if (!in_suspend)		events_check_enabled = false;	platform_leave(platform_mode); Power_up:	syscore_resume(); Enable_irqs:	clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);	local_irq_enable(); Enable_cpus:	enable_nonboot_cpus(); Platform_finish:	platform_finish(platform_mode);	dpm_resume_start(in_suspend ?		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);	return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	char suspend_abort[MAX_SUSPEND_ABORT_LEN];	int error, last_dev;	error = platform_suspend_prepare(state);	if (error)		goto Platform_finish;	error = dpm_suspend_late(PMSG_SUSPEND);	if (error) {		last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;		last_dev %= REC_FAILED_NUM;		printk(KERN_ERR "PM: late suspend of devices failed/n");		log_suspend_abort_reason("%s device failed to power down",			suspend_stats.failed_devs[last_dev]);		goto Platform_finish;	}	error = platform_suspend_prepare_late(state);	if (error)		goto Devices_early_resume;	error = dpm_suspend_noirq(PMSG_SUSPEND);	if (error) {		last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;		last_dev %= REC_FAILED_NUM;		printk(KERN_ERR "PM: noirq suspend of devices failed/n");		log_suspend_abort_reason("noirq suspend of %s device failed",			suspend_stats.failed_devs[last_dev]);		goto Platform_early_resume;	}	error = platform_suspend_prepare_noirq(state);	if (error)		goto Platform_wake;	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	/*	 * PM_SUSPEND_FREEZE equals	 * frozen processes + suspended devices + idle processors.	 * Thus we should invoke freeze_enter() soon after	 * all the devices are suspended.	 */	if (state == PM_SUSPEND_FREEZE) {		trace_suspend_resume(TPS("machine_suspend"), state, true);		freeze_enter();		trace_suspend_resume(TPS("machine_suspend"), state, false);		goto Platform_wake;	}	error = disable_nonboot_cpus();	if (error || suspend_test(TEST_CPUS)) {		log_suspend_abort_reason("Disabling non-boot cpus failed");		goto Enable_cpus;	}	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			trace_suspend_resume(TPS("machine_suspend"),				state, true);			error = suspend_ops->enter(state);			trace_suspend_resume(TPS("machine_suspend"),				state, false);			events_check_enabled = false;		} else if (*wakeup) {			pm_get_active_wakeup_sources(suspend_abort,				MAX_SUSPEND_ABORT_LEN);			log_suspend_abort_reason(suspend_abort);			error = -EBUSY;		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	platform_resume_noirq(state);	dpm_resume_noirq(PMSG_RESUME); Platform_early_resume:	platform_resume_early(state); Devices_early_resume://.........这里部分代码省略.........

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */#ifdef VENDOR_EDITextern void regulator_suspend_dump(void);extern void pinctrl_suspend_dump(void);#endif /* VENDOR_EDIT */static int suspend_enter(suspend_state_t state, bool *wakeup){	char suspend_abort[MAX_SUSPEND_ABORT_LEN];	int error, last_dev;	if (need_suspend_ops(state) && suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_end(PMSG_SUSPEND);	if (error) {		last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;		last_dev %= REC_FAILED_NUM;		printk(KERN_ERR "PM: Some devices failed to power down/n");		log_suspend_abort_reason("%s device failed to power down",			suspend_stats.failed_devs[last_dev]);		goto Platform_finish;	}	if (need_suspend_ops(state) && suspend_ops->prepare_late) {		error = suspend_ops->prepare_late();		if (error)			goto Platform_wake;	}	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	/*	 * PM_SUSPEND_FREEZE equals	 * frozen processes + suspended devices + idle processors.	 * Thus we should invoke freeze_enter() soon after	 * all the devices are suspended.	 */	if (state == PM_SUSPEND_FREEZE) {		freeze_enter();		goto Platform_wake;	}	error = disable_nonboot_cpus();	if (error || suspend_test(TEST_CPUS)) {		log_suspend_abort_reason("Disabling non-boot cpus failed");		goto Enable_cpus;	}	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {#ifdef VENDOR_EDIT			regulator_suspend_dump();			pinctrl_suspend_dump();#endif /* VENDOR_EDIT */			error = suspend_ops->enter(state);			events_check_enabled = false;		} else if (*wakeup) {			pm_get_active_wakeup_sources(suspend_abort,				MAX_SUSPEND_ABORT_LEN);			log_suspend_abort_reason(suspend_abort);			error = -EBUSY;		}		start_logging_wakeup_reasons();		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	if (need_suspend_ops(state) && suspend_ops->wake)		suspend_ops->wake();	dpm_resume_start(PMSG_RESUME); Platform_finish:	if (need_suspend_ops(state) && suspend_ops->finish)		suspend_ops->finish();	return error;}

static int create_image(int platform_mode){    int error;    error = arch_prepare_suspend();    if (error)        return error;    /* At this point, dpm_suspend_start() has been called, but *not*     * dpm_suspend_noirq(). We *must* call dpm_suspend_noirq() now.     * Otherwise, drivers for some devices (e.g. interrupt controllers)     * become desynchronized with the actual state of the hardware     * at resume time, and evil weirdness ensues.     */    error = dpm_suspend_noirq(PMSG_FREEZE);    if (error) {        printk(KERN_ERR "PM: Some devices failed to power down, "               "aborting hibernation/n");        return error;    }    error = platform_pre_snapshot(platform_mode);    if (error || hibernation_test(TEST_PLATFORM))        goto Platform_finish;    error = disable_nonboot_cpus();    if (error || hibernation_test(TEST_CPUS)            || hibernation_testmode(HIBERNATION_TEST))        goto Enable_cpus;    local_irq_disable();    error = sysdev_suspend(PMSG_FREEZE);    if (!error)        error = syscore_suspend();    if (error) {        printk(KERN_ERR "PM: Some system devices failed to power down, "               "aborting hibernation/n");        goto Enable_irqs;    }    if (hibernation_test(TEST_CORE))        goto Power_up;    in_suspend = 1;    save_processor_state();    error = swsusp_arch_suspend();    if (error)        printk(KERN_ERR "PM: Error %d creating hibernation image/n",               error);    /* Restore control flow magically appears here */    restore_processor_state();    if (!in_suspend)        platform_leave(platform_mode);Power_up:    syscore_resume();    sysdev_resume();    /* NOTE:  dpm_resume_noirq() is just a resume() for devices     * that suspended with irqs off ... no overall powerup.     */Enable_irqs:    local_irq_enable();Enable_cpus:    enable_nonboot_cpus();Platform_finish:    platform_finish(platform_mode);    dpm_resume_noirq(in_suspend ?                     (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);    return error;}

static int resume_target_kernel(bool platform_mode){    int error;    error = dpm_suspend_noirq(PMSG_QUIESCE);    if (error) {        printk(KERN_ERR "PM: Some devices failed to power down, "               "aborting resume/n");        return error;    }    error = platform_pre_restore(platform_mode);    if (error)        goto Cleanup;    error = disable_nonboot_cpus();    if (error)        goto Enable_cpus;    local_irq_disable();    error = sysdev_suspend(PMSG_QUIESCE);    if (!error)        error = syscore_suspend();    if (error)        goto Enable_irqs;    /* We'll ignore saved state, but this gets preempt count (etc) right */    save_processor_state();    error = restore_highmem();    if (!error) {        error = swsusp_arch_resume();        /*         * The code below is only ever reached in case of a failure.         * Otherwise execution continues at place where         * swsusp_arch_suspend() was called         */        BUG_ON(!error);        /* This call to restore_highmem() undos the previous one */        restore_highmem();    }    /*     * The only reason why swsusp_arch_resume() can fail is memory being     * very tight, so we have to free it as soon as we can to avoid     * subsequent failures     */    swsusp_free();    restore_processor_state();    touch_softlockup_watchdog();    syscore_resume();    sysdev_resume();Enable_irqs:    local_irq_enable();Enable_cpus:    enable_nonboot_cpus();Cleanup:    platform_restore_cleanup(platform_mode);    dpm_resume_noirq(PMSG_RECOVER);    return error;}

/** * create_image - Create a hibernation image. * @platform_mode: Whether or not to use the platform driver. * * Execute device drivers' .freeze_noirq() callbacks, create a hibernation image * and execute the drivers' .thaw_noirq() callbacks. * * Control reappears in this routine after the subsequent restore. */static int create_image(int platform_mode){	int error;	error = dpm_suspend_noirq(PMSG_FREEZE);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down, "			"aborting hibernation/n");		return error;	}	error = platform_pre_snapshot(platform_mode);	if (error || hibernation_test(TEST_PLATFORM))		goto Platform_finish;	error = disable_nonboot_cpus();	if (error || hibernation_test(TEST_CPUS)	    || hibernation_testmode(HIBERNATION_TEST))		goto Enable_cpus;	local_irq_disable();	error = syscore_suspend();	if (error) {		printk(KERN_ERR "PM: Some system devices failed to power down, "			"aborting hibernation/n");		goto Enable_irqs;	}	if (hibernation_test(TEST_CORE) || pm_wakeup_pending())		goto Power_up;	in_suspend = 1;	save_processor_state();	error = swsusp_arch_suspend();	if (error)		printk(KERN_ERR "PM: Error %d creating hibernation image/n",			error);	/* Restore control flow magically appears here */	restore_processor_state();	if (!in_suspend) {		events_check_enabled = false;		platform_leave(platform_mode);	} Power_up:	syscore_resume(); Enable_irqs:	local_irq_enable(); Enable_cpus:	enable_nonboot_cpus(); Platform_finish:	platform_finish(platform_mode);	dpm_resume_noirq(in_suspend ?		(error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);	return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	int error;	error = platform_suspend_prepare(state);	if (error)		goto Platform_finish;	error = dpm_suspend_late(PMSG_SUSPEND);	if (error) {		pr_err("late suspend of devices failed/n");		goto Platform_finish;	}	error = platform_suspend_prepare_late(state);	if (error)		goto Devices_early_resume;	if (state == PM_SUSPEND_TO_IDLE && pm_test_level != TEST_PLATFORM) {		s2idle_loop();		goto Platform_early_resume;	}	error = dpm_suspend_noirq(PMSG_SUSPEND);	if (error) {		pr_err("noirq suspend of devices failed/n");		goto Platform_early_resume;	}	error = platform_suspend_prepare_noirq(state);	if (error)		goto Platform_wake;	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());	system_state = SYSTEM_SUSPEND;	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			trace_suspend_resume(TPS("machine_suspend"),				state, true);			error = suspend_ops->enter(state);			trace_suspend_resume(TPS("machine_suspend"),				state, false);		} else if (*wakeup) {			error = -EBUSY;		}		syscore_resume();	}	system_state = SYSTEM_RUNNING;	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	platform_resume_noirq(state);	dpm_resume_noirq(PMSG_RESUME); Platform_early_resume:	platform_resume_early(state); Devices_early_resume:	dpm_resume_early(PMSG_RESUME); Platform_finish:	platform_resume_finish(state);	return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){    int error;    if (suspend_ops->prepare) {        error = suspend_ops->prepare();        if (error)            goto Platform_finish;    }    error = dpm_suspend_end(PMSG_SUSPEND);    if (error) {        printk(KERN_ERR "PM: Some devices failed to power down/n");        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 Enable_cpus;    arch_suspend_disable_irqs();    BUG_ON(!irqs_disabled());    error = syscore_suspend();    if (!error) {        *wakeup = pm_wakeup_pending();        if (!(suspend_test(TEST_CORE) || *wakeup)) {            /*OPPO 2012-11-27 zhzhyon Add for headset detect*/#ifdef CONFIG_VENDOR_EDIT            if(has_wake_lock(WAKE_LOCK_SUSPEND))            {                goto Resume_devices;            }#endif            /*OPPO 2012-11-27 zhzhyon Add end*/            error = suspend_ops->enter(state);            events_check_enabled = false;        }        /*OPPO 2012-11-27 zhzhyon Add for headset detect*/#ifdef CONFIG_VENDOR_EDITResume_devices:#endif        /*OPPO 2012-11-27 zhzhyon Add end*/        syscore_resume();    }    arch_suspend_enable_irqs();    BUG_ON(irqs_disabled());Enable_cpus:    enable_nonboot_cpus();Platform_wake:    if (suspend_ops->wake)        suspend_ops->wake();    dpm_resume_start(PMSG_RESUME);Platform_finish:    if (suspend_ops->finish)        suspend_ops->finish();    return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	int error;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_end(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down/n");		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 Enable_cpus;	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	system_state = SYSTEM_SUSPEND;	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			error = suspend_ops->enter(state);			events_check_enabled = false;		}		syscore_resume();	}	system_state = SYSTEM_RUNNING;	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	if (suspend_ops->wake)		suspend_ops->wake();	dpm_resume_start(PMSG_RESUME); Platform_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) {		printk(KERN_ERR "PM: Some devices failed to power down/n");		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 Enable_cpus;	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();#ifdef CONFIG_LGE_LOG_SERVICE		sleep_enter = 1;#endif	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); 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_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	int error;	if (need_suspend_ops(state) && suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_end(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "PM: Some devices failed to power down/n");		goto Platform_finish;	}	if (need_suspend_ops(state) && suspend_ops->prepare_late) {		error = suspend_ops->prepare_late();		if (error)			goto Platform_wake;	}	if (suspend_test(TEST_PLATFORM))		goto Platform_wake;	/*	 * PM_SUSPEND_FREEZE equals	 * frozen processes + suspended devices + idle processors.	 * Thus we should invoke freeze_enter() soon after	 * all the devices are suspended.	 */	if (state == PM_SUSPEND_FREEZE) {		freeze_enter();		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 = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			error = suspend_ops->enter(state);			events_check_enabled = false;		} else if (*wakeup) {			error = -EBUSY;		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	if (need_suspend_ops(state) && suspend_ops->wake)		suspend_ops->wake();	dpm_resume_start(PMSG_RESUME); Platform_finish:	if (need_suspend_ops(state) && suspend_ops->finish)		suspend_ops->finish();	return error;}

/** * suspend_enter - Make the system enter the given sleep state. * @state: System sleep state to enter. * @wakeup: Returns information that the sleep state should not be re-entered. * * This function should be called after devices have been suspended. */static int suspend_enter(suspend_state_t state, bool *wakeup){	char suspend_abort[MAX_SUSPEND_ABORT_LEN];	int error, last_dev;	if (suspend_ops->prepare) {		error = suspend_ops->prepare();		if (error)			goto Platform_finish;	}	error = dpm_suspend_end(PMSG_SUSPEND);	if (error) {		last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;		last_dev %= REC_FAILED_NUM;		printk(KERN_ERR "PM: Some devices failed to power down/n");		log_suspend_abort_reason("%s device failed to power down",			suspend_stats.failed_devs[last_dev]);		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)) {		log_suspend_abort_reason("Disabling non-boot cpus failed");		goto Enable_cpus;	}	arch_suspend_disable_irqs();	BUG_ON(!irqs_disabled());	error = syscore_suspend();	if (!error) {		*wakeup = pm_wakeup_pending();		if (!(suspend_test(TEST_CORE) || *wakeup)) {			error = suspend_ops->enter(state);			events_check_enabled = false;		} else {			pm_get_active_wakeup_sources(suspend_abort,				MAX_SUSPEND_ABORT_LEN);			log_suspend_abort_reason(suspend_abort);		}		syscore_resume();	}	arch_suspend_enable_irqs();	BUG_ON(irqs_disabled()); Enable_cpus:	enable_nonboot_cpus(); Platform_wake:	if (suspend_ops->wake)		suspend_ops->wake();	dpm_resume_start(PMSG_RESUME); Platform_finish:	if (suspend_ops->finish)		suspend_ops->finish();	return error;}