/** * 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; gfp_t saved_mask; struct device l3_dev; if (!suspend_ops) return -ENOSYS; if (suspend_ops->begin) { error = suspend_ops->begin(state); if (error) goto Close; } suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); 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; //omap_pm_set_min_bus_tput(&l3_dev, OCP_INITIATOR_AGENT, 100 * 1000 * 4); // sookyoung.kim suspend_enter(state); //omap_pm_set_min_bus_tput(&l3_dev, OCP_INITIATOR_AGENT, 200 * 1000 * 4); // sookyoung.kim Resume_devices: suspend_test_start(); dpm_resume_end(PMSG_RESUME); // LGE_UPDATE_S #if defined(CONFIG_WAKE_IRQ_PRINT) wakeup_irq_record_print(); #endif // LGE_UPDATE_E suspend_test_finish("resume devices"); set_gfp_allowed_mask(saved_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; }
/** * 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; gfp_t saved_mask; if (!suspend_ops) return -ENOSYS; if (suspend_ops->begin) { error = suspend_ops->begin(state); if (error) goto Close; } suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); 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)) { printk(KERN_ERR "PM: suspend test failed\n"); goto Recover_platform; } suspend_enter(state); Resume_devices: suspend_test_start(); dpm_resume_end(PMSG_RESUME); suspend_test_finish("resume devices"); set_gfp_allowed_mask(saved_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; }
int hibernation_restore(int platform_mode) { int error; gfp_t saved_mask; pm_prepare_console(); suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); error = dpm_suspend_start(PMSG_QUIESCE); if (!error) { error = resume_target_kernel(platform_mode); dpm_resume_end(PMSG_RECOVER); } set_gfp_allowed_mask(saved_mask); resume_console(); pm_restore_console(); return error; }
int hibernation_snapshot(int platform_mode) { int error; gfp_t saved_mask; error = platform_begin(platform_mode); if (error) return error; /* Preallocate image memory before shutting down devices. */ error = hibernate_preallocate_memory(); if (error) goto Close; suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); error = dpm_suspend_start(PMSG_FREEZE); if (error) goto Recover_platform; if (hibernation_test(TEST_DEVICES)) goto Recover_platform; error = create_image(platform_mode); /* Control returns here after successful restore */ Resume_devices: /* We may need to release the preallocated image pages here. */ if (error || !in_suspend) swsusp_free(); dpm_resume_end(in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE); set_gfp_allowed_mask(saved_mask); resume_console(); Close: platform_end(platform_mode); return error; Recover_platform: platform_recover(platform_mode); goto Resume_devices; }
int hibernation_platform_enter(void) { int error; gfp_t saved_mask; if (!hibernation_ops) return -ENOSYS; /* * We have cancelled the power transition by running * hibernation_ops->finish() before saving the image, so we should let * the firmware know that we're going to enter the sleep state after all */ error = hibernation_ops->begin(); if (error) goto Close; entering_platform_hibernation = true; suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); error = dpm_suspend_start(PMSG_HIBERNATE); if (error) { if (hibernation_ops->recover) hibernation_ops->recover(); goto Resume_devices; } error = dpm_suspend_noirq(PMSG_HIBERNATE); if (error) goto Resume_devices; error = hibernation_ops->prepare(); if (error) goto Platform_finish; error = disable_nonboot_cpus(); if (error) goto Platform_finish; local_irq_disable(); sysdev_suspend(PMSG_HIBERNATE); if (!pm_check_wakeup_events()) { error = -EAGAIN; goto Power_up; } hibernation_ops->enter(); /* We should never get here */ while (1); Power_up: sysdev_resume(); local_irq_enable(); enable_nonboot_cpus(); Platform_finish: hibernation_ops->finish(); dpm_suspend_noirq(PMSG_RESTORE); Resume_devices: entering_platform_hibernation = false; dpm_resume_end(PMSG_RESTORE); set_gfp_allowed_mask(saved_mask); resume_console(); Close: hibernation_ops->end(); return error; }
/** * 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; gfp_t saved_mask; if (!suspend_ops) return -ENOSYS; if (suspend_ops->begin) { error = suspend_ops->begin(state); if (error) goto Close; } #if 1 { struct timespec ts; struct rtc_time tm; long elasped_time=0L; int capa = get_bat_soc(); // battery capa get int volt = get_bat_volt(); // fuel gage volt getnstimeofday(&ts); rtc_time_to_tm(ts.tv_sec, &tm); //printk("%s:", __func__); elasped_time=ts.tv_sec-old_ts.tv_sec; printk("([elasped_time=%ldsec, suspend]%d-%02d-%02d %02d:%02d:%02d.%09lu UTC, battery capa=%d, volt=%d)\n", elasped_time, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec, capa, volt); old_ts = ts; } #endif suspend_console(); saved_mask = clear_gfp_allowed_mask(GFP_IOFS); 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); suspend_test_finish("resume devices"); set_gfp_allowed_mask(saved_mask); resume_console(); #if 1 { struct timespec ts; struct rtc_time tm; int capa = get_bat_soc(); // battery capa get int volt = get_bat_volt(); // fuel gage volt getnstimeofday(&ts); long elasped_time=0L; elasped_time=ts.tv_sec-old_ts.tv_sec; rtc_time_to_tm(ts.tv_sec, &tm); //printk("%s:", __func__); printk("\n([elasped_time=%ldsec, resume]%d-%02d-%02d %02d:%02d:%02d.%09lu UTC, battery capa=%d, volt=%d)\n", elasped_time, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec, capa, volt); old_ts = ts; } #endif Close: if (suspend_ops->end) suspend_ops->end(); return error; Recover_platform: if (suspend_ops->recover) suspend_ops->recover(); goto Resume_devices; }