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->current_state == PCI_D3cold) {
51 pci_wakeup_event(pci_dev);
52 pm_runtime_resume(&pci_dev->dev);
53 return;
54 }
55
56
57 if (pci_dev->pme_support)
58 pci_check_pme_status(pci_dev);
59
60 if (pci_dev->pme_poll)
61 pci_dev->pme_poll = false;
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_info(&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 acpi_handle handle = NULL;
294
295 if (bus->bridge)
296 handle = ACPI_HANDLE(bus->bridge);
297 if (acpi_pci_disabled || handle == NULL)
298 return;
299
300 acpi_pci_slot_enumerate(bus, handle);
301 acpiphp_enumerate_slots(bus, handle);
302}
303
304void acpi_pci_remove_bus(struct pci_bus *bus)
305{
306
307
308
309
310 if (acpi_pci_disabled)
311 return;
312
313 acpiphp_remove_slots(bus);
314 acpi_pci_slot_remove(bus);
315}
316
317
318static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
319{
320 struct pci_dev *pci_dev = to_pci_dev(dev);
321 bool is_bridge;
322 u64 addr;
323
324
325
326
327
328
329 is_bridge = pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE
330 || pci_dev->hdr_type == PCI_HEADER_TYPE_CARDBUS;
331
332 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
333 *handle = acpi_find_child(ACPI_HANDLE(dev->parent), addr, is_bridge);
334 if (!*handle)
335 return -ENODEV;
336 return 0;
337}
338
339static void pci_acpi_setup(struct device *dev)
340{
341 struct pci_dev *pci_dev = to_pci_dev(dev);
342 acpi_handle handle = ACPI_HANDLE(dev);
343 struct acpi_device *adev;
344
345 if (acpi_bus_get_device(handle, &adev) || !adev->wakeup.flags.valid)
346 return;
347
348 device_set_wakeup_capable(dev, true);
349 acpi_pci_sleep_wake(pci_dev, false);
350
351 pci_acpi_add_pm_notifier(adev, pci_dev);
352 if (adev->wakeup.flags.run_wake)
353 device_set_run_wake(dev, true);
354}
355
356static void pci_acpi_cleanup(struct device *dev)
357{
358 acpi_handle handle = ACPI_HANDLE(dev);
359 struct acpi_device *adev;
360
361 if (!acpi_bus_get_device(handle, &adev) && adev->wakeup.flags.valid) {
362 device_set_wakeup_capable(dev, false);
363 device_set_run_wake(dev, false);
364 pci_acpi_remove_pm_notifier(adev);
365 }
366}
367
368static bool pci_acpi_bus_match(struct device *dev)
369{
370 return dev->bus == &pci_bus_type;
371}
372
373static struct acpi_bus_type acpi_pci_bus = {
374 .name = "PCI",
375 .match = pci_acpi_bus_match,
376 .find_device = acpi_pci_find_device,
377 .setup = pci_acpi_setup,
378 .cleanup = pci_acpi_cleanup,
379};
380
381static int __init acpi_pci_init(void)
382{
383 int ret;
384
385 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
386 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
387 pci_no_msi();
388 }
389
390 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
391 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
392 pcie_no_aspm();
393 }
394
395 ret = register_acpi_bus_type(&acpi_pci_bus);
396 if (ret)
397 return 0;
398
399 pci_set_platform_pm(&acpi_pci_platform_pm);
400 acpi_pci_slot_init();
401 acpiphp_init();
402
403 return 0;
404}
405arch_initcall(acpi_pci_init);
406