1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (C) 2024 Linaro Ltd.
*/
#include <linux/device.h>
#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/pci-pwrctl.h>
#include <linux/property.h>
#include <linux/slab.h>
static int pci_pwrctl_notify(struct notifier_block *nb, unsigned long action,
void *data)
{
struct pci_pwrctl *pwrctl = container_of(nb, struct pci_pwrctl, nb);
struct device *dev = data;
if (dev_fwnode(dev) != dev_fwnode(pwrctl->dev))
return NOTIFY_DONE;
switch (action) {
case BUS_NOTIFY_ADD_DEVICE:
/*
* We will have two struct device objects bound to two different
* drivers on different buses but consuming the same DT node. We
* must not bind the pins twice in this case but only once for
* the first device to be added.
*
* If we got here then the PCI device is the second after the
* power control platform device. Mark its OF node as reused.
*/
dev->of_node_reused = true;
break;
case BUS_NOTIFY_BOUND_DRIVER:
pwrctl->link = device_link_add(dev, pwrctl->dev,
DL_FLAG_AUTOREMOVE_CONSUMER);
if (!pwrctl->link)
dev_err(pwrctl->dev, "Failed to add device link\n");
break;
case BUS_NOTIFY_UNBOUND_DRIVER:
if (pwrctl->link)
device_link_remove(dev, pwrctl->dev);
break;
}
return NOTIFY_DONE;
}
static void rescan_work_func(struct work_struct *work)
{
struct pci_pwrctl *pwrctl = container_of(work, struct pci_pwrctl, work);
pci_lock_rescan_remove();
pci_rescan_bus(to_pci_dev(pwrctl->dev->parent)->bus);
pci_unlock_rescan_remove();
}
/**
* pci_pwrctl_init() - Initialize the PCI power control context struct
*
* @pwrctl: PCI power control data
* @dev: Parent device
*/
void pci_pwrctl_init(struct pci_pwrctl *pwrctl, struct device *dev)
{
pwrctl->dev = dev;
INIT_WORK(&pwrctl->work, rescan_work_func);
}
EXPORT_SYMBOL_GPL(pci_pwrctl_init);
/**
* pci_pwrctl_device_set_ready() - Notify the pwrctl subsystem that the PCI
* device is powered-up and ready to be detected.
*
* @pwrctl: PCI power control data.
*
* Returns:
* 0 on success, negative error number on error.
*
* Note:
* This function returning 0 doesn't mean the device was detected. It means,
* that the bus rescan was successfully started. The device will get bound to
* its PCI driver asynchronously.
*/
int pci_pwrctl_device_set_ready(struct pci_pwrctl *pwrctl)
{
int ret;
if (!pwrctl->dev)
return -ENODEV;
pwrctl->nb.notifier_call = pci_pwrctl_notify;
ret = bus_register_notifier(&pci_bus_type, &pwrctl->nb);
if (ret)
return ret;
schedule_work(&pwrctl->work);
return 0;
}
EXPORT_SYMBOL_GPL(pci_pwrctl_device_set_ready);
/**
* pci_pwrctl_device_unset_ready() - Notify the pwrctl subsystem that the PCI
* device is about to be powered-down.
*
* @pwrctl: PCI power control data.
*/
void pci_pwrctl_device_unset_ready(struct pci_pwrctl *pwrctl)
{
/*
* We don't have to delete the link here. Typically, this function
* is only called when the power control device is being detached. If
* it is being detached then the child PCI device must have already
* been unbound too or the device core wouldn't let us unbind.
*/
bus_unregister_notifier(&pci_bus_type, &pwrctl->nb);
}
EXPORT_SYMBOL_GPL(pci_pwrctl_device_unset_ready);
static void devm_pci_pwrctl_device_unset_ready(void *data)
{
struct pci_pwrctl *pwrctl = data;
pci_pwrctl_device_unset_ready(pwrctl);
}
/**
* devm_pci_pwrctl_device_set_ready - Managed variant of
* pci_pwrctl_device_set_ready().
*
* @dev: Device managing this pwrctl provider.
* @pwrctl: PCI power control data.
*
* Returns:
* 0 on success, negative error number on error.
*/
int devm_pci_pwrctl_device_set_ready(struct device *dev,
struct pci_pwrctl *pwrctl)
{
int ret;
ret = pci_pwrctl_device_set_ready(pwrctl);
if (ret)
return ret;
return devm_add_action_or_reset(dev,
devm_pci_pwrctl_device_unset_ready,
pwrctl);
}
EXPORT_SYMBOL_GPL(devm_pci_pwrctl_device_set_ready);
MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");
MODULE_DESCRIPTION("PCI Device Power Control core driver");
MODULE_LICENSE("GPL");
|
