projects/linux·blob master · refs

420 lines · 10.1 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2024 Linaro Ltd.
4 */
5
6#define dev_fmt(fmt) "pwrctrl: " fmt
7
8#include <linux/device.h>
9#include <linux/export.h>
10#include <linux/kernel.h>
11#include <linux/of.h>
12#include <linux/of_graph.h>
13#include <linux/of_platform.h>
14#include <linux/pci.h>
15#include <linux/pci-pwrctrl.h>
16#include <linux/platform_device.h>
17#include <linux/property.h>
18#include <linux/slab.h>
19
20#include "../pci.h"
21
22static int pci_pwrctrl_notify(struct notifier_block *nb, unsigned long action,
23 void *data)
24{
25 struct pci_pwrctrl *pwrctrl = container_of(nb, struct pci_pwrctrl, nb);
26 struct device *dev = data;
27
28 if (dev_fwnode(dev) != dev_fwnode(pwrctrl->dev))
29 return NOTIFY_DONE;
30
31 switch (action) {
32 case BUS_NOTIFY_ADD_DEVICE:
33 /*
34 * We will have two struct device objects bound to two different
35 * drivers on different buses but consuming the same DT node. We
36 * must not bind the pins twice in this case but only once for
37 * the first device to be added.
38 *
39 * If we got here then the PCI device is the second after the
40 * power control platform device. Mark its OF node as reused.
41 */
42 dev_set_of_node_reused(dev);
43 break;
44 }
45
46 return NOTIFY_DONE;
47}
48
49/**
50 * pci_pwrctrl_init() - Initialize the PCI power control context struct
51 *
52 * @pwrctrl: PCI power control data
53 * @dev: Parent device
54 */
55void pci_pwrctrl_init(struct pci_pwrctrl *pwrctrl, struct device *dev)
56{
57 pwrctrl->dev = dev;
58 dev_set_drvdata(dev, pwrctrl);
59}
60EXPORT_SYMBOL_GPL(pci_pwrctrl_init);
61
62/**
63 * pci_pwrctrl_device_set_ready() - Notify the pwrctrl subsystem that the PCI
64 * device is powered-up and ready to be detected.
65 *
66 * @pwrctrl: PCI power control data.
67 *
68 * Returns:
69 * 0 on success, negative error number on error.
70 *
71 * Note:
72 * This function returning 0 doesn't mean the device was detected. It means,
73 * that the bus rescan was successfully started. The device will get bound to
74 * its PCI driver asynchronously.
75 */
76int pci_pwrctrl_device_set_ready(struct pci_pwrctrl *pwrctrl)
77{
78 int ret;
79
80 if (!pwrctrl->dev)
81 return -ENODEV;
82
83 pwrctrl->nb.notifier_call = pci_pwrctrl_notify;
84 ret = bus_register_notifier(&pci_bus_type, &pwrctrl->nb);
85 if (ret)
86 return ret;
87
88 return 0;
89}
90EXPORT_SYMBOL_GPL(pci_pwrctrl_device_set_ready);
91
92/**
93 * pci_pwrctrl_device_unset_ready() - Notify the pwrctrl subsystem that the PCI
94 * device is about to be powered-down.
95 *
96 * @pwrctrl: PCI power control data.
97 */
98void pci_pwrctrl_device_unset_ready(struct pci_pwrctrl *pwrctrl)
99{
100 /*
101 * We don't have to delete the link here. Typically, this function
102 * is only called when the power control device is being detached. If
103 * it is being detached then the child PCI device must have already
104 * been unbound too or the device core wouldn't let us unbind.
105 */
106 bus_unregister_notifier(&pci_bus_type, &pwrctrl->nb);
107}
108EXPORT_SYMBOL_GPL(pci_pwrctrl_device_unset_ready);
109
110static void devm_pci_pwrctrl_device_unset_ready(void *data)
111{
112 struct pci_pwrctrl *pwrctrl = data;
113
114 pci_pwrctrl_device_unset_ready(pwrctrl);
115}
116
117/**
118 * devm_pci_pwrctrl_device_set_ready - Managed variant of
119 * pci_pwrctrl_device_set_ready().
120 *
121 * @dev: Device managing this pwrctrl provider.
122 * @pwrctrl: PCI power control data.
123 *
124 * Returns:
125 * 0 on success, negative error number on error.
126 */
127int devm_pci_pwrctrl_device_set_ready(struct device *dev,
128 struct pci_pwrctrl *pwrctrl)
129{
130 int ret;
131
132 ret = pci_pwrctrl_device_set_ready(pwrctrl);
133 if (ret)
134 return ret;
135
136 return devm_add_action_or_reset(dev,
137 devm_pci_pwrctrl_device_unset_ready,
138 pwrctrl);
139}
140EXPORT_SYMBOL_GPL(devm_pci_pwrctrl_device_set_ready);
141
142/*
143 * Check whether the pwrctrl device really needs to be created or not. The
144 * pwrctrl device will only be created if the node satisfies below requirements:
145 *
146 * 1. Presence of compatible property with "pci" prefix to match against the
147 * pwrctrl driver (AND)
148 * 2. At least one of the power supplies defined in the devicetree node of the
149 * device (OR) in the remote endpoint parent node to indicate pwrctrl
150 * requirement.
151 */
152static bool pci_pwrctrl_is_required(struct device_node *np)
153{
154 struct device_node *endpoint;
155 const char *compat;
156 int ret;
157
158 ret = of_property_read_string(np, "compatible", &compat);
159 if (ret < 0)
160 return false;
161
162 if (!strstarts(compat, "pci"))
163 return false;
164
165 if (of_pci_supply_present(np))
166 return true;
167
168 if (of_graph_is_present(np)) {
169 for_each_endpoint_of_node(np, endpoint) {
170 struct device_node *remote __free(device_node) =
171 of_graph_get_remote_port_parent(endpoint);
172 if (remote) {
173 if (of_pci_supply_present(remote)) {
174 of_node_put(endpoint);
175 return true;
176 }
177 }
178 }
179 }
180
181 return false;
182}
183
184static int __pci_pwrctrl_power_off_device(struct device *dev)
185{
186 struct pci_pwrctrl *pwrctrl = dev_get_drvdata(dev);
187
188 if (!pwrctrl)
189 return 0;
190
191 return pwrctrl->power_off(pwrctrl);
192}
193
194static void pci_pwrctrl_power_off_device(struct device_node *np)
195{
196 struct platform_device *pdev;
197 int ret;
198
199 for_each_available_child_of_node_scoped(np, child)
200 pci_pwrctrl_power_off_device(child);
201
202 if (!pci_pwrctrl_is_required(np))
203 return;
204
205 pdev = of_find_device_by_node(np);
206 if (!pdev)
207 return;
208
209 scoped_guard(device, &pdev->dev) {
210 if (device_is_bound(&pdev->dev)) {
211 ret = __pci_pwrctrl_power_off_device(&pdev->dev);
212 if (ret)
213 dev_err(&pdev->dev, "Failed to power off device: %d", ret);
214 }
215 }
216
217 platform_device_put(pdev);
218}
219
220/**
221 * pci_pwrctrl_power_off_devices - Power off pwrctrl devices
222 *
223 * @parent: PCI host controller device
224 *
225 * Recursively traverse all pwrctrl devices for the devicetree hierarchy
226 * below the specified PCI host controller and power them off in a depth
227 * first manner.
228 */
229void pci_pwrctrl_power_off_devices(struct device *parent)
230{
231 struct device_node *np = parent->of_node;
232
233 for_each_available_child_of_node_scoped(np, child)
234 pci_pwrctrl_power_off_device(child);
235}
236EXPORT_SYMBOL_GPL(pci_pwrctrl_power_off_devices);
237
238static int __pci_pwrctrl_power_on_device(struct device *dev)
239{
240 struct pci_pwrctrl *pwrctrl = dev_get_drvdata(dev);
241
242 if (!pwrctrl)
243 return 0;
244
245 return pwrctrl->power_on(pwrctrl);
246}
247
248/*
249 * Power on the devices in a depth first manner. Before powering on the device,
250 * make sure its driver is bound.
251 */
252static int pci_pwrctrl_power_on_device(struct device_node *np)
253{
254 struct platform_device *pdev;
255 int ret = 0;
256
257 for_each_available_child_of_node_scoped(np, child) {
258 ret = pci_pwrctrl_power_on_device(child);
259 if (ret)
260 return ret;
261 }
262
263 if (!pci_pwrctrl_is_required(np))
264 return 0;
265
266 pdev = of_find_device_by_node(np);
267 if (!pdev)
268 return 0;
269
270 scoped_guard(device, &pdev->dev) {
271 if (device_is_bound(&pdev->dev)) {
272 ret = __pci_pwrctrl_power_on_device(&pdev->dev);
273 } else {
274 /* FIXME: Use blocking wait instead of probe deferral */
275 dev_dbg(&pdev->dev, "driver is not bound\n");
276 ret = -EPROBE_DEFER;
277 }
278 }
279
280 platform_device_put(pdev);
281
282 return ret;
283}
284
285/**
286 * pci_pwrctrl_power_on_devices - Power on pwrctrl devices
287 *
288 * @parent: PCI host controller device
289 *
290 * Recursively traverse all pwrctrl devices for the devicetree hierarchy
291 * below the specified PCI host controller and power them on in a depth
292 * first manner. On error, all powered on devices will be powered off.
293 *
294 * Return: 0 on success, -EPROBE_DEFER if any pwrctrl driver is not bound, an
295 * appropriate error code otherwise.
296 */
297int pci_pwrctrl_power_on_devices(struct device *parent)
298{
299 struct device_node *np = parent->of_node;
300 struct device_node *child = NULL;
301 int ret;
302
303 for_each_available_child_of_node(np, child) {
304 ret = pci_pwrctrl_power_on_device(child);
305 if (ret)
306 goto err_power_off;
307 }
308
309 return 0;
310
311err_power_off:
312 for_each_available_child_of_node_scoped(np, tmp) {
313 if (tmp == child)
314 break;
315 pci_pwrctrl_power_off_device(tmp);
316 }
317 of_node_put(child);
318
319 return ret;
320}
321EXPORT_SYMBOL_GPL(pci_pwrctrl_power_on_devices);
322
323static int pci_pwrctrl_create_device(struct device_node *np,
324 struct device *parent)
325{
326 struct platform_device *pdev;
327 int ret;
328
329 for_each_available_child_of_node_scoped(np, child) {
330 ret = pci_pwrctrl_create_device(child, parent);
331 if (ret)
332 return ret;
333 }
334
335 /* Bail out if the platform device is already available for the node */
336 pdev = of_find_device_by_node(np);
337 if (pdev) {
338 platform_device_put(pdev);
339 return 0;
340 }
341
342 if (!pci_pwrctrl_is_required(np)) {
343 dev_dbg(parent, "Skipping OF node: %s\n", np->name);
344 return 0;
345 }
346
347 /* Now create the pwrctrl device */
348 pdev = of_platform_device_create(np, NULL, parent);
349 if (!pdev) {
350 dev_err(parent, "Failed to create pwrctrl device for node: %s\n", np->name);
351 return -EINVAL;
352 }
353
354 return 0;
355}
356
357/**
358 * pci_pwrctrl_create_devices - Create pwrctrl devices
359 *
360 * @parent: PCI host controller device
361 *
362 * Recursively create pwrctrl devices for the devicetree hierarchy below
363 * the specified PCI host controller in a depth first manner. On error, all
364 * created devices will be destroyed.
365 *
366 * Return: 0 on success, negative error number on error.
367 */
368int pci_pwrctrl_create_devices(struct device *parent)
369{
370 int ret;
371
372 for_each_available_child_of_node_scoped(parent->of_node, child) {
373 ret = pci_pwrctrl_create_device(child, parent);
374 if (ret) {
375 pci_pwrctrl_destroy_devices(parent);
376 return ret;
377 }
378 }
379
380 return 0;
381}
382EXPORT_SYMBOL_GPL(pci_pwrctrl_create_devices);
383
384static void pci_pwrctrl_destroy_device(struct device_node *np)
385{
386 struct platform_device *pdev;
387
388 for_each_available_child_of_node_scoped(np, child)
389 pci_pwrctrl_destroy_device(child);
390
391 pdev = of_find_device_by_node(np);
392 if (!pdev)
393 return;
394
395 of_device_unregister(pdev);
396 platform_device_put(pdev);
397
398 of_node_clear_flag(np, OF_POPULATED);
399}
400
401/**
402 * pci_pwrctrl_destroy_devices - Destroy pwrctrl devices
403 *
404 * @parent: PCI host controller device
405 *
406 * Recursively destroy pwrctrl devices for the devicetree hierarchy below
407 * the specified PCI host controller in a depth first manner.
408 */
409void pci_pwrctrl_destroy_devices(struct device *parent)
410{
411 struct device_node *np = parent->of_node;
412
413 for_each_available_child_of_node_scoped(np, child)
414 pci_pwrctrl_destroy_device(child);
415}
416EXPORT_SYMBOL_GPL(pci_pwrctrl_destroy_devices);
417
418MODULE_AUTHOR("Bartosz Golaszewski <[email protected]>");
419MODULE_DESCRIPTION("PCI Device Power Control core driver");
420MODULE_LICENSE("GPL");