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 * @context: Device wakeup context.
399 static void pci_acpi_wake_bus(struct acpi_device_wakeup_context
*context
)
401 struct acpi_device
*adev
;
402 struct acpi_pci_root
*root
;
404 adev
= container_of(context
, struct acpi_device
, wakeup
.context
);
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 * @context: Device wakeup context.
413 static void pci_acpi_wake_dev(struct acpi_device_wakeup_context
*context
)
415 struct pci_dev
*pci_dev
;
417 pci_dev
= to_pci_dev(context
->dev
);
419 if (pci_dev
->pme_poll
)
420 pci_dev
->pme_poll
= false;
422 if (pci_dev
->current_state
== PCI_D3cold
) {
423 pci_wakeup_event(pci_dev
);
424 pm_request_resume(&pci_dev
->dev
);
428 /* Clear PME Status if set. */
429 if (pci_dev
->pme_support
)
430 pci_check_pme_status(pci_dev
);
432 pci_wakeup_event(pci_dev
);
433 pm_request_resume(&pci_dev
->dev
);
435 pci_pme_wakeup_bus(pci_dev
->subordinate
);
439 * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.
440 * @dev: PCI root bridge ACPI device.
442 acpi_status
pci_acpi_add_bus_pm_notifier(struct acpi_device
*dev
)
444 return acpi_add_pm_notifier(dev
, NULL
, pci_acpi_wake_bus
);
448 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
449 * @dev: ACPI device to add the notifier for.
450 * @pci_dev: PCI device to check for the PME status if an event is signaled.
452 acpi_status
pci_acpi_add_pm_notifier(struct acpi_device
*dev
,
453 struct pci_dev
*pci_dev
)
455 return acpi_add_pm_notifier(dev
, &pci_dev
->dev
, pci_acpi_wake_dev
);
459 * _SxD returns the D-state with the highest power
460 * (lowest D-state number) supported in the S-state "x".
462 * If the devices does not have a _PRW
463 * (Power Resources for Wake) supporting system wakeup from "x"
464 * then the OS is free to choose a lower power (higher number
465 * D-state) than the return value from _SxD.
467 * But if _PRW is enabled at S-state "x", the OS
468 * must not choose a power lower than _SxD --
469 * unless the device has an _SxW method specifying
470 * the lowest power (highest D-state number) the device
471 * may enter while still able to wake the system.
473 * ie. depending on global OS policy:
475 * if (_PRW at S-state x)
476 * choose from highest power _SxD to lowest power _SxW
477 * else // no _PRW at S-state x
478 * choose highest power _SxD or any lower power
481 static pci_power_t
acpi_pci_choose_state(struct pci_dev
*pdev
)
483 int acpi_state
, d_max
;
486 d_max
= ACPI_STATE_D3_HOT
;
488 d_max
= ACPI_STATE_D3_COLD
;
489 acpi_state
= acpi_pm_device_sleep_state(&pdev
->dev
, NULL
, d_max
);
491 return PCI_POWER_ERROR
;
493 switch (acpi_state
) {
500 case ACPI_STATE_D3_HOT
:
502 case ACPI_STATE_D3_COLD
:
505 return PCI_POWER_ERROR
;
508 static bool acpi_pci_power_manageable(struct pci_dev
*dev
)
510 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
511 return adev
? acpi_device_power_manageable(adev
) : false;
514 static int acpi_pci_set_power_state(struct pci_dev
*dev
, pci_power_t state
)
516 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
517 static const u8 state_conv
[] = {
518 [PCI_D0
] = ACPI_STATE_D0
,
519 [PCI_D1
] = ACPI_STATE_D1
,
520 [PCI_D2
] = ACPI_STATE_D2
,
521 [PCI_D3hot
] = ACPI_STATE_D3_HOT
,
522 [PCI_D3cold
] = ACPI_STATE_D3_COLD
,
526 /* If the ACPI device has _EJ0, ignore the device */
527 if (!adev
|| acpi_has_method(adev
->handle
, "_EJ0"))
532 if (dev_pm_qos_flags(&dev
->dev
, PM_QOS_FLAG_NO_POWER_OFF
) ==
541 error
= acpi_device_set_power(adev
, state_conv
[state
]);
545 dev_dbg(&dev
->dev
, "power state changed by ACPI to %s\n",
546 acpi_power_state_string(state_conv
[state
]));
551 static pci_power_t
acpi_pci_get_power_state(struct pci_dev
*dev
)
553 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
554 static const pci_power_t state_conv
[] = {
555 [ACPI_STATE_D0
] = PCI_D0
,
556 [ACPI_STATE_D1
] = PCI_D1
,
557 [ACPI_STATE_D2
] = PCI_D2
,
558 [ACPI_STATE_D3_HOT
] = PCI_D3hot
,
559 [ACPI_STATE_D3_COLD
] = PCI_D3cold
,
563 if (!adev
|| !acpi_device_power_manageable(adev
))
566 if (acpi_device_get_power(adev
, &state
) || state
== ACPI_STATE_UNKNOWN
)
569 return state_conv
[state
];
572 static int acpi_pci_propagate_wakeup(struct pci_bus
*bus
, bool enable
)
574 while (bus
->parent
) {
575 if (acpi_pm_device_can_wakeup(&bus
->self
->dev
))
576 return acpi_pm_set_bridge_wakeup(&bus
->self
->dev
, enable
);
581 /* We have reached the root bus. */
583 if (acpi_pm_device_can_wakeup(bus
->bridge
))
584 return acpi_pm_set_bridge_wakeup(bus
->bridge
, enable
);
589 static int acpi_pci_wakeup(struct pci_dev
*dev
, bool enable
)
591 if (acpi_pm_device_can_wakeup(&dev
->dev
))
592 return acpi_pm_set_device_wakeup(&dev
->dev
, enable
);
594 return acpi_pci_propagate_wakeup(dev
->bus
, enable
);
597 static bool acpi_pci_need_resume(struct pci_dev
*dev
)
599 struct acpi_device
*adev
= ACPI_COMPANION(&dev
->dev
);
602 * In some cases (eg. Samsung 305V4A) leaving a bridge in suspend over
603 * system-wide suspend/resume confuses the platform firmware, so avoid
604 * doing that, unless the bridge has a driver that should take care of
605 * the PM handling. According to Section 16.1.6 of ACPI 6.2, endpoint
606 * devices are expected to be in D3 before invoking the S3 entry path
607 * from the firmware, so they should not be affected by this issue.
609 if (pci_is_bridge(dev
) && !dev
->driver
&&
610 acpi_target_system_state() != ACPI_STATE_S0
)
613 if (!adev
|| !acpi_device_power_manageable(adev
))
616 if (device_may_wakeup(&dev
->dev
) != !!adev
->wakeup
.prepare_count
)
619 if (acpi_target_system_state() == ACPI_STATE_S0
)
622 return !!adev
->power
.flags
.dsw_present
;
625 static const struct pci_platform_pm_ops acpi_pci_platform_pm
= {
626 .is_manageable
= acpi_pci_power_manageable
,
627 .set_state
= acpi_pci_set_power_state
,
628 .get_state
= acpi_pci_get_power_state
,
629 .choose_state
= acpi_pci_choose_state
,
630 .set_wakeup
= acpi_pci_wakeup
,
631 .need_resume
= acpi_pci_need_resume
,
634 void acpi_pci_add_bus(struct pci_bus
*bus
)
636 union acpi_object
*obj
;
637 struct pci_host_bridge
*bridge
;
639 if (acpi_pci_disabled
|| !bus
->bridge
|| !ACPI_HANDLE(bus
->bridge
))
642 acpi_pci_slot_enumerate(bus
);
643 acpiphp_enumerate_slots(bus
);
646 * For a host bridge, check its _DSM for function 8 and if
647 * that is available, mark it in pci_host_bridge.
649 if (!pci_is_root_bus(bus
))
652 obj
= acpi_evaluate_dsm(ACPI_HANDLE(bus
->bridge
), &pci_acpi_dsm_guid
, 3,
653 RESET_DELAY_DSM
, NULL
);
657 if (obj
->type
== ACPI_TYPE_INTEGER
&& obj
->integer
.value
== 1) {
658 bridge
= pci_find_host_bridge(bus
);
659 bridge
->ignore_reset_delay
= 1;
664 void acpi_pci_remove_bus(struct pci_bus
*bus
)
666 if (acpi_pci_disabled
|| !bus
->bridge
)
669 acpiphp_remove_slots(bus
);
670 acpi_pci_slot_remove(bus
);
674 static struct acpi_device
*acpi_pci_find_companion(struct device
*dev
)
676 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
680 check_children
= pci_is_bridge(pci_dev
);
681 /* Please ref to ACPI spec for the syntax of _ADR */
682 addr
= (PCI_SLOT(pci_dev
->devfn
) << 16) | PCI_FUNC(pci_dev
->devfn
);
683 return acpi_find_child_device(ACPI_COMPANION(dev
->parent
), addr
,
688 * pci_acpi_optimize_delay - optimize PCI D3 and D3cold delay from ACPI
689 * @pdev: the PCI device whose delay is to be updated
690 * @handle: ACPI handle of this device
692 * Update the d3_delay and d3cold_delay of a PCI device from the ACPI _DSM
693 * control method of either the device itself or the PCI host bridge.
695 * Function 8, "Reset Delay," applies to the entire hierarchy below a PCI
696 * host bridge. If it returns one, the OS may assume that all devices in
697 * the hierarchy have already completed power-on reset delays.
699 * Function 9, "Device Readiness Durations," applies only to the object
700 * where it is located. It returns delay durations required after various
701 * events if the device requires less time than the spec requires. Delays
702 * from this function take precedence over the Reset Delay function.
704 * These _DSM functions are defined by the draft ECN of January 28, 2014,
705 * titled "ACPI additions for FW latency optimizations."
707 static void pci_acpi_optimize_delay(struct pci_dev
*pdev
,
710 struct pci_host_bridge
*bridge
= pci_find_host_bridge(pdev
->bus
);
712 union acpi_object
*obj
, *elements
;
714 if (bridge
->ignore_reset_delay
)
715 pdev
->d3cold_delay
= 0;
717 obj
= acpi_evaluate_dsm(handle
, &pci_acpi_dsm_guid
, 3,
718 FUNCTION_DELAY_DSM
, NULL
);
722 if (obj
->type
== ACPI_TYPE_PACKAGE
&& obj
->package
.count
== 5) {
723 elements
= obj
->package
.elements
;
724 if (elements
[0].type
== ACPI_TYPE_INTEGER
) {
725 value
= (int)elements
[0].integer
.value
/ 1000;
726 if (value
< PCI_PM_D3COLD_WAIT
)
727 pdev
->d3cold_delay
= value
;
729 if (elements
[3].type
== ACPI_TYPE_INTEGER
) {
730 value
= (int)elements
[3].integer
.value
/ 1000;
731 if (value
< PCI_PM_D3_WAIT
)
732 pdev
->d3_delay
= value
;
738 static void pci_acpi_set_untrusted(struct pci_dev
*dev
)
742 if (pci_pcie_type(dev
) != PCI_EXP_TYPE_ROOT_PORT
)
744 if (device_property_read_u8(&dev
->dev
, "ExternalFacingPort", &val
))
748 * These root ports expose PCIe (including DMA) outside of the
749 * system so make sure we treat them and everything behind as
756 static void pci_acpi_setup(struct device
*dev
)
758 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
759 struct acpi_device
*adev
= ACPI_COMPANION(dev
);
764 pci_acpi_optimize_delay(pci_dev
, adev
->handle
);
765 pci_acpi_set_untrusted(pci_dev
);
767 pci_acpi_add_pm_notifier(adev
, pci_dev
);
768 if (!adev
->wakeup
.flags
.valid
)
771 device_set_wakeup_capable(dev
, true);
772 acpi_pci_wakeup(pci_dev
, false);
775 static void pci_acpi_cleanup(struct device
*dev
)
777 struct acpi_device
*adev
= ACPI_COMPANION(dev
);
782 pci_acpi_remove_pm_notifier(adev
);
783 if (adev
->wakeup
.flags
.valid
)
784 device_set_wakeup_capable(dev
, false);
787 static bool pci_acpi_bus_match(struct device
*dev
)
789 return dev_is_pci(dev
);
792 static struct acpi_bus_type acpi_pci_bus
= {
794 .match
= pci_acpi_bus_match
,
795 .find_companion
= acpi_pci_find_companion
,
796 .setup
= pci_acpi_setup
,
797 .cleanup
= pci_acpi_cleanup
,
801 static struct fwnode_handle
*(*pci_msi_get_fwnode_cb
)(struct device
*dev
);
804 * pci_msi_register_fwnode_provider - Register callback to retrieve fwnode
805 * @fn: Callback matching a device to a fwnode that identifies a PCI
808 * This should be called by irqchip driver, which is the parent of
809 * the MSI domain to provide callback interface to query fwnode.
812 pci_msi_register_fwnode_provider(struct fwnode_handle
*(*fn
)(struct device
*))
814 pci_msi_get_fwnode_cb
= fn
;
818 * pci_host_bridge_acpi_msi_domain - Retrieve MSI domain of a PCI host bridge
819 * @bus: The PCI host bridge bus.
821 * This function uses the callback function registered by
822 * pci_msi_register_fwnode_provider() to retrieve the irq_domain with
823 * type DOMAIN_BUS_PCI_MSI of the specified host bridge bus.
824 * This returns NULL on error or when the domain is not found.
826 struct irq_domain
*pci_host_bridge_acpi_msi_domain(struct pci_bus
*bus
)
828 struct fwnode_handle
*fwnode
;
830 if (!pci_msi_get_fwnode_cb
)
833 fwnode
= pci_msi_get_fwnode_cb(&bus
->dev
);
837 return irq_find_matching_fwnode(fwnode
, DOMAIN_BUS_PCI_MSI
);
840 static int __init
acpi_pci_init(void)
844 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_MSI
) {
845 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
849 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_ASPM
) {
850 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
854 ret
= register_acpi_bus_type(&acpi_pci_bus
);
858 pci_set_platform_pm(&acpi_pci_platform_pm
);
859 acpi_pci_slot_init();
864 arch_initcall(acpi_pci_init
);