Lines Matching refs:state

164 static bool valid_state(suspend_state_t state)
171     return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
176     /* "mem" and "freeze" are always present in /sys/power/state. */
188     suspend_state_t state;
190     for (state = PM_SUSPEND_TO_IDLE; state <= PM_SUSPEND_MEM; state++) {
191         if (mem_sleep_labels[state] && !strcmp(str, mem_sleep_labels[state])) {
192             mem_sleep_default = state;
236 int suspend_valid_only_mem(suspend_state_t state)
238     return state == PM_SUSPEND_MEM;
242 static bool sleep_state_supported(suspend_state_t state)
244     return state == PM_SUSPEND_TO_IDLE || (suspend_ops && suspend_ops->enter);
247 static int platform_suspend_prepare(suspend_state_t state)
249     return state != PM_SUSPEND_TO_IDLE && suspend_ops->prepare ? suspend_ops->prepare() : 0;
252 static int platform_suspend_prepare_late(suspend_state_t state)
254     return state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->prepare ? s2idle_ops->prepare() : 0;
257 static int platform_suspend_prepare_noirq(suspend_state_t state)
259     if (state == PM_SUSPEND_TO_IDLE) {
266 static void platform_resume_noirq(suspend_state_t state)
268     if (state == PM_SUSPEND_TO_IDLE) {
277 static void platform_resume_early(suspend_state_t state)
279     if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->restore) {
284 static void platform_resume_finish(suspend_state_t state)
286     if (state != PM_SUSPEND_TO_IDLE && suspend_ops->finish) {
291 static int platform_suspend_begin(suspend_state_t state)
293     if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->begin) {
296         return suspend_ops->begin(state);
302 static void platform_resume_end(suspend_state_t state)
304     if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->end) {
311 static void platform_recover(suspend_state_t state)
313     if (state != PM_SUSPEND_TO_IDLE && suspend_ops->recover) {
318 static bool platform_suspend_again(suspend_state_t state)
320     return state != PM_SUSPEND_TO_IDLE && suspend_ops->suspend_again ? suspend_ops->suspend_again() : false;
342  * suspend_prepare - Prepare for entering system sleep state.
344  * Common code run for every system sleep state that can be entered (except for
348 static int suspend_prepare(suspend_state_t state)
352     if (!sleep_state_supported(state)) {
392  * suspend_enter - Make the system enter the given sleep state.
393  * @state: System sleep state to enter.
394  * @wakeup: Returns information that the sleep state should not be re-entered.
398 static int suspend_enter(suspend_state_t state, bool *wakeup)
402     error = platform_suspend_prepare(state);
415     error = platform_suspend_prepare_late(state);
428     error = platform_suspend_prepare_noirq(state);
437     if (state == PM_SUSPEND_TO_IDLE) {
457             trace_suspend_resume(TPS("machine_suspend"), state, true);
458             error = suspend_ops->enter(state);
459             trace_suspend_resume(TPS("machine_suspend"), state, false);
475     platform_resume_noirq(state);
479     platform_resume_early(state);
485     platform_resume_finish(state);
490  * suspend_devices_and_enter - Suspend devices and enter system sleep state.
491  * @state: System sleep state to enter.
493 int suspend_devices_and_enter(suspend_state_t state)
498     if (!sleep_state_supported(state)) {
502     pm_suspend_target_state = state;
504     if (state == PM_SUSPEND_TO_IDLE) {
508     error = platform_suspend_begin(state);
527         error = suspend_enter(state, &wakeup);
528     } while (!error && !wakeup && platform_suspend_again(state));
534     trace_suspend_resume(TPS("resume_console"), state, true);
536     trace_suspend_resume(TPS("resume_console"), state, false);
539     platform_resume_end(state);
544     platform_recover(state);
562  * enter_state - Do common work needed to enter system sleep state.
563  * @state: System sleep state to enter.
565  * Make sure that no one else is trying to put the system into a sleep state.
567  * system enter the given sleep state and clean up after wakeup.
569 static int enter_state(suspend_state_t state)
573     trace_suspend_resume(TPS("suspend_enter"), state, true);
574     if (state == PM_SUSPEND_TO_IDLE) {
581     } else if (!valid_state(state)) {
588     if (state == PM_SUSPEND_TO_IDLE) {
598     pm_pr_dbg("Preparing system for sleep (%s)\n", mem_sleep_labels[state]);
600     error = suspend_prepare(state);
609     trace_suspend_resume(TPS("suspend_enter"), state, false);
610     pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]);
612     error = suspend_devices_and_enter(state);
626  * @state: System sleep state to enter.
628  * Check if the value of @state represents one of the supported states,
631 int pm_suspend(suspend_state_t state)
635     if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX) {
639     pr_info("suspend entry (%s)\n", mem_sleep_labels[state]);
640     error = enter_state(state);