1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * PowerPC 4xx Clock and Power Management
5 * Copyright (C) 2010, Applied Micro Circuits Corporation
6 * Victor Gallardo (vgallardo@apm.com)
8 * Based on arch/powerpc/platforms/44x/idle.c:
9 * Jerone Young <jyoung5@us.ibm.com>
10 * Copyright 2008 IBM Corp.
12 * Based on arch/powerpc/sysdev/fsl_pmc.c:
13 * Anton Vorontsov <avorontsov@ru.mvista.com>
14 * Copyright 2009 MontaVista Software, Inc.
16 * See file CREDITS for list of people who contributed to this
20 #include <linux/kernel.h>
21 #include <linux/of_platform.h>
22 #include <linux/sysfs.h>
23 #include <linux/cpu.h>
24 #include <linux/suspend.h>
26 #include <asm/dcr-native.h>
27 #include <asm/machdep.h>
33 #define CPM_IDLE_WAIT 0
34 #define CPM_IDLE_DOZE 1
38 unsigned int dcr_offset[3];
39 unsigned int powersave_off;
41 unsigned int idle_doze;
46 static struct cpm cpm;
48 struct cpm_idle_mode {
53 static struct cpm_idle_mode idle_mode[] = {
54 [CPM_IDLE_WAIT] = { 1, "wait" }, /* default */
55 [CPM_IDLE_DOZE] = { 0, "doze" },
58 static unsigned int cpm_set(unsigned int cpm_reg, unsigned int mask)
62 /* CPM controller supports 3 different types of sleep interface
63 * known as class 1, 2 and 3. For class 1 units, they are
64 * unconditionally put to sleep when the corresponding CPM bit is
65 * set. For class 2 and 3 units this is not case; if they can be
66 * put to sleep, they will. Here we do not verify, we just
67 * set them and expect them to eventually go off when they can.
69 value = dcr_read(cpm.dcr_host, cpm.dcr_offset[cpm_reg]);
70 dcr_write(cpm.dcr_host, cpm.dcr_offset[cpm_reg], value | mask);
72 /* return old state, to restore later if needed */
76 static void cpm_idle_wait(void)
78 unsigned long msr_save;
80 /* save off initial state */
82 /* sync required when CPM0_ER[CPU] is set */
84 /* set wait state MSR */
85 mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
87 /* return to initial state */
92 static void cpm_idle_sleep(unsigned int mask)
96 /* update CPM_ER state */
97 er_save = cpm_set(CPM_ER, mask);
99 /* go to wait state so that CPM0_ER[CPU] can take effect */
102 /* restore CPM_ER state */
103 dcr_write(cpm.dcr_host, cpm.dcr_offset[CPM_ER], er_save);
106 static void cpm_idle_doze(void)
108 cpm_idle_sleep(cpm.idle_doze);
111 static void cpm_idle_config(int mode)
115 if (idle_mode[mode].enabled)
118 for (i = 0; i < ARRAY_SIZE(idle_mode); i++)
119 idle_mode[i].enabled = 0;
121 idle_mode[mode].enabled = 1;
124 static ssize_t cpm_idle_show(struct kobject *kobj,
125 struct kobj_attribute *attr, char *buf)
130 for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
131 if (idle_mode[i].enabled)
132 s += sprintf(s, "[%s] ", idle_mode[i].name);
134 s += sprintf(s, "%s ", idle_mode[i].name);
137 *(s-1) = '\n'; /* convert the last space to a newline */
142 static ssize_t cpm_idle_store(struct kobject *kobj,
143 struct kobj_attribute *attr,
144 const char *buf, size_t n)
150 p = memchr(buf, '\n', n);
151 len = p ? p - buf : n;
153 for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
154 if (strncmp(buf, idle_mode[i].name, len) == 0) {
163 static struct kobj_attribute cpm_idle_attr =
164 __ATTR(idle, 0644, cpm_idle_show, cpm_idle_store);
166 static void __init cpm_idle_config_sysfs(void)
171 dev = get_cpu_device(0);
173 ret = sysfs_create_file(&dev->kobj,
174 &cpm_idle_attr.attr);
177 "cpm: failed to create idle sysfs entry\n");
180 static void cpm_idle(void)
182 if (idle_mode[CPM_IDLE_DOZE].enabled)
188 static int cpm_suspend_valid(suspend_state_t state)
191 case PM_SUSPEND_STANDBY:
192 return !!cpm.standby;
194 return !!cpm.suspend;
200 static void cpm_suspend_standby(unsigned int mask)
202 unsigned long tcr_save;
204 /* disable decrement interrupt */
205 tcr_save = mfspr(SPRN_TCR);
206 mtspr(SPRN_TCR, tcr_save & ~TCR_DIE);
208 /* go to sleep state */
209 cpm_idle_sleep(mask);
211 /* restore decrement interrupt */
212 mtspr(SPRN_TCR, tcr_save);
215 static int cpm_suspend_enter(suspend_state_t state)
218 case PM_SUSPEND_STANDBY:
219 cpm_suspend_standby(cpm.standby);
222 cpm_suspend_standby(cpm.suspend);
229 static const struct platform_suspend_ops cpm_suspend_ops = {
230 .valid = cpm_suspend_valid,
231 .enter = cpm_suspend_enter,
234 static int __init cpm_get_uint_property(struct device_node *np,
238 const unsigned int *prop = of_get_property(np, name, &len);
240 if (prop == NULL || len < sizeof(u32))
246 static int __init cpm_init(void)
248 struct device_node *np;
249 int dcr_base, dcr_len;
252 if (!cpm.powersave_off) {
253 cpm_idle_config(CPM_IDLE_WAIT);
254 ppc_md.power_save = &cpm_idle;
257 np = of_find_compatible_node(NULL, NULL, "ibm,cpm");
263 dcr_base = dcr_resource_start(np, 0);
264 dcr_len = dcr_resource_len(np, 0);
266 if (dcr_base == 0 || dcr_len == 0) {
267 printk(KERN_ERR "cpm: could not parse dcr property for %pOF\n",
273 cpm.dcr_host = dcr_map(np, dcr_base, dcr_len);
275 if (!DCR_MAP_OK(cpm.dcr_host)) {
276 printk(KERN_ERR "cpm: failed to map dcr property for %pOF\n",
282 /* All 4xx SoCs with a CPM controller have one of two
283 * different order for the CPM registers. Some have the
284 * CPM registers in the following order (ER,FR,SR). The
285 * others have them in the following order (SR,ER,FR).
288 if (cpm_get_uint_property(np, "er-offset") == 0) {
289 cpm.dcr_offset[CPM_ER] = 0;
290 cpm.dcr_offset[CPM_FR] = 1;
291 cpm.dcr_offset[CPM_SR] = 2;
293 cpm.dcr_offset[CPM_ER] = 1;
294 cpm.dcr_offset[CPM_FR] = 2;
295 cpm.dcr_offset[CPM_SR] = 0;
298 /* Now let's see what IPs to turn off for the following modes */
300 cpm.unused = cpm_get_uint_property(np, "unused-units");
301 cpm.idle_doze = cpm_get_uint_property(np, "idle-doze");
302 cpm.standby = cpm_get_uint_property(np, "standby");
303 cpm.suspend = cpm_get_uint_property(np, "suspend");
305 /* If some IPs are unused let's turn them off now */
308 cpm_set(CPM_ER, cpm.unused);
309 cpm_set(CPM_FR, cpm.unused);
312 /* Now let's export interfaces */
314 if (!cpm.powersave_off && cpm.idle_doze)
315 cpm_idle_config_sysfs();
317 if (cpm.standby || cpm.suspend)
318 suspend_set_ops(&cpm_suspend_ops);
325 late_initcall(cpm_init);
327 static int __init cpm_powersave_off(char *arg)
329 cpm.powersave_off = 1;
332 __setup("powersave=off", cpm_powersave_off);