Loading...
1/*
2 * File: pci-acpi.c
3 * Purpose: Provide PCI support in ACPI
4 *
5 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
6 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
7 * Copyright (C) 2004 Intel Corp.
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 "pci.h"
21
22static DEFINE_MUTEX(pci_acpi_pm_notify_mtx);
23
24/**
25 * pci_acpi_wake_bus - Wake-up notification handler for root buses.
26 * @handle: ACPI handle of a device the notification is for.
27 * @event: Type of the signaled event.
28 * @context: PCI root bus to wake up devices on.
29 */
30static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)
31{
32 struct pci_bus *pci_bus = context;
33
34 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)
35 pci_pme_wakeup_bus(pci_bus);
36}
37
38/**
39 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices.
40 * @handle: ACPI handle of a device the notification is for.
41 * @event: Type of the signaled event.
42 * @context: PCI device object to wake up.
43 */
44static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
45{
46 struct pci_dev *pci_dev = context;
47
48 if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev)
49 return;
50
51 if (!pci_dev->pm_cap || !pci_dev->pme_support
52 || pci_check_pme_status(pci_dev)) {
53 if (pci_dev->pme_poll)
54 pci_dev->pme_poll = false;
55
56 pci_wakeup_event(pci_dev);
57 pm_runtime_resume(&pci_dev->dev);
58 }
59
60 if (pci_dev->subordinate)
61 pci_pme_wakeup_bus(pci_dev->subordinate);
62}
63
64/**
65 * add_pm_notifier - Register PM notifier for given ACPI device.
66 * @dev: ACPI device to add the notifier for.
67 * @context: PCI device or bus to check for PME status if an event is signaled.
68 *
69 * NOTE: @dev need not be a run-wake or wake-up device to be a valid source of
70 * PM wake-up events. For example, wake-up events may be generated for bridges
71 * if one of the devices below the bridge is signaling PME, even if the bridge
72 * itself doesn't have a wake-up GPE associated with it.
73 */
74static acpi_status add_pm_notifier(struct acpi_device *dev,
75 acpi_notify_handler handler,
76 void *context)
77{
78 acpi_status status = AE_ALREADY_EXISTS;
79
80 mutex_lock(&pci_acpi_pm_notify_mtx);
81
82 if (dev->wakeup.flags.notifier_present)
83 goto out;
84
85 status = acpi_install_notify_handler(dev->handle,
86 ACPI_SYSTEM_NOTIFY,
87 handler, context);
88 if (ACPI_FAILURE(status))
89 goto out;
90
91 dev->wakeup.flags.notifier_present = true;
92
93 out:
94 mutex_unlock(&pci_acpi_pm_notify_mtx);
95 return status;
96}
97
98/**
99 * remove_pm_notifier - Unregister PM notifier from given ACPI device.
100 * @dev: ACPI device to remove the notifier from.
101 */
102static acpi_status remove_pm_notifier(struct acpi_device *dev,
103 acpi_notify_handler handler)
104{
105 acpi_status status = AE_BAD_PARAMETER;
106
107 mutex_lock(&pci_acpi_pm_notify_mtx);
108
109 if (!dev->wakeup.flags.notifier_present)
110 goto out;
111
112 status = acpi_remove_notify_handler(dev->handle,
113 ACPI_SYSTEM_NOTIFY,
114 handler);
115 if (ACPI_FAILURE(status))
116 goto out;
117
118 dev->wakeup.flags.notifier_present = false;
119
120 out:
121 mutex_unlock(&pci_acpi_pm_notify_mtx);
122 return status;
123}
124
125/**
126 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus.
127 * @dev: ACPI device to add the notifier for.
128 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled.
129 */
130acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
131 struct pci_bus *pci_bus)
132{
133 return add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);
134}
135
136/**
137 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier.
138 * @dev: ACPI device to remove the notifier from.
139 */
140acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)
141{
142 return remove_pm_notifier(dev, pci_acpi_wake_bus);
143}
144
145/**
146 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
147 * @dev: ACPI device to add the notifier for.
148 * @pci_dev: PCI device to check for the PME status if an event is signaled.
149 */
150acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
151 struct pci_dev *pci_dev)
152{
153 return add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);
154}
155
156/**
157 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier.
158 * @dev: ACPI device to remove the notifier from.
159 */
160acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)
161{
162 return remove_pm_notifier(dev, pci_acpi_wake_dev);
163}
164
165/*
166 * _SxD returns the D-state with the highest power
167 * (lowest D-state number) supported in the S-state "x".
168 *
169 * If the devices does not have a _PRW
170 * (Power Resources for Wake) supporting system wakeup from "x"
171 * then the OS is free to choose a lower power (higher number
172 * D-state) than the return value from _SxD.
173 *
174 * But if _PRW is enabled at S-state "x", the OS
175 * must not choose a power lower than _SxD --
176 * unless the device has an _SxW method specifying
177 * the lowest power (highest D-state number) the device
178 * may enter while still able to wake the system.
179 *
180 * ie. depending on global OS policy:
181 *
182 * if (_PRW at S-state x)
183 * choose from highest power _SxD to lowest power _SxW
184 * else // no _PRW at S-state x
185 * choose highest power _SxD or any lower power
186 */
187
188static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
189{
190 int acpi_state;
191
192 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL);
193 if (acpi_state < 0)
194 return PCI_POWER_ERROR;
195
196 switch (acpi_state) {
197 case ACPI_STATE_D0:
198 return PCI_D0;
199 case ACPI_STATE_D1:
200 return PCI_D1;
201 case ACPI_STATE_D2:
202 return PCI_D2;
203 case ACPI_STATE_D3_HOT:
204 return PCI_D3hot;
205 case ACPI_STATE_D3_COLD:
206 return PCI_D3cold;
207 }
208 return PCI_POWER_ERROR;
209}
210
211static bool acpi_pci_power_manageable(struct pci_dev *dev)
212{
213 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
214
215 return handle ? acpi_bus_power_manageable(handle) : false;
216}
217
218static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
219{
220 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
221 acpi_handle tmp;
222 static const u8 state_conv[] = {
223 [PCI_D0] = ACPI_STATE_D0,
224 [PCI_D1] = ACPI_STATE_D1,
225 [PCI_D2] = ACPI_STATE_D2,
226 [PCI_D3hot] = ACPI_STATE_D3,
227 [PCI_D3cold] = ACPI_STATE_D3
228 };
229 int error = -EINVAL;
230
231 /* If the ACPI device has _EJ0, ignore the device */
232 if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
233 return -ENODEV;
234
235 switch (state) {
236 case PCI_D0:
237 case PCI_D1:
238 case PCI_D2:
239 case PCI_D3hot:
240 case PCI_D3cold:
241 error = acpi_bus_set_power(handle, state_conv[state]);
242 }
243
244 if (!error)
245 dev_printk(KERN_INFO, &dev->dev,
246 "power state changed by ACPI to D%d\n", state);
247
248 return error;
249}
250
251static bool acpi_pci_can_wakeup(struct pci_dev *dev)
252{
253 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
254
255 return handle ? acpi_bus_can_wakeup(handle) : false;
256}
257
258static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
259{
260 while (bus->parent) {
261 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
262 return;
263 bus = bus->parent;
264 }
265
266 /* We have reached the root bus. */
267 if (bus->bridge)
268 acpi_pm_device_sleep_wake(bus->bridge, enable);
269}
270
271static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
272{
273 if (acpi_pci_can_wakeup(dev))
274 return acpi_pm_device_sleep_wake(&dev->dev, enable);
275
276 acpi_pci_propagate_wakeup_enable(dev->bus, enable);
277 return 0;
278}
279
280static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
281{
282 while (bus->parent) {
283 struct pci_dev *bridge = bus->self;
284
285 if (bridge->pme_interrupt)
286 return;
287 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
288 return;
289 bus = bus->parent;
290 }
291
292 /* We have reached the root bus. */
293 if (bus->bridge)
294 acpi_pm_device_run_wake(bus->bridge, enable);
295}
296
297static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
298{
299 if (dev->pme_interrupt)
300 return 0;
301
302 if (!acpi_pm_device_run_wake(&dev->dev, enable))
303 return 0;
304
305 acpi_pci_propagate_run_wake(dev->bus, enable);
306 return 0;
307}
308
309static struct pci_platform_pm_ops acpi_pci_platform_pm = {
310 .is_manageable = acpi_pci_power_manageable,
311 .set_state = acpi_pci_set_power_state,
312 .choose_state = acpi_pci_choose_state,
313 .can_wakeup = acpi_pci_can_wakeup,
314 .sleep_wake = acpi_pci_sleep_wake,
315 .run_wake = acpi_pci_run_wake,
316};
317
318/* ACPI bus type */
319static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
320{
321 struct pci_dev * pci_dev;
322 u64 addr;
323
324 pci_dev = to_pci_dev(dev);
325 /* Please ref to ACPI spec for the syntax of _ADR */
326 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
327 *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
328 if (!*handle)
329 return -ENODEV;
330 return 0;
331}
332
333static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
334{
335 int num;
336 unsigned int seg, bus;
337
338 /*
339 * The string should be the same as root bridge's name
340 * Please look at 'pci_scan_bus_parented'
341 */
342 num = sscanf(dev_name(dev), "pci%04x:%02x", &seg, &bus);
343 if (num != 2)
344 return -ENODEV;
345 *handle = acpi_get_pci_rootbridge_handle(seg, bus);
346 if (!*handle)
347 return -ENODEV;
348 return 0;
349}
350
351static struct acpi_bus_type acpi_pci_bus = {
352 .bus = &pci_bus_type,
353 .find_device = acpi_pci_find_device,
354 .find_bridge = acpi_pci_find_root_bridge,
355};
356
357static int __init acpi_pci_init(void)
358{
359 int ret;
360
361 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
362 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
363 pci_no_msi();
364 }
365
366 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
367 printk(KERN_INFO"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
368 pcie_no_aspm();
369 }
370
371 ret = register_acpi_bus_type(&acpi_pci_bus);
372 if (ret)
373 return 0;
374 pci_set_platform_pm(&acpi_pci_platform_pm);
375 return 0;
376}
377arch_initcall(acpi_pci_init);
1/*
2 * File: pci-acpi.c
3 * Purpose: Provide PCI support in ACPI
4 *
5 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
6 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
7 * Copyright (C) 2004 Intel Corp.
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 <linux/pci-acpi.h>
16#include <linux/pm_runtime.h>
17#include <linux/pm_qos.h>
18#include "pci.h"
19
20/**
21 * pci_acpi_wake_bus - Wake-up notification handler for root buses.
22 * @handle: ACPI handle of a device the notification is for.
23 * @event: Type of the signaled event.
24 * @context: PCI root bus to wake up devices on.
25 */
26static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)
27{
28 struct pci_bus *pci_bus = context;
29
30 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)
31 pci_pme_wakeup_bus(pci_bus);
32}
33
34/**
35 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices.
36 * @handle: ACPI handle of a device the notification is for.
37 * @event: Type of the signaled event.
38 * @context: PCI device object to wake up.
39 */
40static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
41{
42 struct pci_dev *pci_dev = context;
43
44 if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev)
45 return;
46
47 if (pci_dev->pme_poll)
48 pci_dev->pme_poll = false;
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 /* Clear PME Status if set. */
57 if (pci_dev->pme_support)
58 pci_check_pme_status(pci_dev);
59
60 pci_wakeup_event(pci_dev);
61 pm_runtime_resume(&pci_dev->dev);
62
63 if (pci_dev->subordinate)
64 pci_pme_wakeup_bus(pci_dev->subordinate);
65}
66
67/**
68 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus.
69 * @dev: ACPI device to add the notifier for.
70 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled.
71 */
72acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
73 struct pci_bus *pci_bus)
74{
75 return acpi_add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);
76}
77
78/**
79 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier.
80 * @dev: ACPI device to remove the notifier from.
81 */
82acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)
83{
84 return acpi_remove_pm_notifier(dev, pci_acpi_wake_bus);
85}
86
87/**
88 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
89 * @dev: ACPI device to add the notifier for.
90 * @pci_dev: PCI device to check for the PME status if an event is signaled.
91 */
92acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
93 struct pci_dev *pci_dev)
94{
95 return acpi_add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);
96}
97
98/**
99 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier.
100 * @dev: ACPI device to remove the notifier from.
101 */
102acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)
103{
104 return acpi_remove_pm_notifier(dev, pci_acpi_wake_dev);
105}
106
107phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle)
108{
109 acpi_status status = AE_NOT_EXIST;
110 unsigned long long mcfg_addr;
111
112 if (handle)
113 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA,
114 NULL, &mcfg_addr);
115 if (ACPI_FAILURE(status))
116 return 0;
117
118 return (phys_addr_t)mcfg_addr;
119}
120
121/*
122 * _SxD returns the D-state with the highest power
123 * (lowest D-state number) supported in the S-state "x".
124 *
125 * If the devices does not have a _PRW
126 * (Power Resources for Wake) supporting system wakeup from "x"
127 * then the OS is free to choose a lower power (higher number
128 * D-state) than the return value from _SxD.
129 *
130 * But if _PRW is enabled at S-state "x", the OS
131 * must not choose a power lower than _SxD --
132 * unless the device has an _SxW method specifying
133 * the lowest power (highest D-state number) the device
134 * may enter while still able to wake the system.
135 *
136 * ie. depending on global OS policy:
137 *
138 * if (_PRW at S-state x)
139 * choose from highest power _SxD to lowest power _SxW
140 * else // no _PRW at S-state x
141 * choose highest power _SxD or any lower power
142 */
143
144static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
145{
146 int acpi_state, d_max;
147
148 if (pdev->no_d3cold)
149 d_max = ACPI_STATE_D3_HOT;
150 else
151 d_max = ACPI_STATE_D3_COLD;
152 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max);
153 if (acpi_state < 0)
154 return PCI_POWER_ERROR;
155
156 switch (acpi_state) {
157 case ACPI_STATE_D0:
158 return PCI_D0;
159 case ACPI_STATE_D1:
160 return PCI_D1;
161 case ACPI_STATE_D2:
162 return PCI_D2;
163 case ACPI_STATE_D3_HOT:
164 return PCI_D3hot;
165 case ACPI_STATE_D3_COLD:
166 return PCI_D3cold;
167 }
168 return PCI_POWER_ERROR;
169}
170
171static bool acpi_pci_power_manageable(struct pci_dev *dev)
172{
173 acpi_handle handle = ACPI_HANDLE(&dev->dev);
174
175 return handle ? acpi_bus_power_manageable(handle) : false;
176}
177
178static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
179{
180 acpi_handle handle = ACPI_HANDLE(&dev->dev);
181 static const u8 state_conv[] = {
182 [PCI_D0] = ACPI_STATE_D0,
183 [PCI_D1] = ACPI_STATE_D1,
184 [PCI_D2] = ACPI_STATE_D2,
185 [PCI_D3hot] = ACPI_STATE_D3_COLD,
186 [PCI_D3cold] = ACPI_STATE_D3_COLD,
187 };
188 int error = -EINVAL;
189
190 /* If the ACPI device has _EJ0, ignore the device */
191 if (!handle || acpi_has_method(handle, "_EJ0"))
192 return -ENODEV;
193
194 switch (state) {
195 case PCI_D3cold:
196 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) ==
197 PM_QOS_FLAGS_ALL) {
198 error = -EBUSY;
199 break;
200 }
201 case PCI_D0:
202 case PCI_D1:
203 case PCI_D2:
204 case PCI_D3hot:
205 error = acpi_bus_set_power(handle, state_conv[state]);
206 }
207
208 if (!error)
209 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
210 acpi_power_state_string(state_conv[state]));
211
212 return error;
213}
214
215static bool acpi_pci_can_wakeup(struct pci_dev *dev)
216{
217 acpi_handle handle = ACPI_HANDLE(&dev->dev);
218
219 return handle ? acpi_bus_can_wakeup(handle) : false;
220}
221
222static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
223{
224 while (bus->parent) {
225 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
226 return;
227 bus = bus->parent;
228 }
229
230 /* We have reached the root bus. */
231 if (bus->bridge)
232 acpi_pm_device_sleep_wake(bus->bridge, enable);
233}
234
235static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
236{
237 if (acpi_pci_can_wakeup(dev))
238 return acpi_pm_device_sleep_wake(&dev->dev, enable);
239
240 acpi_pci_propagate_wakeup_enable(dev->bus, enable);
241 return 0;
242}
243
244static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
245{
246 while (bus->parent) {
247 struct pci_dev *bridge = bus->self;
248
249 if (bridge->pme_interrupt)
250 return;
251 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
252 return;
253 bus = bus->parent;
254 }
255
256 /* We have reached the root bus. */
257 if (bus->bridge)
258 acpi_pm_device_run_wake(bus->bridge, enable);
259}
260
261static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
262{
263 /*
264 * Per PCI Express Base Specification Revision 2.0 section
265 * 5.3.3.2 Link Wakeup, platform support is needed for D3cold
266 * waking up to power on the main link even if there is PME
267 * support for D3cold
268 */
269 if (dev->pme_interrupt && !dev->runtime_d3cold)
270 return 0;
271
272 if (!acpi_pm_device_run_wake(&dev->dev, enable))
273 return 0;
274
275 acpi_pci_propagate_run_wake(dev->bus, enable);
276 return 0;
277}
278
279static struct pci_platform_pm_ops acpi_pci_platform_pm = {
280 .is_manageable = acpi_pci_power_manageable,
281 .set_state = acpi_pci_set_power_state,
282 .choose_state = acpi_pci_choose_state,
283 .sleep_wake = acpi_pci_sleep_wake,
284 .run_wake = acpi_pci_run_wake,
285};
286
287void acpi_pci_add_bus(struct pci_bus *bus)
288{
289 if (acpi_pci_disabled || !bus->bridge)
290 return;
291
292 acpi_pci_slot_enumerate(bus);
293 acpiphp_enumerate_slots(bus);
294}
295
296void acpi_pci_remove_bus(struct pci_bus *bus)
297{
298 if (acpi_pci_disabled || !bus->bridge)
299 return;
300
301 acpiphp_remove_slots(bus);
302 acpi_pci_slot_remove(bus);
303}
304
305/* ACPI bus type */
306static struct acpi_device *acpi_pci_find_companion(struct device *dev)
307{
308 struct pci_dev *pci_dev = to_pci_dev(dev);
309 bool check_children;
310 u64 addr;
311
312 /*
313 * pci_is_bridge() is not suitable here, because pci_dev->subordinate
314 * is set only after acpi_pci_find_device() has been called for the
315 * given device.
316 */
317 check_children = pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE
318 || pci_dev->hdr_type == PCI_HEADER_TYPE_CARDBUS;
319 /* Please ref to ACPI spec for the syntax of _ADR */
320 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
321 return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr,
322 check_children);
323}
324
325static void pci_acpi_setup(struct device *dev)
326{
327 struct pci_dev *pci_dev = to_pci_dev(dev);
328 struct acpi_device *adev = ACPI_COMPANION(dev);
329
330 if (!adev)
331 return;
332
333 pci_acpi_add_pm_notifier(adev, pci_dev);
334 if (!adev->wakeup.flags.valid)
335 return;
336
337 device_set_wakeup_capable(dev, true);
338 acpi_pci_sleep_wake(pci_dev, false);
339 if (adev->wakeup.flags.run_wake)
340 device_set_run_wake(dev, true);
341}
342
343static void pci_acpi_cleanup(struct device *dev)
344{
345 struct acpi_device *adev = ACPI_COMPANION(dev);
346
347 if (!adev)
348 return;
349
350 pci_acpi_remove_pm_notifier(adev);
351 if (adev->wakeup.flags.valid) {
352 device_set_wakeup_capable(dev, false);
353 device_set_run_wake(dev, false);
354 }
355}
356
357static bool pci_acpi_bus_match(struct device *dev)
358{
359 return dev_is_pci(dev);
360}
361
362static struct acpi_bus_type acpi_pci_bus = {
363 .name = "PCI",
364 .match = pci_acpi_bus_match,
365 .find_companion = acpi_pci_find_companion,
366 .setup = pci_acpi_setup,
367 .cleanup = pci_acpi_cleanup,
368};
369
370static int __init acpi_pci_init(void)
371{
372 int ret;
373
374 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
375 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
376 pci_no_msi();
377 }
378
379 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
380 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
381 pcie_no_aspm();
382 }
383
384 ret = register_acpi_bus_type(&acpi_pci_bus);
385 if (ret)
386 return 0;
387
388 pci_set_platform_pm(&acpi_pci_platform_pm);
389 acpi_pci_slot_init();
390 acpiphp_init();
391
392 return 0;
393}
394arch_initcall(acpi_pci_init);