1/*
  2 * PowerPC 4xx Clock and Power Management
  3 *
  4 * Copyright (C) 2010, Applied Micro Circuits Corporation
  5 * Victor Gallardo (vgallardo@apm.com)
  6 *
  7 * Based on arch/powerpc/platforms/44x/idle.c:
  8 * Jerone Young <jyoung5@us.ibm.com>
  9 * Copyright 2008 IBM Corp.
 10 *
 11 * Based on arch/powerpc/sysdev/fsl_pmc.c:
 12 * Anton Vorontsov <avorontsov@ru.mvista.com>
 13 * Copyright 2009  MontaVista Software, Inc.
 14 *
 15 * See file CREDITS for list of people who contributed to this
 16 * project.
 17 *
 18 * This program is free software; you can redistribute it and/or
 19 * modify it under the terms of the GNU General Public License as
 20 * published by the Free Software Foundation; either version 2 of
 21 * the License, or (at your option) any later version.
 22 *
 23 * This program is distributed in the hope that it will be useful,
 24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 26 * GNU General Public License for more details.
 27 *
 28 * You should have received a copy of the GNU General Public License
 29 * along with this program; if not, write to the Free Software
 30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 31 * MA 02111-1307 USA
 32 */
 33
 34#include <linux/kernel.h>
 35#include <linux/of_platform.h>
 36#include <linux/sysfs.h>
 37#include <linux/cpu.h>
 38#include <linux/suspend.h>
 39#include <asm/dcr.h>
 40#include <asm/dcr-native.h>
 41#include <asm/machdep.h>
 42
 43#define CPM_ER	0
 44#define CPM_FR	1
 45#define CPM_SR	2
 46
 47#define CPM_IDLE_WAIT	0
 48#define CPM_IDLE_DOZE	1
 49
 50struct cpm {
 51	dcr_host_t	dcr_host;
 52	unsigned int	dcr_offset[3];
 53	unsigned int	powersave_off;
 54	unsigned int	unused;
 55	unsigned int	idle_doze;
 56	unsigned int	standby;
 57	unsigned int	suspend;
 58};
 59
 60static struct cpm cpm;
 61
 62struct cpm_idle_mode {
 63	unsigned int enabled;
 64	const char  *name;
 65};
 66
 67static struct cpm_idle_mode idle_mode[] = {
 68	[CPM_IDLE_WAIT] = { 1, "wait" }, /* default */
 69	[CPM_IDLE_DOZE] = { 0, "doze" },
 70};
 71
 72static unsigned int cpm_set(unsigned int cpm_reg, unsigned int mask)
 73{
 74	unsigned int value;
 75
 76	/* CPM controller supports 3 different types of sleep interface
 77	 * known as class 1, 2 and 3. For class 1 units, they are
 78	 * unconditionally put to sleep when the corresponding CPM bit is
 79	 * set. For class 2 and 3 units this is not case; if they can be
 80	 * put to to sleep, they will. Here we do not verify, we just
 81	 * set them and expect them to eventually go off when they can.
 82	 */
 83	value = dcr_read(cpm.dcr_host, cpm.dcr_offset[cpm_reg]);
 84	dcr_write(cpm.dcr_host, cpm.dcr_offset[cpm_reg], value | mask);
 85
 86	/* return old state, to restore later if needed */
 87	return value;
 88}
 89
 90static void cpm_idle_wait(void)
 91{
 92	unsigned long msr_save;
 93
 94	/* save off initial state */
 95	msr_save = mfmsr();
 96	/* sync required when CPM0_ER[CPU] is set */
 97	mb();
 98	/* set wait state MSR */
 99	mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
100	isync();
101	/* return to initial state */
102	mtmsr(msr_save);
103	isync();
104}
105
106static void cpm_idle_sleep(unsigned int mask)
107{
108	unsigned int er_save;
109
110	/* update CPM_ER state */
111	er_save = cpm_set(CPM_ER, mask);
112
113	/* go to wait state so that CPM0_ER[CPU] can take effect */
114	cpm_idle_wait();
115
116	/* restore CPM_ER state */
117	dcr_write(cpm.dcr_host, cpm.dcr_offset[CPM_ER], er_save);
118}
119
120static void cpm_idle_doze(void)
121{
122	cpm_idle_sleep(cpm.idle_doze);
123}
124
125static void cpm_idle_config(int mode)
126{
127	int i;
128
129	if (idle_mode[mode].enabled)
130		return;
131
132	for (i = 0; i < ARRAY_SIZE(idle_mode); i++)
133		idle_mode[i].enabled = 0;
134
135	idle_mode[mode].enabled = 1;
136}
137
138static ssize_t cpm_idle_show(struct kobject *kobj,
139			     struct kobj_attribute *attr, char *buf)
140{
141	char *s = buf;
142	int i;
143
144	for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
145		if (idle_mode[i].enabled)
146			s += sprintf(s, "[%s] ", idle_mode[i].name);
147		else
148			s += sprintf(s, "%s ", idle_mode[i].name);
149	}
150
151	*(s-1) = '\n'; /* convert the last space to a newline */
152
153	return s - buf;
154}
155
156static ssize_t cpm_idle_store(struct kobject *kobj,
157			      struct kobj_attribute *attr,
158			      const char *buf, size_t n)
159{
160	int i;
161	char *p;
162	int len;
163
164	p = memchr(buf, '\n', n);
165	len = p ? p - buf : n;
166
167	for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
168		if (strncmp(buf, idle_mode[i].name, len) == 0) {
169			cpm_idle_config(i);
170			return n;
171		}
172	}
173
174	return -EINVAL;
175}
176
177static struct kobj_attribute cpm_idle_attr =
178	__ATTR(idle, 0644, cpm_idle_show, cpm_idle_store);
179
180static void cpm_idle_config_sysfs(void)
181{
182	struct device *dev;
183	unsigned long ret;
184
185	dev = get_cpu_device(0);
186
187	ret = sysfs_create_file(&dev->kobj,
188				&cpm_idle_attr.attr);
189	if (ret)
190		printk(KERN_WARNING
191		       "cpm: failed to create idle sysfs entry\n");
192}
193
194static void cpm_idle(void)
195{
196	if (idle_mode[CPM_IDLE_DOZE].enabled)
197		cpm_idle_doze();
198	else
199		cpm_idle_wait();
200}
201
202static int cpm_suspend_valid(suspend_state_t state)
203{
204	switch (state) {
205	case PM_SUSPEND_STANDBY:
206		return !!cpm.standby;
207	case PM_SUSPEND_MEM:
208		return !!cpm.suspend;
209	default:
210		return 0;
211	}
212}
213
214static void cpm_suspend_standby(unsigned int mask)
215{
216	unsigned long tcr_save;
217
218	/* disable decrement interrupt */
219	tcr_save = mfspr(SPRN_TCR);
220	mtspr(SPRN_TCR, tcr_save & ~TCR_DIE);
221
222	/* go to sleep state */
223	cpm_idle_sleep(mask);
224
225	/* restore decrement interrupt */
226	mtspr(SPRN_TCR, tcr_save);
227}
228
229static int cpm_suspend_enter(suspend_state_t state)
230{
231	switch (state) {
232	case PM_SUSPEND_STANDBY:
233		cpm_suspend_standby(cpm.standby);
234		break;
235	case PM_SUSPEND_MEM:
236		cpm_suspend_standby(cpm.suspend);
237		break;
238	}
239
240	return 0;
241}
242
243static struct platform_suspend_ops cpm_suspend_ops = {
244	.valid		= cpm_suspend_valid,
245	.enter		= cpm_suspend_enter,
246};
247
248static int cpm_get_uint_property(struct device_node *np,
249				 const char *name)
250{
251	int len;
252	const unsigned int *prop = of_get_property(np, name, &len);
253
254	if (prop == NULL || len < sizeof(u32))
255		return 0;
256
257	return *prop;
258}
259
260static int __init cpm_init(void)
261{
262	struct device_node *np;
263	int dcr_base, dcr_len;
264	int ret = 0;
265
266	if (!cpm.powersave_off) {
267		cpm_idle_config(CPM_IDLE_WAIT);
268		ppc_md.power_save = &cpm_idle;
269	}
270
271	np = of_find_compatible_node(NULL, NULL, "ibm,cpm");
272	if (!np) {
273		ret = -EINVAL;
274		goto out;
275	}
276
277	dcr_base = dcr_resource_start(np, 0);
278	dcr_len = dcr_resource_len(np, 0);
279
280	if (dcr_base == 0 || dcr_len == 0) {
281		printk(KERN_ERR "cpm: could not parse dcr property for %s\n",
282		       np->full_name);
283		ret = -EINVAL;
284		goto node_put;
285	}
286
287	cpm.dcr_host = dcr_map(np, dcr_base, dcr_len);
288
289	if (!DCR_MAP_OK(cpm.dcr_host)) {
290		printk(KERN_ERR "cpm: failed to map dcr property for %s\n",
291		       np->full_name);
292		ret = -EINVAL;
293		goto node_put;
294	}
295
296	/* All 4xx SoCs with a CPM controller have one of two
297	 * different order for the CPM registers. Some have the
298	 * CPM registers in the following order (ER,FR,SR). The
299	 * others have them in the following order (SR,ER,FR).
300	 */
301
302	if (cpm_get_uint_property(np, "er-offset") == 0) {
303		cpm.dcr_offset[CPM_ER] = 0;
304		cpm.dcr_offset[CPM_FR] = 1;
305		cpm.dcr_offset[CPM_SR] = 2;
306	} else {
307		cpm.dcr_offset[CPM_ER] = 1;
308		cpm.dcr_offset[CPM_FR] = 2;
309		cpm.dcr_offset[CPM_SR] = 0;
310	}
311
312	/* Now let's see what IPs to turn off for the following modes */
313
314	cpm.unused = cpm_get_uint_property(np, "unused-units");
315	cpm.idle_doze = cpm_get_uint_property(np, "idle-doze");
316	cpm.standby = cpm_get_uint_property(np, "standby");
317	cpm.suspend = cpm_get_uint_property(np, "suspend");
318
319	/* If some IPs are unused let's turn them off now */
320
321	if (cpm.unused) {
322		cpm_set(CPM_ER, cpm.unused);
323		cpm_set(CPM_FR, cpm.unused);
324	}
325
326	/* Now let's export interfaces */
327
328	if (!cpm.powersave_off && cpm.idle_doze)
329		cpm_idle_config_sysfs();
330
331	if (cpm.standby || cpm.suspend)
332		suspend_set_ops(&cpm_suspend_ops);
333node_put:
334	of_node_put(np);
335out:
336	return ret;
337}
338
339late_initcall(cpm_init);
340
341static int __init cpm_powersave_off(char *arg)
342{
343	cpm.powersave_off = 1;
344	return 0;
345}
346__setup("powersave=off", cpm_powersave_off);