This source file includes following definitions.
- psci_enter_idle_state
- psci_dt_parse_state_node
- psci_dt_cpu_init_idle
- psci_cpu_init_idle
- psci_idle_init_cpu
- psci_idle_init
1
2
3
4
5
6
7
8
9 #define pr_fmt(fmt) "CPUidle PSCI: " fmt
10
11 #include <linux/cpuidle.h>
12 #include <linux/cpumask.h>
13 #include <linux/cpu_pm.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/of_device.h>
18 #include <linux/psci.h>
19 #include <linux/slab.h>
20
21 #include <asm/cpuidle.h>
22
23 #include "dt_idle_states.h"
24
25 static DEFINE_PER_CPU_READ_MOSTLY(u32 *, psci_power_state);
26
27 static int psci_enter_idle_state(struct cpuidle_device *dev,
28 struct cpuidle_driver *drv, int idx)
29 {
30 u32 *state = __this_cpu_read(psci_power_state);
31
32 return CPU_PM_CPU_IDLE_ENTER_PARAM(psci_cpu_suspend_enter,
33 idx, state[idx - 1]);
34 }
35
36 static struct cpuidle_driver psci_idle_driver __initdata = {
37 .name = "psci_idle",
38 .owner = THIS_MODULE,
39
40
41
42
43 .states[0] = {
44 .enter = psci_enter_idle_state,
45 .exit_latency = 1,
46 .target_residency = 1,
47 .power_usage = UINT_MAX,
48 .name = "WFI",
49 .desc = "ARM WFI",
50 }
51 };
52
53 static const struct of_device_id psci_idle_state_match[] __initconst = {
54 { .compatible = "arm,idle-state",
55 .data = psci_enter_idle_state },
56 { },
57 };
58
59 static int __init psci_dt_parse_state_node(struct device_node *np, u32 *state)
60 {
61 int err = of_property_read_u32(np, "arm,psci-suspend-param", state);
62
63 if (err) {
64 pr_warn("%pOF missing arm,psci-suspend-param property\n", np);
65 return err;
66 }
67
68 if (!psci_power_state_is_valid(*state)) {
69 pr_warn("Invalid PSCI power state %#x\n", *state);
70 return -EINVAL;
71 }
72
73 return 0;
74 }
75
76 static int __init psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu)
77 {
78 int i, ret = 0, count = 0;
79 u32 *psci_states;
80 struct device_node *state_node;
81
82
83 while ((state_node = of_parse_phandle(cpu_node, "cpu-idle-states",
84 count))) {
85 count++;
86 of_node_put(state_node);
87 }
88
89 if (!count)
90 return -ENODEV;
91
92 psci_states = kcalloc(count, sizeof(*psci_states), GFP_KERNEL);
93 if (!psci_states)
94 return -ENOMEM;
95
96 for (i = 0; i < count; i++) {
97 state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
98 ret = psci_dt_parse_state_node(state_node, &psci_states[i]);
99 of_node_put(state_node);
100
101 if (ret)
102 goto free_mem;
103
104 pr_debug("psci-power-state %#x index %d\n", psci_states[i], i);
105 }
106
107
108 per_cpu(psci_power_state, cpu) = psci_states;
109 return 0;
110
111 free_mem:
112 kfree(psci_states);
113 return ret;
114 }
115
116 static __init int psci_cpu_init_idle(unsigned int cpu)
117 {
118 struct device_node *cpu_node;
119 int ret;
120
121
122
123
124
125 if (!psci_ops.cpu_suspend)
126 return -EOPNOTSUPP;
127
128 cpu_node = of_cpu_device_node_get(cpu);
129 if (!cpu_node)
130 return -ENODEV;
131
132 ret = psci_dt_cpu_init_idle(cpu_node, cpu);
133
134 of_node_put(cpu_node);
135
136 return ret;
137 }
138
139 static int __init psci_idle_init_cpu(int cpu)
140 {
141 struct cpuidle_driver *drv;
142 struct device_node *cpu_node;
143 const char *enable_method;
144 int ret = 0;
145
146 cpu_node = of_cpu_device_node_get(cpu);
147 if (!cpu_node)
148 return -ENODEV;
149
150
151
152
153
154 enable_method = of_get_property(cpu_node, "enable-method", NULL);
155 if (!enable_method || (strcmp(enable_method, "psci")))
156 ret = -ENODEV;
157
158 of_node_put(cpu_node);
159 if (ret)
160 return ret;
161
162 drv = kmemdup(&psci_idle_driver, sizeof(*drv), GFP_KERNEL);
163 if (!drv)
164 return -ENOMEM;
165
166 drv->cpumask = (struct cpumask *)cpumask_of(cpu);
167
168
169
170
171
172
173
174
175
176
177
178
179 ret = dt_init_idle_driver(drv, psci_idle_state_match, 1);
180 if (ret <= 0) {
181 ret = ret ? : -ENODEV;
182 goto out_kfree_drv;
183 }
184
185
186
187
188 ret = psci_cpu_init_idle(cpu);
189 if (ret) {
190 pr_err("CPU %d failed to PSCI idle\n", cpu);
191 goto out_kfree_drv;
192 }
193
194 ret = cpuidle_register(drv, NULL);
195 if (ret)
196 goto out_kfree_drv;
197
198 return 0;
199
200 out_kfree_drv:
201 kfree(drv);
202 return ret;
203 }
204
205
206
207
208
209
210
211
212 static int __init psci_idle_init(void)
213 {
214 int cpu, ret;
215 struct cpuidle_driver *drv;
216 struct cpuidle_device *dev;
217
218 for_each_possible_cpu(cpu) {
219 ret = psci_idle_init_cpu(cpu);
220 if (ret)
221 goto out_fail;
222 }
223
224 return 0;
225
226 out_fail:
227 while (--cpu >= 0) {
228 dev = per_cpu(cpuidle_devices, cpu);
229 drv = cpuidle_get_cpu_driver(dev);
230 cpuidle_unregister(drv);
231 kfree(drv);
232 }
233
234 return ret;
235 }
236 device_initcall(psci_idle_init);