[linux-2.6-block.git] / drivers / cpuidle / cpuidle-cps.c

/*
 * Copyright (C) 2014 Imagination Technologies
 * Author: Paul Burton <paul.burton@imgtec.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <linux/cpu_pm.h>
#include <linux/cpuidle.h>
#include <linux/init.h>

#include <asm/idle.h>
#include <asm/pm-cps.h>

/* Enumeration of the various idle states this driver may enter */
enum cps_idle_state {
	STATE_WAIT = 0,		/* MIPS wait instruction, coherent */
	STATE_NC_WAIT,		/* MIPS wait instruction, non-coherent */
	STATE_CLOCK_GATED,	/* Core clock gated */
	STATE_POWER_GATED,	/* Core power gated */
	STATE_COUNT
};

static int cps_nc_enter(struct cpuidle_device *dev,
			struct cpuidle_driver *drv, int index)
{
	enum cps_pm_state pm_state;
	int err;

	/*
	 * At least one core must remain powered up & clocked in order for the
	 * system to have any hope of functioning.
	 *
	 * TODO: don't treat core 0 specially, just prevent the final core
	 * TODO: remap interrupt affinity temporarily
	 */
	if (!cpu_data[dev->cpu].core && (index > STATE_NC_WAIT))
		index = STATE_NC_WAIT;

	/* Select the appropriate cps_pm_state */
	switch (index) {
	case STATE_NC_WAIT:
		pm_state = CPS_PM_NC_WAIT;
		break;
	case STATE_CLOCK_GATED:
		pm_state = CPS_PM_CLOCK_GATED;
		break;
	case STATE_POWER_GATED:
		pm_state = CPS_PM_POWER_GATED;
		break;
	default:
		BUG();
		return -EINVAL;
	}

	/* Notify listeners the CPU is about to power down */
	if ((pm_state == CPS_PM_POWER_GATED) && cpu_pm_enter())
		return -EINTR;

	/* Enter that state */
	err = cps_pm_enter_state(pm_state);

	/* Notify listeners the CPU is back up */
	if (pm_state == CPS_PM_POWER_GATED)
		cpu_pm_exit();

	return err ?: index;
}

static struct cpuidle_driver cps_driver = {
	.name			= "cpc_cpuidle",
	.owner			= THIS_MODULE,
	.states = {
		[STATE_WAIT] = MIPS_CPUIDLE_WAIT_STATE,
		[STATE_NC_WAIT] = {
			.enter	= cps_nc_enter,
			.exit_latency		= 200,
			.target_residency	= 450,
			.flags	= CPUIDLE_FLAG_TIME_VALID,
			.name	= "nc-wait",
			.desc	= "non-coherent MIPS wait",
		},
		[STATE_CLOCK_GATED] = {
			.enter	= cps_nc_enter,
			.exit_latency		= 300,
			.target_residency	= 700,
			.flags	= CPUIDLE_FLAG_TIME_VALID |
				  CPUIDLE_FLAG_TIMER_STOP,
			.name	= "clock-gated",
			.desc	= "core clock gated",
		},
		[STATE_POWER_GATED] = {
			.enter	= cps_nc_enter,
			.exit_latency		= 600,
			.target_residency	= 1000,
			.flags	= CPUIDLE_FLAG_TIME_VALID |
				  CPUIDLE_FLAG_TIMER_STOP,
			.name	= "power-gated",
			.desc	= "core power gated",
		},
	},
	.state_count		= STATE_COUNT,
	.safe_state_index	= 0,
};

static void __init cps_cpuidle_unregister(void)
{
	int cpu;
	struct cpuidle_device *device;

	for_each_possible_cpu(cpu) {
		device = &per_cpu(cpuidle_dev, cpu);
		cpuidle_unregister_device(device);
	}

	cpuidle_unregister_driver(&cps_driver);
}

static int __init cps_cpuidle_init(void)
{
	int err, cpu, core, i;
	struct cpuidle_device *device;

	/* Detect supported states */
	if (!cps_pm_support_state(CPS_PM_POWER_GATED))
		cps_driver.state_count = STATE_CLOCK_GATED + 1;
	if (!cps_pm_support_state(CPS_PM_CLOCK_GATED))
		cps_driver.state_count = STATE_NC_WAIT + 1;
	if (!cps_pm_support_state(CPS_PM_NC_WAIT))
		cps_driver.state_count = STATE_WAIT + 1;

	/* Inform the user if some states are unavailable */
	if (cps_driver.state_count < STATE_COUNT) {
		pr_info("cpuidle-cps: limited to ");
		switch (cps_driver.state_count - 1) {
		case STATE_WAIT:
			pr_cont("coherent wait\n");
			break;
		case STATE_NC_WAIT:
			pr_cont("non-coherent wait\n");
			break;
		case STATE_CLOCK_GATED:
			pr_cont("clock gating\n");
			break;
		}
	}

	/*
	 * Set the coupled flag on the appropriate states if this system
	 * requires it.
	 */
	if (coupled_coherence)
		for (i = STATE_NC_WAIT; i < cps_driver.state_count; i++)
			cps_driver.states[i].flags |= CPUIDLE_FLAG_COUPLED;

	err = cpuidle_register_driver(&cps_driver);
	if (err) {
		pr_err("Failed to register CPS cpuidle driver\n");
		return err;
	}

	for_each_possible_cpu(cpu) {
		core = cpu_data[cpu].core;
		device = &per_cpu(cpuidle_dev, cpu);
		device->cpu = cpu;
#ifdef CONFIG_MIPS_MT
		cpumask_copy(&device->coupled_cpus, &cpu_sibling_map[cpu]);
#endif

		err = cpuidle_register_device(device);
		if (err) {
			pr_err("Failed to register CPU%d cpuidle device\n",
			       cpu);
			goto err_out;
		}
	}

	return 0;
err_out:
	cps_cpuidle_unregister();
	return err;
}
device_initcall(cps_cpuidle_init);
Commit	Line	Data
d0508944 PB	1	/*
	2	* Copyright (C) 2014 Imagination Technologies
	3	* Author: Paul Burton <paul.burton@imgtec.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by the
	7	* Free Software Foundation; either version 2 of the License, or (at your
	8	* option) any later version.
	9	*/
	10
	11	#include <linux/cpu_pm.h>
	12	#include <linux/cpuidle.h>
	13	#include <linux/init.h>
	14
	15	#include <asm/idle.h>
	16	#include <asm/pm-cps.h>
	17
	18	/* Enumeration of the various idle states this driver may enter */
	19	enum cps_idle_state {
	20	STATE_WAIT = 0, /* MIPS wait instruction, coherent */
	21	STATE_NC_WAIT, /* MIPS wait instruction, non-coherent */
	22	STATE_CLOCK_GATED, /* Core clock gated */
	23	STATE_POWER_GATED, /* Core power gated */
	24	STATE_COUNT
	25	};
	26
	27	static int cps_nc_enter(struct cpuidle_device *dev,
	28	struct cpuidle_driver *drv, int index)
	29	{
	30	enum cps_pm_state pm_state;
	31	int err;
	32
	33	/*
	34	* At least one core must remain powered up & clocked in order for the
	35	* system to have any hope of functioning.
	36	*
	37	* TODO: don't treat core 0 specially, just prevent the final core
	38	* TODO: remap interrupt affinity temporarily
	39	*/
	40	if (!cpu_data[dev->cpu].core && (index > STATE_NC_WAIT))
	41	index = STATE_NC_WAIT;
	42
	43	/* Select the appropriate cps_pm_state */
	44	switch (index) {
	45	case STATE_NC_WAIT:
	46	pm_state = CPS_PM_NC_WAIT;
	47	break;
	48	case STATE_CLOCK_GATED:
	49	pm_state = CPS_PM_CLOCK_GATED;
	50	break;
	51	case STATE_POWER_GATED:
	52	pm_state = CPS_PM_POWER_GATED;
	53	break;
	54	default:
	55	BUG();
	56	return -EINVAL;
	57	}
	58
	59	/* Notify listeners the CPU is about to power down */
	60	if ((pm_state == CPS_PM_POWER_GATED) && cpu_pm_enter())
	61	return -EINTR;
	62
	63	/* Enter that state */
	64	err = cps_pm_enter_state(pm_state);
65
66	/* Notify listeners the CPU is back up */
67	if (pm_state == CPS_PM_POWER_GATED)
68	cpu_pm_exit();
69
70	return err ?: index;
71	}
72
73	static struct cpuidle_driver cps_driver = {
74	.name = "cpc_cpuidle",
75	.owner = THIS_MODULE,
76	.states = {
77	[STATE_WAIT] = MIPS_CPUIDLE_WAIT_STATE,
78	[STATE_NC_WAIT] = {
79	.enter = cps_nc_enter,
80	.exit_latency = 200,
81	.target_residency = 450,
82	.flags = CPUIDLE_FLAG_TIME_VALID,
83	.name = "nc-wait",
84	.desc = "non-coherent MIPS wait",
85	},
86	[STATE_CLOCK_GATED] = {
87	.enter = cps_nc_enter,
88	.exit_latency = 300,
89	.target_residency = 700,
90	.flags = CPUIDLE_FLAG_TIME_VALID \|
91	CPUIDLE_FLAG_TIMER_STOP,
92	.name = "clock-gated",
93	.desc = "core clock gated",
94	},
95	[STATE_POWER_GATED] = {
96	.enter = cps_nc_enter,
97	.exit_latency = 600,
98	.target_residency = 1000,
99	.flags = CPUIDLE_FLAG_TIME_VALID \|
100	CPUIDLE_FLAG_TIMER_STOP,
101	.name = "power-gated",
102	.desc = "core power gated",
103	},
104	},
105	.state_count = STATE_COUNT,
106	.safe_state_index = 0,
107	};
108
109	static void __init cps_cpuidle_unregister(void)
110	{
111	int cpu;
112	struct cpuidle_device *device;
113
114	for_each_possible_cpu(cpu) {
115	device = &per_cpu(cpuidle_dev, cpu);
116	cpuidle_unregister_device(device);
117	}
118
119	cpuidle_unregister_driver(&cps_driver);
120	}
121
122	static int __init cps_cpuidle_init(void)
123	{
124	int err, cpu, core, i;
125	struct cpuidle_device *device;
126
127	/* Detect supported states */
128	if (!cps_pm_support_state(CPS_PM_POWER_GATED))
129	cps_driver.state_count = STATE_CLOCK_GATED + 1;
130	if (!cps_pm_support_state(CPS_PM_CLOCK_GATED))
131	cps_driver.state_count = STATE_NC_WAIT + 1;
132	if (!cps_pm_support_state(CPS_PM_NC_WAIT))
133	cps_driver.state_count = STATE_WAIT + 1;
134
135	/* Inform the user if some states are unavailable */
136	if (cps_driver.state_count < STATE_COUNT) {
137	pr_info("cpuidle-cps: limited to ");
138	switch (cps_driver.state_count - 1) {
139	case STATE_WAIT:
140	pr_cont("coherent wait\n");
141	break;
142	case STATE_NC_WAIT:
143	pr_cont("non-coherent wait\n");
144	break;
145	case STATE_CLOCK_GATED:
146	pr_cont("clock gating\n");
147	break;
148	}
149	}
150
151	/*
152	* Set the coupled flag on the appropriate states if this system
153	* requires it.
154	*/
155	if (coupled_coherence)
156	for (i = STATE_NC_WAIT; i < cps_driver.state_count; i++)
157	cps_driver.states[i].flags \|= CPUIDLE_FLAG_COUPLED;
158
159	err = cpuidle_register_driver(&cps_driver);
160	if (err) {
161	pr_err("Failed to register CPS cpuidle driver\n");
162	return err;
163	}
164
165	for_each_possible_cpu(cpu) {
166	core = cpu_data[cpu].core;
167	device = &per_cpu(cpuidle_dev, cpu);
168	device->cpu = cpu;
169	#ifdef CONFIG_MIPS_MT
170	cpumask_copy(&device->coupled_cpus, &cpu_sibling_map[cpu]);
171	#endif
172
173	err = cpuidle_register_device(device);
174	if (err) {
175	pr_err("Failed to register CPU%d cpuidle device\n",
176	cpu);
177	goto err_out;
178	}
179	}
180
181	return 0;
182	err_out:
183	cps_cpuidle_unregister();
184	return err;
185	}
186	device_initcall(cps_cpuidle_init);