1
2
3
4
5
6
7
8
9
10#include <linux/delay.h>
11#include <linux/init.h>
12#include <linux/pci.h>
13#include <linux/module.h>
14#include <linux/pci-aspm.h>
15#include <acpi/acpi.h>
16#include <acpi/acpi_bus.h>
17
18#include <linux/pci-acpi.h>
19#include <linux/pm_runtime.h>
20#include <linux/pm_qos.h>
21#include "pci.h"
22
23
24
25
26
27
28
29static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)
30{
31 struct pci_bus *pci_bus = context;
32
33 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)
34 pci_pme_wakeup_bus(pci_bus);
35}
36
37
38
39
40
41
42
43static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
44{
45 struct pci_dev *pci_dev = context;
46
47 if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev)
48 return;
49
50 if (pci_dev->pme_poll)
51 pci_dev->pme_poll = false;
52
53 if (pci_dev->current_state == PCI_D3cold) {
54 pci_wakeup_event(pci_dev);
55 pm_runtime_resume(&pci_dev->dev);
56 return;
57 }
58
59
60 if (pci_dev->pme_support)
61 pci_check_pme_status(pci_dev);
62
63 pci_wakeup_event(pci_dev);
64 pm_runtime_resume(&pci_dev->dev);
65
66 if (pci_dev->subordinate)
67 pci_pme_wakeup_bus(pci_dev->subordinate);
68}
69
70
71
72
73
74
75acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
76 struct pci_bus *pci_bus)
77{
78 return acpi_add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);
79}
80
81
82
83
84
85acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)
86{
87 return acpi_remove_pm_notifier(dev, pci_acpi_wake_bus);
88}
89
90
91
92
93
94
95acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
96 struct pci_dev *pci_dev)
97{
98 return acpi_add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);
99}
100
101
102
103
104
105acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)
106{
107 return acpi_remove_pm_notifier(dev, pci_acpi_wake_dev);
108}
109
110phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle)
111{
112 acpi_status status = AE_NOT_EXIST;
113 unsigned long long mcfg_addr;
114
115 if (handle)
116 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA,
117 NULL, &mcfg_addr);
118 if (ACPI_FAILURE(status))
119 return 0;
120
121 return (phys_addr_t)mcfg_addr;
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
147static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
148{
149 int acpi_state, d_max;
150
151 if (pdev->no_d3cold)
152 d_max = ACPI_STATE_D3_HOT;
153 else
154 d_max = ACPI_STATE_D3_COLD;
155 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max);
156 if (acpi_state < 0)
157 return PCI_POWER_ERROR;
158
159 switch (acpi_state) {
160 case ACPI_STATE_D0:
161 return PCI_D0;
162 case ACPI_STATE_D1:
163 return PCI_D1;
164 case ACPI_STATE_D2:
165 return PCI_D2;
166 case ACPI_STATE_D3_HOT:
167 return PCI_D3hot;
168 case ACPI_STATE_D3_COLD:
169 return PCI_D3cold;
170 }
171 return PCI_POWER_ERROR;
172}
173
174static bool acpi_pci_power_manageable(struct pci_dev *dev)
175{
176 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
177
178 return handle ? acpi_bus_power_manageable(handle) : false;
179}
180
181static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
182{
183 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
184 acpi_handle tmp;
185 static const u8 state_conv[] = {
186 [PCI_D0] = ACPI_STATE_D0,
187 [PCI_D1] = ACPI_STATE_D1,
188 [PCI_D2] = ACPI_STATE_D2,
189 [PCI_D3hot] = ACPI_STATE_D3_COLD,
190 [PCI_D3cold] = ACPI_STATE_D3_COLD,
191 };
192 int error = -EINVAL;
193
194
195 if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
196 return -ENODEV;
197
198 switch (state) {
199 case PCI_D3cold:
200 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) ==
201 PM_QOS_FLAGS_ALL) {
202 error = -EBUSY;
203 break;
204 }
205 case PCI_D0:
206 case PCI_D1:
207 case PCI_D2:
208 case PCI_D3hot:
209 error = acpi_bus_set_power(handle, state_conv[state]);
210 }
211
212 if (!error)
213 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
214 acpi_power_state_string(state_conv[state]));
215
216 return error;
217}
218
219static bool acpi_pci_can_wakeup(struct pci_dev *dev)
220{
221 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
222
223 return handle ? acpi_bus_can_wakeup(handle) : false;
224}
225
226static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
227{
228 while (bus->parent) {
229 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
230 return;
231 bus = bus->parent;
232 }
233
234
235 if (bus->bridge)
236 acpi_pm_device_sleep_wake(bus->bridge, enable);
237}
238
239static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
240{
241 if (acpi_pci_can_wakeup(dev))
242 return acpi_pm_device_sleep_wake(&dev->dev, enable);
243
244 acpi_pci_propagate_wakeup_enable(dev->bus, enable);
245 return 0;
246}
247
248static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
249{
250 while (bus->parent) {
251 struct pci_dev *bridge = bus->self;
252
253 if (bridge->pme_interrupt)
254 return;
255 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
256 return;
257 bus = bus->parent;
258 }
259
260
261 if (bus->bridge)
262 acpi_pm_device_run_wake(bus->bridge, enable);
263}
264
265static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
266{
267
268
269
270
271
272
273 if (dev->pme_interrupt && !dev->runtime_d3cold)
274 return 0;
275
276 if (!acpi_pm_device_run_wake(&dev->dev, enable))
277 return 0;
278
279 acpi_pci_propagate_run_wake(dev->bus, enable);
280 return 0;
281}
282
283static struct pci_platform_pm_ops acpi_pci_platform_pm = {
284 .is_manageable = acpi_pci_power_manageable,
285 .set_state = acpi_pci_set_power_state,
286 .choose_state = acpi_pci_choose_state,
287 .sleep_wake = acpi_pci_sleep_wake,
288 .run_wake = acpi_pci_run_wake,
289};
290
291void acpi_pci_add_bus(struct pci_bus *bus)
292{
293 if (acpi_pci_disabled || !bus->bridge)
294 return;
295
296 acpi_pci_slot_enumerate(bus);
297 acpiphp_enumerate_slots(bus);
298}
299
300void acpi_pci_remove_bus(struct pci_bus *bus)
301{
302 if (acpi_pci_disabled || !bus->bridge)
303 return;
304
305 acpiphp_remove_slots(bus);
306 acpi_pci_slot_remove(bus);
307}
308
309
310static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
311{
312 struct pci_dev *pci_dev = to_pci_dev(dev);
313 bool is_bridge;
314 u64 addr;
315
316
317
318
319
320
321 is_bridge = pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE
322 || pci_dev->hdr_type == PCI_HEADER_TYPE_CARDBUS;
323
324 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
325 *handle = acpi_find_child(ACPI_HANDLE(dev->parent), addr, is_bridge);
326 if (!*handle)
327 return -ENODEV;
328 return 0;
329}
330
331static void pci_acpi_setup(struct device *dev)
332{
333 struct pci_dev *pci_dev = to_pci_dev(dev);
334 acpi_handle handle = ACPI_HANDLE(dev);
335 struct acpi_device *adev;
336
337 if (acpi_bus_get_device(handle, &adev) || !adev->wakeup.flags.valid)
338 return;
339
340 device_set_wakeup_capable(dev, true);
341 acpi_pci_sleep_wake(pci_dev, false);
342
343 pci_acpi_add_pm_notifier(adev, pci_dev);
344 if (adev->wakeup.flags.run_wake)
345 device_set_run_wake(dev, true);
346}
347
348static void pci_acpi_cleanup(struct device *dev)
349{
350 acpi_handle handle = ACPI_HANDLE(dev);
351 struct acpi_device *adev;
352
353 if (!acpi_bus_get_device(handle, &adev) && adev->wakeup.flags.valid) {
354 device_set_wakeup_capable(dev, false);
355 device_set_run_wake(dev, false);
356 pci_acpi_remove_pm_notifier(adev);
357 }
358}
359
360static bool pci_acpi_bus_match(struct device *dev)
361{
362 return dev->bus == &pci_bus_type;
363}
364
365static struct acpi_bus_type acpi_pci_bus = {
366 .name = "PCI",
367 .match = pci_acpi_bus_match,
368 .find_device = acpi_pci_find_device,
369 .setup = pci_acpi_setup,
370 .cleanup = pci_acpi_cleanup,
371};
372
373static int __init acpi_pci_init(void)
374{
375 int ret;
376
377 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
378 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
379 pci_no_msi();
380 }
381
382 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
383 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
384 pcie_no_aspm();
385 }
386
387 ret = register_acpi_bus_type(&acpi_pci_bus);
388 if (ret)
389 return 0;
390
391 pci_set_platform_pm(&acpi_pci_platform_pm);
392 acpi_pci_slot_init();
393 acpiphp_init();
394
395 return 0;
396}
397arch_initcall(acpi_pci_init);
398