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

static int enter_state(u32 state){	int error;	if (down_trylock(&pm_sem))		return -EBUSY;	/* Suspend is hard to get right on SMP. */	if (num_online_cpus() != 1) {		error = -EPERM;		goto Unlock;	}	if (state == PM_SUSPEND_DISK) {		error = pm_suspend_disk();		goto Unlock;	}	pr_debug("PM: Preparing system for suspend/n");	if ((error = suspend_prepare(state)))		goto Unlock;	pr_debug("PM: Entering state./n");	error = suspend_enter(state);	pr_debug("PM: Finishing up./n");	suspend_finish(state); Unlock:	up(&pm_sem);	return error;}

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_DISK) {		error = pm_suspend_disk();		goto Unlock;	}	pr_debug("PM: Preparing system for %s sleep/n", pm_states[state]);	if ((error = suspend_prepare(state)))		goto Unlock;	pr_debug("PM: Entering %s sleep/n", pm_states[state]);	error = suspend_enter(state);	pr_debug("PM: Finishing wakeup./n");	suspend_finish(state); 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 (!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 the desired system sleep *			  state. *	@state:		  state to enter */int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!pm_ops)		return -ENOSYS;	if (pm_ops->set_target) {		error = pm_ops->set_target(state);		if (error)			return error;	}	suspend_console();	error = device_suspend(PMSG_SUSPEND);	if (error) {		printk(KERN_ERR "Some devices failed to suspend/n");		goto Resume_console;	}	if (pm_ops->prepare) {		error = pm_ops->prepare(state);		if (error)			goto Resume_devices;	}	error = disable_nonboot_cpus();	if (!error)		suspend_enter(state);	enable_nonboot_cpus();	pm_finish(state); Resume_devices:	device_resume(); Resume_console:	resume_console();	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();	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 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;}

/** * 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;}

/** * 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;}

/** * 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;}

/** * 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;}

/** *	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 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;}

/** *	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 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;}

//.........这里部分代码省略.........		break;	case SNAPSHOT_S2RAM:		if (!pm_ops) {			error = -ENOSYS;			break;		}		if (!data->frozen) {			error = -EPERM;			break;		}		if (!mutex_trylock(&pm_mutex)) {			error = -EBUSY;			break;		}		if (pm_ops->prepare) {			error = pm_ops->prepare(PM_SUSPEND_MEM);			if (error)				goto OutS3;		}		/* Put devices to sleep */		suspend_console();		error = device_suspend(PMSG_SUSPEND);		if (error) {			printk(KERN_ERR "Failed to suspend some devices./n");		} else {			error = disable_nonboot_cpus();			if (!error) {				/* Enter S3, system is already frozen */				suspend_enter(PM_SUSPEND_MEM);				enable_nonboot_cpus();			}			/* Wake up devices */			device_resume();		}		resume_console();		if (pm_ops->finish)			pm_ops->finish(PM_SUSPEND_MEM); OutS3:		mutex_unlock(&pm_mutex);		break;	case SNAPSHOT_PMOPS:		error = -EINVAL;		switch (arg) {		case PMOPS_PREPARE:			if (hibernation_ops) {				data->platform_suspend = 1;				error = 0;			} else {				error = -ENOSYS;			}			break;		case PMOPS_ENTER:			if (data->platform_suspend) {				kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);				error = hibernation_ops->enter();			}

int suspend_devices_and_enter(suspend_state_t state){	int error;	if (!suspend_ops)		return -ENOSYS;	trace_machine_suspend(state);	var_wakeup_sts = 0;	var_during_suspend = 1;	pmc_disable_save_wakeup_events();	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;	error = suspend_enter(state); Resume_devices: 	if (wmt_trigger_resume_kpad){	  wmt_trigger_resume_kpad=0;	  wmt_resume_kpad();	}	if (wmt_trigger_resume_notify){	  wmt_trigger_resume_notify=0;	  wmt_resume_notify();	} 	suspend_test_start();	dpm_resume_end(PMSG_RESUME);	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();	pmc_enable_wakeup_restore_events();	var_during_suspend = 0;	trace_machine_suspend(PWR_EVENT_EXIT);	return error; Recover_platform:	if (suspend_ops->recover)		suspend_ops->recover();	goto Resume_devices;}

//.........这里部分代码省略.........    case SNAPSHOT_AVAIL_SWAP:        avail = count_swap_pages(data->swap, 1);        avail <<= PAGE_SHIFT;        error = put_user(avail, (loff_t __user *)arg);        break;    case SNAPSHOT_GET_SWAP_PAGE:        if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {            error = -ENODEV;            break;        }        if (!data->bitmap) {            data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));            if (!data->bitmap) {                error = -ENOMEM;                break;            }        }        offset = alloc_swap_page(data->swap, data->bitmap);        if (offset) {            offset <<= PAGE_SHIFT;            error = put_user(offset, (loff_t __user *)arg);        } else {            error = -ENOSPC;        }        break;    case SNAPSHOT_FREE_SWAP_PAGES:        if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {            error = -ENODEV;            break;        }        free_all_swap_pages(data->swap, data->bitmap);        free_bitmap(data->bitmap);        data->bitmap = NULL;        break;    case SNAPSHOT_SET_SWAP_FILE:        if (!data->bitmap) {            /*             * User space encodes device types as two-byte values,             * so we need to recode them             */            if (old_decode_dev(arg)) {                data->swap = swap_type_of(old_decode_dev(arg));                if (data->swap < 0)                    error = -ENODEV;            } else {                data->swap = -1;                error = -EINVAL;            }        } else {            error = -EPERM;        }        break;    case SNAPSHOT_S2RAM:        if (!data->frozen) {            error = -EPERM;            break;        }        if (down_trylock(&pm_sem)) {            error = -EBUSY;            break;        }        if (pm_ops->prepare) {            error = pm_ops->prepare(PM_SUSPEND_MEM);            if (error)                goto OutS3;        }        /* Put devices to sleep */        error = device_suspend(PMSG_SUSPEND);        if (error) {            printk(KERN_ERR "Failed to suspend some devices./n");        } else {            /* Enter S3, system is already frozen */            suspend_enter(PM_SUSPEND_MEM);            /* Wake up devices */            device_resume();        }        if (pm_ops->finish)            pm_ops->finish(PM_SUSPEND_MEM);OutS3:        up(&pm_sem);        break;    default:        error = -ENOTTY;    }    return error;}