/**
* 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]);
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);
#ifdef CONFIG_SUSPEND_WATCHDOG
extern void disable_watchdog(void);
disable_watchdog();
#endif
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 (!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");
#ifdef CONFIG_MACH_LGE
start_monitor_blocking(suspend_monitor_id,
jiffies + usecs_to_jiffies(3000000));
#endif
suspend_finish();
#ifdef CONFIG_MACH_LGE
end_monitor_blocking(suspend_monitor_id);
#endif
Unlock:
mutex_unlock(&pm_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 (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
#ifdef CONFIG_PERFLOCK_SUSPEND_LOCK
shsys_enter_state_perf_lock();
#endif
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:
#ifdef CONFIG_PERFLOCK_SUSPEND_LOCK
shsys_enter_state_perf_unlock();
#endif
mutex_unlock(&pm_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 (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
#ifdef CONFIG_HUAWEI_KERNEL
printk(KERN_INFO "PM: Syncing filesystems put the sync in the queue... ");
suspend_sys_sync_queue();
printk("put it done.\n");
#else
printk(KERN_INFO "PM: Syncing filesystems ... ");
sys_sync();
printk("done.\n");
#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:
mutex_unlock(&pm_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 (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
if (state == PM_SUSPEND_FREEZE)
freeze_begin();
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(state);
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;
}
/**
* 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;
suspend_footprint = 3;
suspend_sys_sync_queue();
suspend_footprint = 4;
pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
error = suspend_prepare();
if (error)
goto Unlock;
suspend_footprint = 10;
if (suspend_test(TEST_FREEZER))
goto Finish;
suspend_footprint = 11;
pr_debug("PM: Entering %s sleep\n", pm_states[state]);
pm_restrict_gfp_mask();
suspend_footprint = 12;
error = suspend_devices_and_enter(state);
suspend_footprint = 13;
pm_restore_gfp_mask();
suspend_footprint = 14;
Finish:
pr_debug("PM: Finishing wakeup.\n");
suspend_finish();
suspend_footprint = 18;
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;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
//20110727 [email protected] Patch applied from P990 froyo MR-03
printk("[LOG] star_emergency_restart() called at enter_state() \n");
star_emergency_restart("sys", 63);
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;
}
int enter_state(suspend_state_t state)
{
int error;
int dock=0;
int retries=3;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
printk(KERN_INFO "PM: Syncing filesystems ... ");
sys_sync();
printk("done.\n");
#ifdef CONFIG_ASUSEC
if (gpio_get_value(TEGRA_GPIO_PX5)==0){
dock=1;
hub_suspended=0;
//// nousb=1;
// printk("mutex+\n");
// mutex_lock(&usb_mutex);
if (nousb==1) {
printk("usb wait1\n");
msleep(500);
}
asusec_close_keyboard();
//// asusec_suspend_hub_callback2();
/* while (!hub_suspended) {
asusec_suspend_hub_callback();
if (retries-- == 0)
break;
if (!hub_suspended) {
stop_dock();
msleep(500);
asusec_resume(0);
msleep(500);
// printk("try to restart asusec\n");
// reload_asusec();
}
}
*/
// printk("mutex-\n");
// mutex_unlock(&usb_mutex);
/*
if (!hub_suspended) {
stop_dock();
printk("Dock problem\n");
if (failed_dock < 3) {
printk("aborted suspend\n");
failed_dock++;
asusec_resume(0);
error=999;
// nousb=0;
goto Unlock;
}
}
*/
// nousb=0;
failed_dock=0;
msleep(2000);
// cpu_down(1);
}
#endif
pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
error = suspend_prepare();
if (error) {
if (dock==1) {
asusec_resume(0);
}
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:
// asusec_resume(0);
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).
*/
static int enter_state(suspend_state_t state)
{
int error;
extern unsigned long set1_gpio;
extern unsigned long set2_gpio;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
#ifdef CONFIG_CPU_FREQ
#ifdef SLEEP_CPUFREQ_CONSERVATIVE
// change cpufreq governor to performance
// if conservative governor
#ifdef SLEEP_CPUFREQ_MANUAL_SET
if(is_userspace_gov())
{
g_cpuspeed = s5pc110_getspeed(0);
printk("userspace cpu speed %d \n",g_cpuspeed);
userSpaceGovernor=true;
}
else if(is_conservative_gov())
{
s5pc110_lock_dvfs_high_level(DVFS_LOCK_TOKEN_5, 0);
gbGovernorTransition=true;
}
#else//SLEEP_CPUFREQ_MANUAL_SET
if(is_conservative_gov()) {
s5pc110_lock_dvfs_high_level(DVFS_LOCK_TOKEN_5, 0);
gbGovernorTransition = true;
gpio_set_value(set2_gpio, 0);
gpio_set_value(set1_gpio, 1);
}
#endif//SLEEP_CPUFREQ_MANUAL_SET
#else//SLEEP_CPUFREQ_CONSERVATIVE
cpufreq_direct_set_policy(0, "userspace");
cpufreq_direct_store_scaling_setspeed(0, "800000", 0);
#endif//SLEEP_CPUFREQ_CONSERVATIVE
#endif//CONFIG_CPU_FREQ
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);
#ifdef CONFIG_CPU_FREQ
#ifdef SLEEP_CPUFREQ_CONSERVATIVE
#ifdef SLEEP_CPUFREQ_MANUAL_SET
if(userSpaceGovernor)
{
s5pc110_pm_target(g_cpuspeed);
printk("recover userspace cpu speed %d \n",g_cpuspeed);
g_cpuspeed=0;
userSpaceGovernor=false;
}
if(gbGovernorTransition)
{
s5pc110_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_5);
gbGovernorTransition=false;
}
#else//SLEEP_CPUFREQ_MANUAL_SET
// change cpufreq to original one
if(gbGovernorTransition) {
s5pc110_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_5);
gbGovernorTransition = false;
}
#endif//SLEEP_CPUFREQ_MANUAL_SET
#else//SLEEP_CPUFREQ_CONSERVATIVE
cpufreq_direct_set_policy(0, "conservative");
#endif//SLEEP_CPUFREQ_CONSERVATIVE
#endif//CONFIG_CPU_FREQ
return error;
}
int enter_state(suspend_state_t state)
{
int error;
struct cpufreq_policy policy;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
#ifdef CONFIG_CPU_FREQ
#if 1
// change cpufreq governor to performance
// if conservative governor
if(is_userspace_gov())
{
g_cpuspeed = s5pc110_getspeed(0);
printk("userspace cpu speed %d \n",g_cpuspeed);
userSpaceGovernor=true;
} else if(is_conservative_gov()) {
/*Fix the upper transition scaling*/
g_dvfs_fix_lock_limit = true;
#if MAXIMUM_FREQ == 1200000
s5pc110_lock_dvfs_high_level(DVFS_LOCK_TOKEN_7, LEV_800MHZ);
#else
s5pc110_lock_dvfs_high_level(DVFS_LOCK_TOKEN_7, LEV_832MHZ);
#endif
gbClockFix = true;
error = cpufreq_get_policy(&policy, 0);
if(error)
{
printk("Failed to get policy\n");
goto Unlock;
}
cpufreq_driver_target(&policy, 800000, CPUFREQ_RELATION_L);
}
#else
// cpufreq_direct_set_policy(0, "userspace");
// cpufreq_direct_store_scaling_setspeed(0, "800000", 0);
#endif
#endif
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);
#ifdef CONFIG_CPU_FREQ
#if 1
if(userSpaceGovernor)
{
s5pc110_pm_target(g_cpuspeed);
printk("recover userspace cpu speed %d \n",g_cpuspeed);
g_cpuspeed=0;
userSpaceGovernor=false;
}
// change cpufreq to original one
if(gbClockFix) {
g_dvfs_fix_lock_limit = false;
s5pc110_unlock_dvfs_high_level(DVFS_LOCK_TOKEN_7);
gbClockFix = false;
}
#else
// cpufreq_direct_set_policy(0, "conservative");
#endif
#endif
return error;
}
