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