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

/** * 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;	suspend_sys_sync_queue();	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:	mutex_unlock(&pm_mutex);	return error;}

static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,			  char *buf){	char *s = buf;#ifdef CONFIG_SUSPEND#if 0	// deleted by peres for test	int i;	for (i = 0; i < PM_SUSPEND_MAX; i++) {		if (pm_states[i] && valid_state(i))			s += sprintf(s,"%s ", pm_states[i]);	}#else	switch(global_state) {		case PM_SUSPEND_ON :			s += sprintf(s,"%s ", pm_states[PM_SUSPEND_ON]);			break;		case PM_SUSPEND_MEM :			s += sprintf(s,"%s ", pm_states[PM_SUSPEND_MEM]);			break;	}#endif#endif#ifdef CONFIG_HIBERNATION	s += sprintf(s, "%s/n", "disk");#else	if (s != buf)		/* convert the last space to a newline */		*(s-1) = '/n';#endif	return (s - buf);}

/** *	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;	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(); Unlock:	mutex_unlock(&pm_mutex);	return error;}

/** *	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_set_ops - Set the global suspend method table. * @ops: Suspend operations to use. */void suspend_set_ops(const struct platform_suspend_ops *ops){	lock_system_sleep();	suspend_ops = ops;	if (valid_state(PM_SUSPEND_STANDBY)) {		mem_sleep_states[PM_SUSPEND_STANDBY] = mem_sleep_labels[PM_SUSPEND_STANDBY];		pm_states[PM_SUSPEND_STANDBY] = pm_labels[PM_SUSPEND_STANDBY];		if (mem_sleep_default == PM_SUSPEND_STANDBY)			mem_sleep_current = PM_SUSPEND_STANDBY;	}	if (valid_state(PM_SUSPEND_MEM)) {		mem_sleep_states[PM_SUSPEND_MEM] = mem_sleep_labels[PM_SUSPEND_MEM];		if (mem_sleep_default >= PM_SUSPEND_MEM)			mem_sleep_current = PM_SUSPEND_MEM;	}	unlock_system_sleep();}

static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,			   const char *buf, size_t n){#ifdef CONFIG_SUSPEND#ifdef CONFIG_EARLYSUSPEND	suspend_state_t state = PM_SUSPEND_ON;#else	suspend_state_t state = PM_SUSPEND_STANDBY;#endif	const char * const *s;#endif	char *p;	int len;	int error = -EINVAL;	p = memchr(buf, '/n', n);	len = p ? p - buf : n;	/* First, check if we are requested to hibernate */	if (len == 4 && !strncmp(buf, "disk", len)) {		error = hibernate();  goto Exit;	}#if defined(CONFIG_MP_MSTAR_STR_BASE)    // for mstar str, we skip wakelock    // and earlysuspend/lateresume to speedup suspend    if (len == 4 && !strncmp(buf, "mstr", len)) {        state = PM_SUSPEND_MEM;        pm_is_mstar_str = 1;        error = enter_state(state);        pm_is_mstar_str = 0;        goto Exit;    }#endif#ifdef CONFIG_SUSPEND	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))			break;	}	if (state < PM_SUSPEND_MAX && *s)#ifdef CONFIG_EARLYSUSPEND		if (state == PM_SUSPEND_ON || valid_state(state)) {			error = 0;			request_suspend_state(state);		}#else		error = enter_state(state);#endif#endif Exit:	return error ? error : n;}

static ssize_t state_show(struct kset *kset, char *buf){	int i;	char * s = buf;	for (i = 0; i < PM_SUSPEND_MAX; i++) {		if (pm_states[i] && valid_state(i))			s += sprintf(s,"%s ", pm_states[i]);	}	s += sprintf(s,"/n");	return (s - buf);}

/** * suspend_set_ops - Set the global suspend method table. * @ops: Suspend operations to use. */void suspend_set_ops(const struct platform_suspend_ops *ops){	suspend_state_t i;	lock_system_sleep();	suspend_ops = ops;	for (i = PM_SUSPEND_STANDBY; i <= PM_SUSPEND_MEM; i++)		pm_states[i].state = valid_state(i) ? i : 0;	unlock_system_sleep();}

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

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

static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,			   const char *buf, size_t n){#ifdef CONFIG_SUSPEND#ifdef CONFIG_EARLYSUSPEND	suspend_state_t state = PM_SUSPEND_ON;#else	suspend_state_t state = PM_SUSPEND_STANDBY;#endif	const char * const *s;#endif	char *p;	int len;	int error = -EINVAL;	p = memchr(buf, '/n', n);	len = p ? p - buf : n;	/* First, check if we are requested to hibernate */	if (len == 4 && !strncmp(buf, "disk", len)) {		printk(KERN_ERR "entering hibernate");		error = hibernate();  goto Exit;	}#ifdef CONFIG_SUSPEND	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))			break;	}	printk(KERN_ERR "entering sleep state = %d/n", state);	if (state < PM_SUSPEND_MAX && *s)	{#ifdef CONFIG_EARLYSUSPEND		if (state == PM_SUSPEND_ON || valid_state(state)) {			error = 0;			request_suspend_state(state);		} else {			printk(KERN_ERR "not valid state with state = %d", state);		}#else		error = enter_state(state);#endif	}#endif Exit:	return error ? error : n;}

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

static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,			   const char *buf, size_t n){#ifdef CONFIG_SUSPEND#ifdef CONFIG_EARLYSUSPEND	suspend_state_t state = PM_SUSPEND_ON;#else	suspend_state_t state = PM_SUSPEND_STANDBY;#endif	const char * const *s;#endif	char *p;	int len;	int error = -EINVAL;	p = memchr(buf, '/n', n);	len = p ? p - buf : n;	/* First, check if we are requested to hibernate */	if (len == 4 && !strncmp(buf, "disk", len)) {		error = hibernate();  goto Exit;	}#ifdef CONFIG_SUSPEND	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))			break;	}	if (state < PM_SUSPEND_MAX && *s) {     /*LGE_CHANGE : [email
C++ valid_user_regs函数代码示例
C++ val_to_str_const函数代码示例