/** * 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; } 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 - 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) return error; } error = dpm_suspend_noirq(PMSG_SUSPEND); if (error) { printk(KERN_ERR "PM: Some devices failed to power down\n"); goto Platfrom_finish; } if (suspend_ops->prepare_late) { error = suspend_ops->prepare_late(); if (error) goto Power_up_devices; } 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 = sysdev_suspend(PMSG_SUSPEND); if (!error) { if (!suspend_test(TEST_CORE)) error = suspend_ops->enter(state); /* Workaround for possible L2 cache coherency issue where preempt_count remains zero */ preempt_count() = 0; sysdev_resume(); } arch_suspend_enable_irqs(); BUG_ON(irqs_disabled()); Enable_cpus: enable_nonboot_cpus(); Platform_wake: if (suspend_ops->wake) suspend_ops->wake(); Power_up_devices: dpm_resume_noirq(PMSG_RESUME); Platfrom_finish: if (suspend_ops->finish) suspend_ops->finish(); return error; }
/* power off whole system, save user data to flash before call this func. * BE SUURE: all hardware has been closed and it's prcm config setted to default value. * @type:0:shutdown, 1:reboot */ static void pm_power_off(pm_operate_t type) { __record_dbg_status(PM_POWEROFF | 0); if (type == PM_REBOOT) { PM_REBOOT(); /* never return */ } #ifdef __CONFIG_ARCH_APP_CORE /* step 1 & 2 has been done when wlan sys poweroff */ /* step3: writel(0x0f, GPRCM_SYS1_WAKEUP_CTRL) to tell PMU that turn on * SW1, SW2, SRSW1, LDO before release application system reset signal. */ HAL_PRCM_SetSys1WakeupPowerFlags(0x0f); __record_dbg_status(PM_POWEROFF | 5); /* step4: writel(0x0f, GPRCM_SYS1_SLEEP_CTRL) to tell PMU that turn off SW1, * SW3 SRSW1, LDO after pull down application system reset signal. */ HAL_PRCM_SetSys1SleepPowerFlags(0x0f); __record_dbg_status(PM_POWEROFF | 7); /* step5: switch to HOSC, close SYS1_CLK. */ PM_SystemDeinit(); __record_dbg_status(PM_POWEROFF | 9); /* step6: set nvic deepsleep flag, and enter wfe. */ SCB->SCR = 0x14; PM_SetCPUBootFlag(0); __disable_fault_irq(); __disable_irq(); if (check_wakeup_irqs()) { PM_REBOOT(); } wfe(); if (check_wakeup_irqs()) { PM_REBOOT(); } wfe(); /* some irq generated when second wfe */ PM_REBOOT(); __record_dbg_status(PM_POWEROFF | 0x0ff); #else /* net cpu */ /* check wifi is closed by app? */ PM_WARN_ON(HAL_PRCM_IsSys3Release()); /* step1: cpu to switch to HOSC */ HAL_PRCM_SetCPUNClk(PRCM_CPU_CLK_SRC_HFCLK, PRCM_SYS_CLK_FACTOR_80M); __record_dbg_status(PM_POWEROFF | 1); /* step2: turn off SYSCLK2. */ HAL_PRCM_DisableSysClk2(PRCM_SYS_CLK_FACTOR_80M); __record_dbg_status(PM_POWEROFF | 3); PM_SystemDeinit(); /* step3: enter WFI state */ arch_suspend_disable_irqs(); while (1) wfi(); __record_dbg_status(PM_POWEROFF | 0x0ff); #endif }
/** * 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("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) { pr_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; } else if (*wakeup) { 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: dpm_resume_early(PMSG_RESUME); Platform_finish: platform_resume_finish(state); return error; }
/* * Exported to Kernel/Platform PM - * It will fail only when some pending wakeup source is detected. * This op may enable irq, so we should recover it if needed. */ int pasr_enter(u32 *sr, u32 *dpd) { enum mtkpasr_phase result; int ret = 0; int irq_disabled = 0; /* MTKPASR_FLUSH -> drain_all_pages -> on_each_cpu_mask will enable local irq */ IS_MTKPASR_ENABLED; /* Check whether we are in irq-disabled environment */ if (irqs_disabled()) { irq_disabled = 1; } ++mtkpasr_triggered; /* It will go to MTKPASR stage */ current->flags |= PF_MTKPASR | PF_SWAPWRITE; MTKPASR_START_PROFILE(); /* RAM-to-RAM compression - State change: MTKPASR_OFF -> MTKPASR_ENTERING -> MTKPASR_DISABLINGSR */ result = mtkpasr_entering(); MTKPASR_END_PROFILE(); /* It will leave MTKPASR stage */ current->flags &= ~(PF_MTKPASR | PF_SWAPWRITE); /* Any pending wakeup source? */ if (result == MTKPASR_GET_WAKEUP) { mtkpasr_restoring(); mtkpasr_err("PM: Failed to enter MTKPASR\n"); ++failed_mtkpasr; ret = -1; goto out; } else if (result == MTKPASR_WRONG_STATE) { mtkpasr_reset_state(); mtkpasr_err("Wrong state!\n"); ++failed_mtkpasr; goto out; } MTKPASR_START_PROFILE(); /* SR-Off/DPD - Check which banks/ranks can enter PASR/DPD - State change:MTKPASR_DISABLINGSR -> MTKPASR_ON (-> MTKPASR_DPD_ON) */ result = mtkpasr_disablingSR(sr, dpd); mtkpasr_sroff = *sr; mtkpasr_dpd = *dpd; MTKPASR_END_PROFILE(); /* To mask some banks */ set_mtkpasr_triggered(); *sr = *sr & mtkpasr_control; if (result == MTKPASR_GET_WAKEUP) { mtkpasr_restoring(); mtkpasr_err("PM: Failed to enter SR_OFF/DPD\n"); ++failed_mtkpasr; ret = -1; goto out; } else if (result == MTKPASR_WRONG_STATE) { mtkpasr_reset_state(); mtkpasr_err("Wrong state!\n"); ++failed_mtkpasr; } out: /* Recover it to irq-disabled environment if needed */ if (irq_disabled == 1) { if (!irqs_disabled()) { mtkpasr_log("IRQ is enabled! To disable it here!\n"); arch_suspend_disable_irqs(); } } return ret; }
/** * 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; #ifdef CONFIG_SEC_GPIO_DVS /************************ Caution !!! ****************************/ /* This function must be located in appropriate SLEEP position * in accordance with the specification of each BB vendor. */ /************************ Caution !!! ****************************/ gpio_dvs_check_sleepgpio(); #ifdef SECGPIO_SLEEP_DEBUGGING /************************ Caution !!! ****************************/ /* This func. must be located in an appropriate position for GPIO SLEEP debugging * in accordance with the specification of each BB vendor, and * the func. must be called after calling the function "gpio_dvs_check_sleepgpio" */ /************************ Caution !!! ****************************/ gpio_dvs_set_sleepgpio(); #endif #endif 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)) { error = suspend_ops->enter(state); events_check_enabled = false; } syscore_resume(); } #if defined(CONFIG_SEC_GPIO_DVS) && defined(SECGPIO_SLEEP_DEBUGGING) /************************ Caution !!! ****************************/ /* This function must be located in an appropriate position * to undo gpio SLEEP debugging setting when DUT wakes up. * It should be implemented in accordance with the specification of each BB vendor. */ /************************ Caution !!! ****************************/ gpio_dvs_undo_sleepgpio(); #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_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 = sysdev_suspend(PMSG_SUSPEND); if (!error) error = syscore_suspend(); if (!error) { if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) { error = suspend_ops->enter(state); events_check_enabled = false; } syscore_resume(); sysdev_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_noirq(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) return error; } #ifdef DEVICE_SUPPORT_SUSPEND_NO_IRQ error = dpm_suspend_noirq(PMSG_SUSPEND); if (error) { printk(KERN_ERR "PM: Some devices failed to power down\n"); goto Platfrom_finish; } #endif if (suspend_ops->prepare_late) { error = suspend_ops->prepare_late(); if (error) goto Power_up_devices; } 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 = sysdev_suspend(PMSG_SUSPEND); if (!error) { if (!suspend_test(TEST_CORE)) error = suspend_ops->enter(state); sysdev_resume(); } #ifdef CONFIG_SCREEN_ON_EARLY if(check_power_key_pressing()){ amvideo_class_resume_early(); vout_pll_resume_early(); osd_resume_early(); resume_vout_early(); } #endif arch_suspend_enable_irqs(); BUG_ON(irqs_disabled()); Enable_cpus: enable_nonboot_cpus(); Platform_wake: if (suspend_ops->wake) suspend_ops->wake(); Power_up_devices: #ifdef DEVICE_SUPPORT_SUSPEND_NO_IRQ dpm_resume_noirq(PMSG_RESUME); #endif Platfrom_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()); 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_EDIT Resume_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) { 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: 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) { 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; }
/** * 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; /* #ifdef CONFIG_CPU_FREQ dvfs_set_max_freq_lock(); #endif */ /* CONFIG_CPU_FREQ */ if (suspend_ops->prepare) { error = suspend_ops->prepare(); if (error) return error; } error = dpm_suspend_noirq(PMSG_SUSPEND); if (error) { printk(KERN_ERR "PM: Some devices failed to power down\n"); goto Platfrom_finish; } if (suspend_ops->prepare_late) { error = suspend_ops->prepare_late(); if (error) goto Power_up_devices; } 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 = sysdev_suspend(PMSG_SUSPEND); if (!error) { if (!suspend_test(TEST_CORE)) error = suspend_ops->enter(state); sysdev_resume(); } arch_suspend_enable_irqs(); BUG_ON(irqs_disabled()); /*#ifdef CONFIG_CPU_FREQ dvfs_set_max_freq_unlock(); #endif*/ /* CONFIG_CPU_FREQ */ Enable_cpus: enable_nonboot_cpus(); Platform_wake: if (suspend_ops->wake) suspend_ops->wake(); Power_up_devices: dpm_resume_noirq(PMSG_RESUME); Platfrom_finish: if (suspend_ops->finish) suspend_ops->finish(); return error; }