Re: [RFC 05/13] acpi/x86: s2idle: add modern standby transition function

[Mario Limonciello <mario.limonciello@amd.com>]

On 11/21/2024 11:22, Antheas Kapenekakis wrote:
> Add a new function to transition modern standby states and call it
> as part of the suspend sequence to make sure it begins under the
> Modern Standby "Sleep" state.
 > > Signed-off-by: Antheas Kapenekakis <lkml@antheas.dev>
> ---
>   include/linux/suspend.h |  11 ++++
>   kernel/power/power.h    |   1 +
>   kernel/power/suspend.c  | 127 ++++++++++++++++++++++++++++++++++++++++
>   3 files changed, 139 insertions(+)
> 
> diff --git a/include/linux/suspend.h b/include/linux/suspend.h
> index 01ee64321cda..b8fe781d8026 100644
> --- a/include/linux/suspend.h
> +++ b/include/linux/suspend.h
> @@ -40,6 +40,15 @@ typedef int __bitwise suspend_state_t;
>   #define PM_SUSPEND_MIN		PM_SUSPEND_TO_IDLE
>   #define PM_SUSPEND_MAX		((__force suspend_state_t) 4)
>   
> +typedef int __bitwise standby_state_t;

As this is series is working on emulating semantics of "Modern Standby" 
on Windows, why not name it all "modern_standby"?

IE

modern_standby_state_t
PM_MODERN_STANDBY_ACTIVE
PM_MODERN_STANDBY_SCREEN_OFF

> +
> +#define PM_STANDBY_ACTIVE		((__force standby_state_t) 0)
> +#define PM_STANDBY_SCREEN_OFF	((__force standby_state_t) 1)
> +#define PM_STANDBY_SLEEP		((__force standby_state_t) 2)
> +#define PM_STANDBY_RESUME		((__force standby_state_t) 3)
> +#define PM_STANDBY_MIN			PM_STANDBY_ACTIVE
> +#define PM_STANDBY_MAX			((__force standby_state_t) 4)
> +
>   /**
>    * struct platform_suspend_ops - Callbacks for managing platform dependent
>    *	system sleep states.
> @@ -281,6 +290,8 @@ extern void arch_suspend_enable_irqs(void);
>   
>   extern int pm_suspend(suspend_state_t state);
>   extern bool sync_on_suspend_enabled;
> +extern int pm_standby_transition(standby_state_t state);
> +extern int pm_standby_state(void);
>   #else /* !CONFIG_SUSPEND */
>   #define suspend_valid_only_mem	NULL
>   
> diff --git a/kernel/power/power.h b/kernel/power/power.h
> index de0e6b1077f2..4ee067cd0d4d 100644
> --- a/kernel/power/power.h
> +++ b/kernel/power/power.h
> @@ -207,6 +207,7 @@ extern void swsusp_show_speed(ktime_t, ktime_t, unsigned int, char *);
>   extern const char * const pm_labels[];
>   extern const char *pm_states[];
>   extern const char *mem_sleep_states[];
> +extern const char *standby_states[];
>   
>   extern int suspend_devices_and_enter(suspend_state_t state);
>   #else /* !CONFIG_SUSPEND */
> diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
> index a42e8514ee7a..1865db71a0c2 100644
> --- a/kernel/power/suspend.c
> +++ b/kernel/power/suspend.c
> @@ -45,12 +45,21 @@ static const char * const mem_sleep_labels[] = {
>   	[PM_SUSPEND_MEM] = "deep",
>   };
>   const char *mem_sleep_states[PM_SUSPEND_MAX];
> +static const char * const standby_labels[] = {
> +	[PM_STANDBY_ACTIVE] = "active",
> +	[PM_STANDBY_SCREEN_OFF] = "screen_off",
> +	[PM_STANDBY_SLEEP] = "sleep",
> +	[PM_STANDBY_RESUME] = "resume",
> +};
> +const char *standby_states[PM_STANDBY_MAX];
>   
>   suspend_state_t mem_sleep_current = PM_SUSPEND_TO_IDLE;
>   suspend_state_t mem_sleep_default = PM_SUSPEND_MAX;
>   suspend_state_t pm_suspend_target_state;
>   EXPORT_SYMBOL_GPL(pm_suspend_target_state);
>   
> +standby_state_t standby_current = PM_STANDBY_ACTIVE;
> +
>   unsigned int pm_suspend_global_flags;
>   EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
>   
> @@ -188,6 +197,16 @@ void __init pm_states_init(void)
>   	 * initialize mem_sleep_states[] accordingly here.
>   	 */
>   	mem_sleep_states[PM_SUSPEND_TO_IDLE] = mem_sleep_labels[PM_SUSPEND_TO_IDLE];
> +	/* All systems support the "active" state. */
> +	standby_states[PM_STANDBY_ACTIVE] = standby_labels[PM_STANDBY_ACTIVE];
> +	/*
> +	 * Not all systems support these states, where they will have increased
> +	 * power consumption. If deemed necessary, they should be gated to not
> +	 * mislead userspace.
> +	 */
> +	standby_states[PM_STANDBY_SCREEN_OFF] = standby_labels[PM_STANDBY_SCREEN_OFF];
> +	standby_states[PM_STANDBY_SLEEP] = standby_labels[PM_STANDBY_SLEEP];
> +	standby_states[PM_STANDBY_RESUME] = standby_labels[PM_STANDBY_RESUME];

Shouldn't these states only be enabled when LPS0 support was found?  IE 
shouldn't they be enabled by acpi_register_lps0_dev() and disabled by 
acpi_unregister_lps0_dev()

>   }
>   
>   static int __init mem_sleep_default_setup(char *str)
> @@ -354,6 +373,108 @@ static bool platform_suspend_again(suspend_state_t state)
>   		suspend_ops->suspend_again() : false;
>   }
>   
> +static int platform_standby_transition_internal(standby_state_t state)
> +{
> +	int error;
> +
> +	if (state == standby_current)
> +		return 0;
> +	if (state > PM_STANDBY_MAX)
> +		return -EINVAL;
> +
> +	pm_pr_dbg("Transitioning from standby state %s to %s\n",
> +		  standby_states[standby_current], standby_states[state]);
> +
> +	/* Resume can only be entered if we are on the sleep state. */
> +	if (state == PM_STANDBY_RESUME) {
> +		if (standby_current != PM_STANDBY_SLEEP)
> +			return -EINVAL;
> +		standby_current = PM_STANDBY_RESUME;
> +		return platform_standby_turn_on_display();
> +	}
> +
> +	/*
> +	 * The system should not be able to re-enter Sleep from resume as it
> +	 * is undefined behavior. As part of setting the state to "Resume",
> +	 * were promised a transition to "Screen Off" or "Active".
> +	 */
> +	if (standby_current == PM_STANDBY_RESUME && state == PM_STANDBY_SLEEP)
> +		return -EINVAL;
> +
> +	/* Resume is the Sleep state logic-wise. */
> +	if (standby_current == PM_STANDBY_RESUME)
> +		standby_current = PM_STANDBY_SLEEP;
> +
> +	if (standby_current < state) {
> +		for (; standby_current < state; standby_current++) {
> +			switch (standby_current + 1) {
> +			case PM_STANDBY_SCREEN_OFF:
> +				error = platform_standby_display_off();
> +				break;
> +			case PM_STANDBY_SLEEP:
> +				error = platform_standby_sleep_entry();
> +				break;
> +			}
> +
> +			if (error)
> +				return error;
> +		}
> +	} else if (standby_current > state) {
> +		for (; standby_current > state; standby_current--) {
> +			switch (standby_current) {
> +			case PM_STANDBY_SLEEP:
> +				error = platform_standby_sleep_exit();
> +				break;
> +			case PM_STANDBY_SCREEN_OFF:
> +				error = platform_standby_display_on();
> +				break;
> +			}
> +
> +			if (error)
> +				return error;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +/**
> + * pm_standby_transition - Transition between Modern Standby states
> + *
> + * Fires the appropriate firmware notifications to transition to the requested
> + * state. Returns an error if the transition fails. The function does not
> + * rollback. It is up to userspace to handle the error and re-transition when
> + * appropriate.
> + */
> +int pm_standby_transition(standby_state_t state)
> +{
> +	unsigned int sleep_flags;
> +	int error;
> +
> +	sleep_flags = lock_system_sleep();
> +	error = platform_standby_transition_internal(state);
> +	unlock_system_sleep(sleep_flags);
> +
> +	return error;
> +}
> +EXPORT_SYMBOL_GPL(pm_standby_transition);
> +
> +/**
> + * pm_standby_state - Returns the current standby state
> + */
> +int pm_standby_state(void)
> +{
> +	unsigned int sleep_flags;
> +	int state;
> +
> +	sleep_flags = lock_system_sleep();
> +	state = standby_current;
> +	unlock_system_sleep(sleep_flags);
> +
> +	return state;
> +}
> +EXPORT_SYMBOL_GPL(pm_standby_state);
> +
>   #ifdef CONFIG_PM_DEBUG
>   static unsigned int pm_test_delay = 5;
>   module_param(pm_test_delay, uint, 0644);
> @@ -586,6 +707,7 @@ static void suspend_finish(void)
>   static int enter_state(suspend_state_t state)
>   {
>   	int error;
> +	standby_state_t standby_prior;
>   
>   	trace_suspend_resume(TPS("suspend_enter"), state, true);
>   	if (state == PM_SUSPEND_TO_IDLE) {
> @@ -601,6 +723,9 @@ static int enter_state(suspend_state_t state)
>   	if (!mutex_trylock(&system_transition_mutex))
>   		return -EBUSY;
>   
> +	standby_prior = standby_current;
> +	platform_standby_transition_internal(PM_STANDBY_SLEEP);
> +
>   	if (state == PM_SUSPEND_TO_IDLE)
>   		s2idle_begin();
>   
> @@ -630,6 +755,8 @@ static int enter_state(suspend_state_t state)
>   	pm_pr_dbg("Finishing wakeup.\n");
>   	suspend_finish();
>    Unlock:
> +	platform_standby_transition_internal(standby_prior);
> +
>   	mutex_unlock(&system_transition_mutex);
>   	return error;
>   }