[deliverable/linux.git] / arch / sh / kernel / cpu / shmobile / cpuidle.c

/*
 * arch/sh/kernel/cpu/shmobile/cpuidle.c
 *
 * Cpuidle support code for SuperH Mobile
 *
 *  Copyright (C) 2009 Magnus Damm
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/suspend.h>
#include <linux/cpuidle.h>
#include <asm/suspend.h>
#include <asm/uaccess.h>
#include <asm/hwblk.h>

static unsigned long cpuidle_mode[] = {
	SUSP_SH_SLEEP, /* regular sleep mode */
	SUSP_SH_SLEEP | SUSP_SH_SF, /* sleep mode + self refresh */
	SUSP_SH_STANDBY | SUSP_SH_SF, /* software standby mode + self refresh */
};

static int cpuidle_sleep_enter(struct cpuidle_device *dev,
				int index)
{
	unsigned long allowed_mode = arch_hwblk_sleep_mode();
	ktime_t before, after;
	int requested_state = index;
	int allowed_state;
	int k;

	/* convert allowed mode to allowed state */
	for (k = ARRAY_SIZE(cpuidle_mode) - 1; k > 0; k--)
		if (cpuidle_mode[k] == allowed_mode)
			break;

	allowed_state = k;

	/* take the following into account for sleep mode selection:
	 * - allowed_state: best mode allowed by hardware (clock deps)
	 * - requested_state: best mode allowed by software (latencies)
	 */
	k = min_t(int, allowed_state, requested_state);

	before = ktime_get();
	sh_mobile_call_standby(cpuidle_mode[k]);
	after = ktime_get();

	dev->last_residency = (int)ktime_to_ns(ktime_sub(after, before)) >> 10;

	return k;
}

static struct cpuidle_device cpuidle_dev;
static struct cpuidle_driver cpuidle_driver = {
	.name =		"sh_idle",
	.owner =	THIS_MODULE,
};

void sh_mobile_setup_cpuidle(void)
{
	struct cpuidle_device *dev = &cpuidle_dev;
	struct cpuidle_state *state;
	int i;

	cpuidle_register_driver(&cpuidle_driver);

	for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
		dev->states[i].name[0] = '\0';
		dev->states[i].desc[0] = '\0';
	}

	i = CPUIDLE_DRIVER_STATE_START;

	state = &dev->states[i++];
	snprintf(state->name, CPUIDLE_NAME_LEN, "C1");
	strncpy(state->desc, "SuperH Sleep Mode", CPUIDLE_DESC_LEN);
	state->exit_latency = 1;
	state->target_residency = 1 * 2;
	state->power_usage = 3;
	state->flags = 0;
	state->flags |= CPUIDLE_FLAG_TIME_VALID;
	state->enter = cpuidle_sleep_enter;

	dev->safe_state_index = i-1;

	if (sh_mobile_sleep_supported & SUSP_SH_SF) {
		state = &dev->states[i++];
		snprintf(state->name, CPUIDLE_NAME_LEN, "C2");
		strncpy(state->desc, "SuperH Sleep Mode [SF]",
			CPUIDLE_DESC_LEN);
		state->exit_latency = 100;
		state->target_residency = 1 * 2;
		state->power_usage = 1;
		state->flags = 0;
		state->flags |= CPUIDLE_FLAG_TIME_VALID;
		state->enter = cpuidle_sleep_enter;
	}

	if (sh_mobile_sleep_supported & SUSP_SH_STANDBY) {
		state = &dev->states[i++];
		snprintf(state->name, CPUIDLE_NAME_LEN, "C3");
		strncpy(state->desc, "SuperH Mobile Standby Mode [SF]",
			CPUIDLE_DESC_LEN);
		state->exit_latency = 2300;
		state->target_residency = 1 * 2;
		state->power_usage = 1;
		state->flags = 0;
		state->flags |= CPUIDLE_FLAG_TIME_VALID;
		state->enter = cpuidle_sleep_enter;
	}

	dev->state_count = i;

	cpuidle_register_device(dev);
}
Commit	Line	Data
7426394f MD	1	/*
	2	* arch/sh/kernel/cpu/shmobile/cpuidle.c
	3	*
	4	* Cpuidle support code for SuperH Mobile
	5	*
	6	* Copyright (C) 2009 Magnus Damm
	7	*
	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file "COPYING" in the main directory of this archive
	10	* for more details.
	11	*/
	12	#include <linux/init.h>
	13	#include <linux/kernel.h>
	14	#include <linux/io.h>
	15	#include <linux/suspend.h>
	16	#include <linux/cpuidle.h>
	17	#include <asm/suspend.h>
	18	#include <asm/uaccess.h>
	19	#include <asm/hwblk.h>
	20
	21	static unsigned long cpuidle_mode[] = {
	22	SUSP_SH_SLEEP, /* regular sleep mode */
	23	SUSP_SH_SLEEP \| SUSP_SH_SF, /* sleep mode + self refresh */
63cd91df	24	SUSP_SH_STANDBY \| SUSP_SH_SF, /* software standby mode + self refresh */
7426394f MD	25	};
	26
	27	static int cpuidle_sleep_enter(struct cpuidle_device *dev,
e978aa7d	28	int index)
7426394f MD	29	{
	30	unsigned long allowed_mode = arch_hwblk_sleep_mode();
	31	ktime_t before, after;
e978aa7d	32	int requested_state = index;
7426394f MD	33	int allowed_state;
	34	int k;
	35
	36	/* convert allowed mode to allowed state */
	37	for (k = ARRAY_SIZE(cpuidle_mode) - 1; k > 0; k--)
	38	if (cpuidle_mode[k] == allowed_mode)
	39	break;
	40
	41	allowed_state = k;
	42
	43	/* take the following into account for sleep mode selection:
	44	* - allowed_state: best mode allowed by hardware (clock deps)
	45	* - requested_state: best mode allowed by software (latencies)
	46	*/
	47	k = min_t(int, allowed_state, requested_state);
	48
7426394f MD	49	before = ktime_get();
	50	sh_mobile_call_standby(cpuidle_mode[k]);
	51	after = ktime_get();
e978aa7d DD	52
	53	dev->last_residency = (int)ktime_to_ns(ktime_sub(after, before)) >> 10;
	54
	55	return k;
7426394f MD	56	}
	57
	58	static struct cpuidle_device cpuidle_dev;
	59	static struct cpuidle_driver cpuidle_driver = {
	60	.name = "sh_idle",
	61	.owner = THIS_MODULE,
	62	};
	63
	64	void sh_mobile_setup_cpuidle(void)
	65	{
	66	struct cpuidle_device *dev = &cpuidle_dev;
	67	struct cpuidle_state *state;
	68	int i;
	69
	70	cpuidle_register_driver(&cpuidle_driver);
	71
	72	for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
	73	dev->states[i].name[0] = '\0';
	74	dev->states[i].desc[0] = '\0';
	75	}
	76
	77	i = CPUIDLE_DRIVER_STATE_START;
	78
	79	state = &dev->states[i++];
c1d0df34	80	snprintf(state->name, CPUIDLE_NAME_LEN, "C1");
7426394f MD	81	strncpy(state->desc, "SuperH Sleep Mode", CPUIDLE_DESC_LEN);
	82	state->exit_latency = 1;
	83	state->target_residency = 1 * 2;
	84	state->power_usage = 3;
	85	state->flags = 0;
7426394f MD	86	state->flags \|= CPUIDLE_FLAG_TIME_VALID;
	87	state->enter = cpuidle_sleep_enter;
	88
e978aa7d	89	dev->safe_state_index = i-1;
7426394f	90
02bf8934 MD	91	if (sh_mobile_sleep_supported & SUSP_SH_SF) {
02bf8934 MD	92	state = &dev->states[i++];
c1d0df34	93	snprintf(state->name, CPUIDLE_NAME_LEN, "C2");
02bf8934 MD	94	strncpy(state->desc, "SuperH Sleep Mode [SF]",
	95	CPUIDLE_DESC_LEN);
	96	state->exit_latency = 100;
	97	state->target_residency = 1 * 2;
	98	state->power_usage = 1;
	99	state->flags = 0;
	100	state->flags \|= CPUIDLE_FLAG_TIME_VALID;
	101	state->enter = cpuidle_sleep_enter;
	102	}
7426394f	103
02bf8934 MD	104	if (sh_mobile_sleep_supported & SUSP_SH_STANDBY) {
02bf8934 MD	105	state = &dev->states[i++];
c1d0df34	106	snprintf(state->name, CPUIDLE_NAME_LEN, "C3");
02bf8934 MD	107	strncpy(state->desc, "SuperH Mobile Standby Mode [SF]",
	108	CPUIDLE_DESC_LEN);
	109	state->exit_latency = 2300;
	110	state->target_residency = 1 * 2;
	111	state->power_usage = 1;
	112	state->flags = 0;
	113	state->flags \|= CPUIDLE_FLAG_TIME_VALID;
	114	state->enter = cpuidle_sleep_enter;
	115	}
63cd91df	116
7426394f MD	117	dev->state_count = i;
	118
	119	cpuidle_register_device(dev);
	120	}