3 * Purpose: Provide PCI support in ACPI
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.
10 #include <linux/delay.h>
11 #include <linux/init.h>
12 #include <linux/irqdomain.h>
13 #include <linux/pci.h>
14 #include <linux/msi.h>
15 #include <linux/pci_hotplug.h>
16 #include <linux/module.h>
17 #include <linux/pci-aspm.h>
18 #include <linux/pci-acpi.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/pm_qos.h>
24 * The GUID is defined in the PCI Firmware Specification available here:
25 * https://www.pcisig.com/members/downloads/pcifw_r3_1_13Dec10.pdf
27 const guid_t pci_acpi_dsm_guid
=
28 GUID_INIT(0xe5c937d0, 0x3553, 0x4d7a,
29 0x91, 0x17, 0xea, 0x4d, 0x19, 0xc3, 0x43, 0x4d);
31 #if defined(CONFIG_PCI_QUIRKS) && defined(CONFIG_ARM64)
32 static int acpi_get_rc_addr(struct acpi_device
*adev
, struct resource
*res
)
34 struct device
*dev
= &adev
->dev
;
35 struct resource_entry
*entry
;
36 struct list_head list
;
40 INIT_LIST_HEAD(&list
);
41 flags
= IORESOURCE_MEM
;
42 ret
= acpi_dev_get_resources(adev
, &list
,
43 acpi_dev_filter_resource_type_cb
,
46 dev_err(dev
, "failed to parse _CRS method, error code %d\n",
52 dev_err(dev
, "no IO and memory resources present in _CRS\n");
56 entry
= list_first_entry(&list
, struct resource_entry
, node
);
58 acpi_dev_free_resource_list(&list
);
62 static acpi_status
acpi_match_rc(acpi_handle handle
, u32 lvl
, void *context
,
65 u16
*segment
= context
;
66 unsigned long long uid
;
69 status
= acpi_evaluate_integer(handle
, "_UID", NULL
, &uid
);
70 if (ACPI_FAILURE(status
) || uid
!= *segment
)
73 *(acpi_handle
*)retval
= handle
;
74 return AE_CTRL_TERMINATE
;
77 int acpi_get_rc_resources(struct device
*dev
, const char *hid
, u16 segment
,
80 struct acpi_device
*adev
;
85 status
= acpi_get_devices(hid
, acpi_match_rc
, &segment
, &handle
);
86 if (ACPI_FAILURE(status
)) {
87 dev_err(dev
, "can't find _HID %s device to locate resources\n",
92 ret
= acpi_bus_get_device(handle
, &adev
);
96 ret
= acpi_get_rc_addr(adev
, res
);
98 dev_err(dev
, "can't get resource from %s\n",
99 dev_name(&adev
->dev
));
107 phys_addr_t
acpi_pci_root_get_mcfg_addr(acpi_handle handle
)
109 acpi_status status
= AE_NOT_EXIST
;
110 unsigned long long mcfg_addr
;
113 status
= acpi_evaluate_integer(handle
, METHOD_NAME__CBA
,
115 if (ACPI_FAILURE(status
))
118 return (phys_addr_t
)mcfg_addr
;
121 static acpi_status
decode_type0_hpx_record(union acpi_object
*record
,
122 struct hotplug_params
*hpx
)
125 union acpi_object
*fields
= record
->package
.elements
;
126 u32 revision
= fields
[1].integer
.value
;
130 if (record
->package
.count
!= 6)
132 for (i
= 2; i
< 6; i
++)
133 if (fields
[i
].type
!= ACPI_TYPE_INTEGER
)
135 hpx
->t0
= &hpx
->type0_data
;
136 hpx
->t0
->revision
= revision
;
137 hpx
->t0
->cache_line_size
= fields
[2].integer
.value
;
138 hpx
->t0
->latency_timer
= fields
[3].integer
.value
;
139 hpx
->t0
->enable_serr
= fields
[4].integer
.value
;
140 hpx
->t0
->enable_perr
= fields
[5].integer
.value
;
144 "%s: Type 0 Revision %d record not supported\n",
151 static acpi_status
decode_type1_hpx_record(union acpi_object
*record
,
152 struct hotplug_params
*hpx
)
155 union acpi_object
*fields
= record
->package
.elements
;
156 u32 revision
= fields
[1].integer
.value
;
160 if (record
->package
.count
!= 5)
162 for (i
= 2; i
< 5; i
++)
163 if (fields
[i
].type
!= ACPI_TYPE_INTEGER
)
165 hpx
->t1
= &hpx
->type1_data
;
166 hpx
->t1
->revision
= revision
;
167 hpx
->t1
->max_mem_read
= fields
[2].integer
.value
;
168 hpx
->t1
->avg_max_split
= fields
[3].integer
.value
;
169 hpx
->t1
->tot_max_split
= fields
[4].integer
.value
;
173 "%s: Type 1 Revision %d record not supported\n",
180 static acpi_status
decode_type2_hpx_record(union acpi_object
*record
,
181 struct hotplug_params
*hpx
)
184 union acpi_object
*fields
= record
->package
.elements
;
185 u32 revision
= fields
[1].integer
.value
;
189 if (record
->package
.count
!= 18)
191 for (i
= 2; i
< 18; i
++)
192 if (fields
[i
].type
!= ACPI_TYPE_INTEGER
)
194 hpx
->t2
= &hpx
->type2_data
;
195 hpx
->t2
->revision
= revision
;
196 hpx
->t2
->unc_err_mask_and
= fields
[2].integer
.value
;
197 hpx
->t2
->unc_err_mask_or
= fields
[3].integer
.value
;
198 hpx
->t2
->unc_err_sever_and
= fields
[4].integer
.value
;
199 hpx
->t2
->unc_err_sever_or
= fields
[5].integer
.value
;
200 hpx
->t2
->cor_err_mask_and
= fields
[6].integer
.value
;
201 hpx
->t2
->cor_err_mask_or
= fields
[7].integer
.value
;
202 hpx
->t2
->adv_err_cap_and
= fields
[8].integer
.value
;
203 hpx
->t2
->adv_err_cap_or
= fields
[9].integer
.value
;
204 hpx
->t2
->pci_exp_devctl_and
= fields
[10].integer
.value
;
205 hpx
->t2
->pci_exp_devctl_or
= fields
[11].integer
.value
;
206 hpx
->t2
->pci_exp_lnkctl_and
= fields
[12].integer
.value
;
207 hpx
->t2
->pci_exp_lnkctl_or
= fields
[13].integer
.value
;
208 hpx
->t2
->sec_unc_err_sever_and
= fields
[14].integer
.value
;
209 hpx
->t2
->sec_unc_err_sever_or
= fields
[15].integer
.value
;
210 hpx
->t2
->sec_unc_err_mask_and
= fields
[16].integer
.value
;
211 hpx
->t2
->sec_unc_err_mask_or
= fields
[17].integer
.value
;
215 "%s: Type 2 Revision %d record not supported\n",
222 static acpi_status
acpi_run_hpx(acpi_handle handle
, struct hotplug_params
*hpx
)
225 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
226 union acpi_object
*package
, *record
, *fields
;
230 /* Clear the return buffer with zeros */
231 memset(hpx
, 0, sizeof(struct hotplug_params
));
233 status
= acpi_evaluate_object(handle
, "_HPX", NULL
, &buffer
);
234 if (ACPI_FAILURE(status
))
237 package
= (union acpi_object
*)buffer
.pointer
;
238 if (package
->type
!= ACPI_TYPE_PACKAGE
) {
243 for (i
= 0; i
< package
->package
.count
; i
++) {
244 record
= &package
->package
.elements
[i
];
245 if (record
->type
!= ACPI_TYPE_PACKAGE
) {
250 fields
= record
->package
.elements
;
251 if (fields
[0].type
!= ACPI_TYPE_INTEGER
||
252 fields
[1].type
!= ACPI_TYPE_INTEGER
) {
257 type
= fields
[0].integer
.value
;
260 status
= decode_type0_hpx_record(record
, hpx
);
261 if (ACPI_FAILURE(status
))
265 status
= decode_type1_hpx_record(record
, hpx
);
266 if (ACPI_FAILURE(status
))
270 status
= decode_type2_hpx_record(record
, hpx
);
271 if (ACPI_FAILURE(status
))
275 printk(KERN_ERR
"%s: Type %d record not supported\n",
282 kfree(buffer
.pointer
);
286 static acpi_status
acpi_run_hpp(acpi_handle handle
, struct hotplug_params
*hpp
)
289 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
290 union acpi_object
*package
, *fields
;
293 memset(hpp
, 0, sizeof(struct hotplug_params
));
295 status
= acpi_evaluate_object(handle
, "_HPP", NULL
, &buffer
);
296 if (ACPI_FAILURE(status
))
299 package
= (union acpi_object
*) buffer
.pointer
;
300 if (package
->type
!= ACPI_TYPE_PACKAGE
||
301 package
->package
.count
!= 4) {
306 fields
= package
->package
.elements
;
307 for (i
= 0; i
< 4; i
++) {
308 if (fields
[i
].type
!= ACPI_TYPE_INTEGER
) {
314 hpp
->t0
= &hpp
->type0_data
;
315 hpp
->t0
->revision
= 1;
316 hpp
->t0
->cache_line_size
= fields
[0].integer
.value
;
317 hpp
->t0
->latency_timer
= fields
[1].integer
.value
;
318 hpp
->t0
->enable_serr
= fields
[2].integer
.value
;
319 hpp
->t0
->enable_perr
= fields
[3].integer
.value
;
322 kfree(buffer
.pointer
);
328 * @dev - the pci_dev for which we want parameters
329 * @hpp - allocated by the caller
331 int pci_get_hp_params(struct pci_dev
*dev
, struct hotplug_params
*hpp
)
334 acpi_handle handle
, phandle
;
335 struct pci_bus
*pbus
;
337 if (acpi_pci_disabled
)
341 for (pbus
= dev
->bus
; pbus
; pbus
= pbus
->parent
) {
342 handle
= acpi_pci_get_bridge_handle(pbus
);
348 * _HPP settings apply to all child buses, until another _HPP is
349 * encountered. If we don't find an _HPP for the input pci dev,
350 * look for it in the parent device scope since that would apply to
354 status
= acpi_run_hpx(handle
, hpp
);
355 if (ACPI_SUCCESS(status
))
357 status
= acpi_run_hpp(handle
, hpp
);
358 if (ACPI_SUCCESS(status
))
360 if (acpi_is_root_bridge(handle
))
362 status
= acpi_get_parent(handle
, &phandle
);
363 if (ACPI_FAILURE(status
))
369 EXPORT_SYMBOL_GPL(pci_get_hp_params
);
372 * pciehp_is_native - Check whether a hotplug port is handled by the OS
373 * @pdev: Hotplug port to check
375 * Walk up from @pdev to the host bridge, obtain its cached _OSC Control Field
376 * and return the value of the "PCI Express Native Hot Plug control" bit.
377 * On failure to obtain the _OSC Control Field return %false.
379 bool pciehp_is_native(struct pci_dev
*pdev
)
381 struct acpi_pci_root
*root
;
384 handle
= acpi_find_root_bridge_handle(pdev
);
388 root
= acpi_pci_find_root(handle
);
392 return root
->osc_control_set
& OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
;
396 * pci_acpi_wake_bus - Root bus wakeup notification fork function.
397 * @work: Work item to handle.
399 static void pci_acpi_wake_bus(struct work_struct
*work
)
401 struct acpi_device
*adev
;
402 struct acpi_pci_root
*root
;
404 adev
= container_of(work
, struct acpi_device
, wakeup
.context
.work
);
405 root
= acpi_driver_data(adev
);
406 pci_pme_wakeup_bus(root
->bus
);
410 * pci_acpi_wake_dev - PCI device wakeup notification work function.
411 * @handle: ACPI handle of a device the notification is for.
412 * @work: Work item to handle.
414 static void pci_acpi_wake_dev(struct work_struct
*work
)
416 struct acpi_device_wakeup_context
*context
;
417 struct pci_dev
*pci_dev
;
419 context
= container_of(work
, struct acpi_device_wakeup_context
, work
);
420 pci_dev
= to_pci_dev(context
->dev
);
422 if (pci_dev
->pme_poll
)
423 pci_dev
->pme_poll
= false;
425 if (pci_dev
->current_state
== PCI_D3cold
) {
426 pci_wakeup_event(pci_dev
);
427 pm_runtime_resume(&pci_dev
->dev
);
431 /* Clear PME Status if set. */
432 if (pci_dev
->pme_support
)
433 pci_check_pme_status(pci_dev
);
435 pci_wakeup_event(pci_dev
);
436 pm_runtime_resume(&pci_dev
->dev
);
438 pci_pme_wakeup_bus(pci_dev
->subordinate
);
442 * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.
443 * @dev: PCI root bridge ACPI device.
445 acpi_status
pci_acpi_add_bus_pm_notifier(struct acpi_device
*dev
)
447 return acpi_add_pm_notifier(dev
, NULL
, pci_acpi_wake_bus
);
451 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
452 * @dev: ACPI device to add the notifier for.
453 * @pci_dev: PCI device to check for the PME status if an event is signaled.
455 acpi_status
pci_acpi_add_pm_notifier(struct acpi_device
*dev
,
456 struct pci_dev
*pci_dev
)
458 return acpi_add_pm_notifier(dev
, &pci_dev
->dev
, pci_acpi_wake_dev
);
462 * _SxD returns the D-state with the highest power
463 * (lowest D-state number) supported in the S-state "x".
465 * If the devices does not have a _PRW
466 * (Power Resources for Wake) supporting system wakeup from "x"
467 * then the OS is free to choose a lower power (higher number
468 * D-state) than the return value from _SxD.
470 * But if _PRW is enabled at S-state "x", the OS
471 * must not choose a power lower than _SxD --
472 * unless the device has an _SxW method specifying
473 * the lowest power (highest D-state number) the device
474 * may enter while still able to wake the system.
476 * ie. depending on global OS policy:
478 * if (_PRW at S-state x)
479 * choose from highest power _SxD to lowest power _SxW
480 * else // no _PRW at S-state x
481 * choose highest power _SxD or any lower power
484 static pci_power_t
acpi_pci_choose_state(struct pci_dev
*pdev
)
486 int acpi_state
, d_max
;
489 d_max
= ACPI_STATE_D3_HOT
;
491 d_max
= ACPI_STATE_D3_COLD
;
492 acpi_state
= acpi_pm_device_sleep_state(&pdev
->dev
, NULL
, d_max
);
494 return PCI_POWER_ERROR
;
496 switch (acpi_state
) {
503 case ACPI_STATE_D3_HOT
:
505 case ACPI_STATE_D3_COLD
:
508 return PCI_POWER_ERROR
;
511 static bool acpi_pci_power_manageable(struct pci_dev
*dev
)
513 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
514 return adev
? acpi_device_power_manageable(adev
) : false;
517 static int acpi_pci_set_power_state(struct pci_dev
*dev
, pci_power_t state
)
519 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
520 static const u8 state_conv
[] = {
521 [PCI_D0
] = ACPI_STATE_D0
,
522 [PCI_D1
] = ACPI_STATE_D1
,
523 [PCI_D2
] = ACPI_STATE_D2
,
524 [PCI_D3hot
] = ACPI_STATE_D3_HOT
,
525 [PCI_D3cold
] = ACPI_STATE_D3_COLD
,
529 /* If the ACPI device has _EJ0, ignore the device */
530 if (!adev
|| acpi_has_method(adev
->handle
, "_EJ0"))
535 if (dev_pm_qos_flags(&dev
->dev
, PM_QOS_FLAG_NO_POWER_OFF
) ==
544 error
= acpi_device_set_power(adev
, state_conv
[state
]);
548 dev_dbg(&dev
->dev
, "power state changed by ACPI to %s\n",
549 acpi_power_state_string(state_conv
[state
]));
554 static pci_power_t
acpi_pci_get_power_state(struct pci_dev
*dev
)
556 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
557 static const pci_power_t state_conv
[] = {
558 [ACPI_STATE_D0
] = PCI_D0
,
559 [ACPI_STATE_D1
] = PCI_D1
,
560 [ACPI_STATE_D2
] = PCI_D2
,
561 [ACPI_STATE_D3_HOT
] = PCI_D3hot
,
562 [ACPI_STATE_D3_COLD
] = PCI_D3cold
,
566 if (!adev
|| !acpi_device_power_manageable(adev
))
569 if (acpi_device_get_power(adev
, &state
) || state
== ACPI_STATE_UNKNOWN
)
572 return state_conv
[state
];
575 static bool acpi_pci_can_wakeup(struct pci_dev
*dev
)
577 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
578 return adev
? acpi_device_can_wakeup(adev
) : false;
581 static void acpi_pci_propagate_wakeup_enable(struct pci_bus
*bus
, bool enable
)
583 while (bus
->parent
) {
584 if (!acpi_pm_device_sleep_wake(&bus
->self
->dev
, enable
))
589 /* We have reached the root bus. */
591 acpi_pm_device_sleep_wake(bus
->bridge
, enable
);
594 static int acpi_pci_sleep_wake(struct pci_dev
*dev
, bool enable
)
596 if (acpi_pci_can_wakeup(dev
))
597 return acpi_pm_device_sleep_wake(&dev
->dev
, enable
);
599 acpi_pci_propagate_wakeup_enable(dev
->bus
, enable
);
603 static void acpi_pci_propagate_run_wake(struct pci_bus
*bus
, bool enable
)
605 while (bus
->parent
) {
606 struct pci_dev
*bridge
= bus
->self
;
608 if (bridge
->pme_interrupt
)
610 if (!acpi_pm_device_run_wake(&bridge
->dev
, enable
))
615 /* We have reached the root bus. */
617 acpi_pm_device_run_wake(bus
->bridge
, enable
);
620 static int acpi_pci_run_wake(struct pci_dev
*dev
, bool enable
)
623 * Per PCI Express Base Specification Revision 2.0 section
624 * 5.3.3.2 Link Wakeup, platform support is needed for D3cold
625 * waking up to power on the main link even if there is PME
628 if (dev
->pme_interrupt
&& !dev
->runtime_d3cold
)
631 if (!acpi_pm_device_run_wake(&dev
->dev
, enable
))
634 acpi_pci_propagate_run_wake(dev
->bus
, enable
);
638 static bool acpi_pci_need_resume(struct pci_dev
*dev
)
640 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
642 if (!adev
|| !acpi_device_power_manageable(adev
))
645 if (device_may_wakeup(&dev
->dev
) != !!adev
->wakeup
.prepare_count
)
648 if (acpi_target_system_state() == ACPI_STATE_S0
)
651 return !!adev
->power
.flags
.dsw_present
;
654 static const struct pci_platform_pm_ops acpi_pci_platform_pm
= {
655 .is_manageable
= acpi_pci_power_manageable
,
656 .set_state
= acpi_pci_set_power_state
,
657 .get_state
= acpi_pci_get_power_state
,
658 .choose_state
= acpi_pci_choose_state
,
659 .sleep_wake
= acpi_pci_sleep_wake
,
660 .run_wake
= acpi_pci_run_wake
,
661 .need_resume
= acpi_pci_need_resume
,
664 void acpi_pci_add_bus(struct pci_bus
*bus
)
666 union acpi_object
*obj
;
667 struct pci_host_bridge
*bridge
;
669 if (acpi_pci_disabled
|| !bus
->bridge
)
672 acpi_pci_slot_enumerate(bus
);
673 acpiphp_enumerate_slots(bus
);
676 * For a host bridge, check its _DSM for function 8 and if
677 * that is available, mark it in pci_host_bridge.
679 if (!pci_is_root_bus(bus
))
682 obj
= acpi_evaluate_dsm(ACPI_HANDLE(bus
->bridge
), &pci_acpi_dsm_guid
, 3,
683 RESET_DELAY_DSM
, NULL
);
687 if (obj
->type
== ACPI_TYPE_INTEGER
&& obj
->integer
.value
== 1) {
688 bridge
= pci_find_host_bridge(bus
);
689 bridge
->ignore_reset_delay
= 1;
694 void acpi_pci_remove_bus(struct pci_bus
*bus
)
696 if (acpi_pci_disabled
|| !bus
->bridge
)
699 acpiphp_remove_slots(bus
);
700 acpi_pci_slot_remove(bus
);
704 static struct acpi_device
*acpi_pci_find_companion(struct device
*dev
)
706 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
710 check_children
= pci_is_bridge(pci_dev
);
711 /* Please ref to ACPI spec for the syntax of _ADR */
712 addr
= (PCI_SLOT(pci_dev
->devfn
) << 16) | PCI_FUNC(pci_dev
->devfn
);
713 return acpi_find_child_device(ACPI_COMPANION(dev
->parent
), addr
,
718 * pci_acpi_optimize_delay - optimize PCI D3 and D3cold delay from ACPI
719 * @pdev: the PCI device whose delay is to be updated
720 * @handle: ACPI handle of this device
722 * Update the d3_delay and d3cold_delay of a PCI device from the ACPI _DSM
723 * control method of either the device itself or the PCI host bridge.
725 * Function 8, "Reset Delay," applies to the entire hierarchy below a PCI
726 * host bridge. If it returns one, the OS may assume that all devices in
727 * the hierarchy have already completed power-on reset delays.
729 * Function 9, "Device Readiness Durations," applies only to the object
730 * where it is located. It returns delay durations required after various
731 * events if the device requires less time than the spec requires. Delays
732 * from this function take precedence over the Reset Delay function.
734 * These _DSM functions are defined by the draft ECN of January 28, 2014,
735 * titled "ACPI additions for FW latency optimizations."
737 static void pci_acpi_optimize_delay(struct pci_dev
*pdev
,
740 struct pci_host_bridge
*bridge
= pci_find_host_bridge(pdev
->bus
);
742 union acpi_object
*obj
, *elements
;
744 if (bridge
->ignore_reset_delay
)
745 pdev
->d3cold_delay
= 0;
747 obj
= acpi_evaluate_dsm(handle
, &pci_acpi_dsm_guid
, 3,
748 FUNCTION_DELAY_DSM
, NULL
);
752 if (obj
->type
== ACPI_TYPE_PACKAGE
&& obj
->package
.count
== 5) {
753 elements
= obj
->package
.elements
;
754 if (elements
[0].type
== ACPI_TYPE_INTEGER
) {
755 value
= (int)elements
[0].integer
.value
/ 1000;
756 if (value
< PCI_PM_D3COLD_WAIT
)
757 pdev
->d3cold_delay
= value
;
759 if (elements
[3].type
== ACPI_TYPE_INTEGER
) {
760 value
= (int)elements
[3].integer
.value
/ 1000;
761 if (value
< PCI_PM_D3_WAIT
)
762 pdev
->d3_delay
= value
;
768 static void pci_acpi_setup(struct device
*dev
)
770 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
771 struct acpi_device
*adev
= ACPI_COMPANION(dev
);
776 pci_acpi_optimize_delay(pci_dev
, adev
->handle
);
778 pci_acpi_add_pm_notifier(adev
, pci_dev
);
779 if (!adev
->wakeup
.flags
.valid
)
782 device_set_wakeup_capable(dev
, true);
783 acpi_pci_sleep_wake(pci_dev
, false);
784 if (adev
->wakeup
.flags
.run_wake
)
785 device_set_run_wake(dev
, true);
788 static void pci_acpi_cleanup(struct device
*dev
)
790 struct acpi_device
*adev
= ACPI_COMPANION(dev
);
795 pci_acpi_remove_pm_notifier(adev
);
796 if (adev
->wakeup
.flags
.valid
) {
797 device_set_wakeup_capable(dev
, false);
798 device_set_run_wake(dev
, false);
802 static bool pci_acpi_bus_match(struct device
*dev
)
804 return dev_is_pci(dev
);
807 static struct acpi_bus_type acpi_pci_bus
= {
809 .match
= pci_acpi_bus_match
,
810 .find_companion
= acpi_pci_find_companion
,
811 .setup
= pci_acpi_setup
,
812 .cleanup
= pci_acpi_cleanup
,
816 static struct fwnode_handle
*(*pci_msi_get_fwnode_cb
)(struct device
*dev
);
819 * pci_msi_register_fwnode_provider - Register callback to retrieve fwnode
820 * @fn: Callback matching a device to a fwnode that identifies a PCI
823 * This should be called by irqchip driver, which is the parent of
824 * the MSI domain to provide callback interface to query fwnode.
827 pci_msi_register_fwnode_provider(struct fwnode_handle
*(*fn
)(struct device
*))
829 pci_msi_get_fwnode_cb
= fn
;
833 * pci_host_bridge_acpi_msi_domain - Retrieve MSI domain of a PCI host bridge
834 * @bus: The PCI host bridge bus.
836 * This function uses the callback function registered by
837 * pci_msi_register_fwnode_provider() to retrieve the irq_domain with
838 * type DOMAIN_BUS_PCI_MSI of the specified host bridge bus.
839 * This returns NULL on error or when the domain is not found.
841 struct irq_domain
*pci_host_bridge_acpi_msi_domain(struct pci_bus
*bus
)
843 struct fwnode_handle
*fwnode
;
845 if (!pci_msi_get_fwnode_cb
)
848 fwnode
= pci_msi_get_fwnode_cb(&bus
->dev
);
852 return irq_find_matching_fwnode(fwnode
, DOMAIN_BUS_PCI_MSI
);
855 static int __init
acpi_pci_init(void)
859 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_MSI
) {
860 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
864 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_ASPM
) {
865 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
869 ret
= register_acpi_bus_type(&acpi_pci_bus
);
873 pci_set_platform_pm(&acpi_pci_platform_pm
);
874 acpi_pci_slot_init();
879 arch_initcall(acpi_pci_init
);