1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * ZynqMP Generic PM domain support |
4 | * |
5 | * Copyright (C) 2015-2019 Xilinx, Inc. |
6 | * |
7 | * Davorin Mista <davorin.mista@aggios.com> |
8 | * Jolly Shah <jollys@xilinx.com> |
9 | * Rajan Vaja <rajan.vaja@xilinx.com> |
10 | */ |
11 | |
12 | #include <linux/err.h> |
13 | #include <linux/list.h> |
14 | #include <linux/module.h> |
15 | #include <linux/of_platform.h> |
16 | #include <linux/platform_device.h> |
17 | #include <linux/pm_domain.h> |
18 | #include <linux/slab.h> |
19 | |
20 | #include <linux/firmware/xlnx-zynqmp.h> |
21 | |
22 | #define ZYNQMP_NUM_DOMAINS (100) |
23 | |
24 | static int min_capability; |
25 | |
26 | /** |
27 | * struct zynqmp_pm_domain - Wrapper around struct generic_pm_domain |
28 | * @gpd: Generic power domain |
29 | * @node_id: PM node ID corresponding to device inside PM domain |
30 | * @requested: The PM node mapped to the PM domain has been requested |
31 | */ |
32 | struct zynqmp_pm_domain { |
33 | struct generic_pm_domain gpd; |
34 | u32 node_id; |
35 | bool requested; |
36 | }; |
37 | |
38 | #define to_zynqmp_pm_domain(pm_domain) \ |
39 | container_of(pm_domain, struct zynqmp_pm_domain, gpd) |
40 | |
41 | /** |
42 | * zynqmp_gpd_is_active_wakeup_path() - Check if device is in wakeup source |
43 | * path |
44 | * @dev: Device to check for wakeup source path |
45 | * @not_used: Data member (not required) |
46 | * |
47 | * This function is checks device's child hierarchy and checks if any device is |
48 | * set as wakeup source. |
49 | * |
50 | * Return: 1 if device is in wakeup source path else 0 |
51 | */ |
52 | static int zynqmp_gpd_is_active_wakeup_path(struct device *dev, void *not_used) |
53 | { |
54 | int may_wakeup; |
55 | |
56 | may_wakeup = device_may_wakeup(dev); |
57 | if (may_wakeup) |
58 | return may_wakeup; |
59 | |
60 | return device_for_each_child(parent: dev, NULL, |
61 | fn: zynqmp_gpd_is_active_wakeup_path); |
62 | } |
63 | |
64 | /** |
65 | * zynqmp_gpd_power_on() - Power on PM domain |
66 | * @domain: Generic PM domain |
67 | * |
68 | * This function is called before devices inside a PM domain are resumed, to |
69 | * power on PM domain. |
70 | * |
71 | * Return: 0 on success, error code otherwise |
72 | */ |
73 | static int zynqmp_gpd_power_on(struct generic_pm_domain *domain) |
74 | { |
75 | struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain); |
76 | int ret; |
77 | |
78 | ret = zynqmp_pm_set_requirement(node: pd->node_id, |
79 | ZYNQMP_PM_CAPABILITY_ACCESS, |
80 | ZYNQMP_PM_MAX_QOS, |
81 | ack: ZYNQMP_PM_REQUEST_ACK_BLOCKING); |
82 | if (ret) { |
83 | dev_err(&domain->dev, |
84 | "failed to set requirement to 0x%x for PM node id %d: %d\n" , |
85 | ZYNQMP_PM_CAPABILITY_ACCESS, pd->node_id, ret); |
86 | return ret; |
87 | } |
88 | |
89 | dev_dbg(&domain->dev, "set requirement to 0x%x for PM node id %d\n" , |
90 | ZYNQMP_PM_CAPABILITY_ACCESS, pd->node_id); |
91 | |
92 | return 0; |
93 | } |
94 | |
95 | /** |
96 | * zynqmp_gpd_power_off() - Power off PM domain |
97 | * @domain: Generic PM domain |
98 | * |
99 | * This function is called after devices inside a PM domain are suspended, to |
100 | * power off PM domain. |
101 | * |
102 | * Return: 0 on success, error code otherwise |
103 | */ |
104 | static int zynqmp_gpd_power_off(struct generic_pm_domain *domain) |
105 | { |
106 | struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain); |
107 | int ret; |
108 | struct pm_domain_data *pdd, *tmp; |
109 | u32 capabilities = min_capability; |
110 | bool may_wakeup; |
111 | |
112 | /* If domain is already released there is nothing to be done */ |
113 | if (!pd->requested) { |
114 | dev_dbg(&domain->dev, "PM node id %d is already released\n" , |
115 | pd->node_id); |
116 | return 0; |
117 | } |
118 | |
119 | list_for_each_entry_safe(pdd, tmp, &domain->dev_list, list_node) { |
120 | /* If device is in wakeup path, set capability to WAKEUP */ |
121 | may_wakeup = zynqmp_gpd_is_active_wakeup_path(dev: pdd->dev, NULL); |
122 | if (may_wakeup) { |
123 | dev_dbg(pdd->dev, "device is in wakeup path in %s\n" , |
124 | domain->name); |
125 | capabilities = ZYNQMP_PM_CAPABILITY_WAKEUP; |
126 | break; |
127 | } |
128 | } |
129 | |
130 | ret = zynqmp_pm_set_requirement(node: pd->node_id, capabilities, qos: 0, |
131 | ack: ZYNQMP_PM_REQUEST_ACK_NO); |
132 | if (ret) { |
133 | dev_err(&domain->dev, |
134 | "failed to set requirement to 0x%x for PM node id %d: %d\n" , |
135 | capabilities, pd->node_id, ret); |
136 | return ret; |
137 | } |
138 | |
139 | dev_dbg(&domain->dev, "set requirement to 0x%x for PM node id %d\n" , |
140 | capabilities, pd->node_id); |
141 | |
142 | return 0; |
143 | } |
144 | |
145 | /** |
146 | * zynqmp_gpd_attach_dev() - Attach device to the PM domain |
147 | * @domain: Generic PM domain |
148 | * @dev: Device to attach |
149 | * |
150 | * Return: 0 on success, error code otherwise |
151 | */ |
152 | static int zynqmp_gpd_attach_dev(struct generic_pm_domain *domain, |
153 | struct device *dev) |
154 | { |
155 | struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain); |
156 | struct device_link *link; |
157 | int ret; |
158 | |
159 | link = device_link_add(consumer: dev, supplier: &domain->dev, DL_FLAG_SYNC_STATE_ONLY); |
160 | if (!link) |
161 | dev_dbg(&domain->dev, "failed to create device link for %s\n" , |
162 | dev_name(dev)); |
163 | |
164 | /* If this is not the first device to attach there is nothing to do */ |
165 | if (domain->device_count) |
166 | return 0; |
167 | |
168 | ret = zynqmp_pm_request_node(node: pd->node_id, capabilities: 0, qos: 0, |
169 | ack: ZYNQMP_PM_REQUEST_ACK_BLOCKING); |
170 | if (ret) { |
171 | dev_err(&domain->dev, "%s request failed for node %d: %d\n" , |
172 | domain->name, pd->node_id, ret); |
173 | return ret; |
174 | } |
175 | |
176 | pd->requested = true; |
177 | |
178 | dev_dbg(&domain->dev, "%s requested PM node id %d\n" , |
179 | dev_name(dev), pd->node_id); |
180 | |
181 | return 0; |
182 | } |
183 | |
184 | /** |
185 | * zynqmp_gpd_detach_dev() - Detach device from the PM domain |
186 | * @domain: Generic PM domain |
187 | * @dev: Device to detach |
188 | */ |
189 | static void zynqmp_gpd_detach_dev(struct generic_pm_domain *domain, |
190 | struct device *dev) |
191 | { |
192 | struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain); |
193 | int ret; |
194 | |
195 | /* If this is not the last device to detach there is nothing to do */ |
196 | if (domain->device_count) |
197 | return; |
198 | |
199 | ret = zynqmp_pm_release_node(node: pd->node_id); |
200 | if (ret) { |
201 | dev_err(&domain->dev, "failed to release PM node id %d: %d\n" , |
202 | pd->node_id, ret); |
203 | return; |
204 | } |
205 | |
206 | pd->requested = false; |
207 | |
208 | dev_dbg(&domain->dev, "%s released PM node id %d\n" , |
209 | dev_name(dev), pd->node_id); |
210 | } |
211 | |
212 | static struct generic_pm_domain *zynqmp_gpd_xlate |
213 | (const struct of_phandle_args *genpdspec, void *data) |
214 | { |
215 | struct genpd_onecell_data *genpd_data = data; |
216 | unsigned int i, idx = genpdspec->args[0]; |
217 | struct zynqmp_pm_domain *pd; |
218 | |
219 | pd = to_zynqmp_pm_domain(genpd_data->domains[0]); |
220 | |
221 | if (genpdspec->args_count != 1) |
222 | return ERR_PTR(error: -EINVAL); |
223 | |
224 | /* Check for existing pm domains */ |
225 | for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++) { |
226 | if (pd[i].node_id == idx) |
227 | goto done; |
228 | } |
229 | |
230 | /* |
231 | * Add index in empty node_id of power domain list as no existing |
232 | * power domain found for current index. |
233 | */ |
234 | for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++) { |
235 | if (pd[i].node_id == 0) { |
236 | pd[i].node_id = idx; |
237 | break; |
238 | } |
239 | } |
240 | |
241 | done: |
242 | if (!genpd_data->domains[i] || i == ZYNQMP_NUM_DOMAINS) |
243 | return ERR_PTR(error: -ENOENT); |
244 | |
245 | return genpd_data->domains[i]; |
246 | } |
247 | |
248 | static int zynqmp_gpd_probe(struct platform_device *pdev) |
249 | { |
250 | int i; |
251 | struct genpd_onecell_data *zynqmp_pd_data; |
252 | struct generic_pm_domain **domains; |
253 | struct zynqmp_pm_domain *pd; |
254 | struct device *dev = &pdev->dev; |
255 | |
256 | pd = devm_kcalloc(dev, ZYNQMP_NUM_DOMAINS, size: sizeof(*pd), GFP_KERNEL); |
257 | if (!pd) |
258 | return -ENOMEM; |
259 | |
260 | zynqmp_pd_data = devm_kzalloc(dev, size: sizeof(*zynqmp_pd_data), GFP_KERNEL); |
261 | if (!zynqmp_pd_data) |
262 | return -ENOMEM; |
263 | |
264 | zynqmp_pd_data->xlate = zynqmp_gpd_xlate; |
265 | |
266 | domains = devm_kcalloc(dev, ZYNQMP_NUM_DOMAINS, size: sizeof(*domains), |
267 | GFP_KERNEL); |
268 | if (!domains) |
269 | return -ENOMEM; |
270 | |
271 | if (!of_device_is_compatible(device: dev->parent->of_node, |
272 | "xlnx,zynqmp-firmware" )) |
273 | min_capability = ZYNQMP_PM_CAPABILITY_UNUSABLE; |
274 | |
275 | for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++, pd++) { |
276 | pd->node_id = 0; |
277 | pd->gpd.name = kasprintf(GFP_KERNEL, fmt: "domain%d" , i); |
278 | pd->gpd.power_off = zynqmp_gpd_power_off; |
279 | pd->gpd.power_on = zynqmp_gpd_power_on; |
280 | pd->gpd.attach_dev = zynqmp_gpd_attach_dev; |
281 | pd->gpd.detach_dev = zynqmp_gpd_detach_dev; |
282 | |
283 | domains[i] = &pd->gpd; |
284 | |
285 | /* Mark all PM domains as initially powered off */ |
286 | pm_genpd_init(genpd: &pd->gpd, NULL, is_off: true); |
287 | } |
288 | |
289 | zynqmp_pd_data->domains = domains; |
290 | zynqmp_pd_data->num_domains = ZYNQMP_NUM_DOMAINS; |
291 | of_genpd_add_provider_onecell(np: dev->parent->of_node, data: zynqmp_pd_data); |
292 | |
293 | return 0; |
294 | } |
295 | |
296 | static void zynqmp_gpd_remove(struct platform_device *pdev) |
297 | { |
298 | of_genpd_del_provider(np: pdev->dev.parent->of_node); |
299 | } |
300 | |
301 | static void zynqmp_gpd_sync_state(struct device *dev) |
302 | { |
303 | int ret; |
304 | |
305 | ret = zynqmp_pm_init_finalize(); |
306 | if (ret) |
307 | dev_warn(dev, "failed to release power management to firmware\n" ); |
308 | } |
309 | |
310 | static struct platform_driver zynqmp_power_domain_driver = { |
311 | .driver = { |
312 | .name = "zynqmp_power_controller" , |
313 | .sync_state = zynqmp_gpd_sync_state, |
314 | }, |
315 | .probe = zynqmp_gpd_probe, |
316 | .remove = zynqmp_gpd_remove, |
317 | }; |
318 | module_platform_driver(zynqmp_power_domain_driver); |
319 | |
320 | MODULE_ALIAS("platform:zynqmp_power_controller" ); |
321 | |