1 // SPDX-License-Identifier: GPL-2.0-only
3 * scan.c - support for transforming the ACPI namespace into individual objects
6 #define pr_fmt(fmt) "ACPI: " fmt
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/kernel.h>
12 #include <linux/acpi.h>
13 #include <linux/acpi_iort.h>
14 #include <linux/acpi_viot.h>
15 #include <linux/iommu.h>
16 #include <linux/signal.h>
17 #include <linux/kthread.h>
18 #include <linux/dmi.h>
19 #include <linux/dma-map-ops.h>
20 #include <linux/platform_data/x86/apple.h>
21 #include <linux/pgtable.h>
22 #include <linux/crc32.h>
23 #include <linux/dma-direct.h>
28 #define ACPI_BUS_CLASS "system_bus"
29 #define ACPI_BUS_HID "LNXSYBUS"
30 #define ACPI_BUS_DEVICE_NAME "System Bus"
32 #define INVALID_ACPI_HANDLE ((acpi_handle)ZERO_PAGE(0))
34 static const char *dummy_hid
= "device";
36 static LIST_HEAD(acpi_dep_list
);
37 static DEFINE_MUTEX(acpi_dep_list_lock
);
38 LIST_HEAD(acpi_bus_id_list
);
39 static DEFINE_MUTEX(acpi_scan_lock
);
40 static LIST_HEAD(acpi_scan_handlers_list
);
41 DEFINE_MUTEX(acpi_device_lock
);
42 LIST_HEAD(acpi_wakeup_device_list
);
43 static DEFINE_MUTEX(acpi_hp_context_lock
);
46 * The UART device described by the SPCR table is the only object which needs
47 * special-casing. Everything else is covered by ACPI namespace paths in STAO
50 static u64 spcr_uart_addr
;
52 void acpi_scan_lock_acquire(void)
54 mutex_lock(&acpi_scan_lock
);
56 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire
);
58 void acpi_scan_lock_release(void)
60 mutex_unlock(&acpi_scan_lock
);
62 EXPORT_SYMBOL_GPL(acpi_scan_lock_release
);
64 void acpi_lock_hp_context(void)
66 mutex_lock(&acpi_hp_context_lock
);
69 void acpi_unlock_hp_context(void)
71 mutex_unlock(&acpi_hp_context_lock
);
74 void acpi_initialize_hp_context(struct acpi_device
*adev
,
75 struct acpi_hotplug_context
*hp
,
76 int (*notify
)(struct acpi_device
*, u32
),
77 void (*uevent
)(struct acpi_device
*, u32
))
79 acpi_lock_hp_context();
82 acpi_set_hp_context(adev
, hp
);
83 acpi_unlock_hp_context();
85 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context
);
87 int acpi_scan_add_handler(struct acpi_scan_handler
*handler
)
92 list_add_tail(&handler
->list_node
, &acpi_scan_handlers_list
);
96 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler
*handler
,
97 const char *hotplug_profile_name
)
101 error
= acpi_scan_add_handler(handler
);
105 acpi_sysfs_add_hotplug_profile(&handler
->hotplug
, hotplug_profile_name
);
109 bool acpi_scan_is_offline(struct acpi_device
*adev
, bool uevent
)
111 struct acpi_device_physical_node
*pn
;
113 char *envp
[] = { "EVENT=offline", NULL
};
116 * acpi_container_offline() calls this for all of the container's
117 * children under the container's physical_node_lock lock.
119 mutex_lock_nested(&adev
->physical_node_lock
, SINGLE_DEPTH_NESTING
);
121 list_for_each_entry(pn
, &adev
->physical_node_list
, node
)
122 if (device_supports_offline(pn
->dev
) && !pn
->dev
->offline
) {
124 kobject_uevent_env(&pn
->dev
->kobj
, KOBJ_CHANGE
, envp
);
130 mutex_unlock(&adev
->physical_node_lock
);
134 static acpi_status
acpi_bus_offline(acpi_handle handle
, u32 lvl
, void *data
,
137 struct acpi_device
*device
= acpi_fetch_acpi_dev(handle
);
138 struct acpi_device_physical_node
*pn
;
139 bool second_pass
= (bool)data
;
140 acpi_status status
= AE_OK
;
145 if (device
->handler
&& !device
->handler
->hotplug
.enabled
) {
146 *ret_p
= &device
->dev
;
150 mutex_lock(&device
->physical_node_lock
);
152 list_for_each_entry(pn
, &device
->physical_node_list
, node
) {
156 /* Skip devices offlined by the first pass. */
160 pn
->put_online
= false;
162 ret
= device_offline(pn
->dev
);
164 pn
->put_online
= !ret
;
174 mutex_unlock(&device
->physical_node_lock
);
179 static acpi_status
acpi_bus_online(acpi_handle handle
, u32 lvl
, void *data
,
182 struct acpi_device
*device
= acpi_fetch_acpi_dev(handle
);
183 struct acpi_device_physical_node
*pn
;
188 mutex_lock(&device
->physical_node_lock
);
190 list_for_each_entry(pn
, &device
->physical_node_list
, node
)
191 if (pn
->put_online
) {
192 device_online(pn
->dev
);
193 pn
->put_online
= false;
196 mutex_unlock(&device
->physical_node_lock
);
201 static int acpi_scan_try_to_offline(struct acpi_device
*device
)
203 acpi_handle handle
= device
->handle
;
204 struct device
*errdev
= NULL
;
208 * Carry out two passes here and ignore errors in the first pass,
209 * because if the devices in question are memory blocks and
210 * CONFIG_MEMCG is set, one of the blocks may hold data structures
211 * that the other blocks depend on, but it is not known in advance which
214 * If the first pass is successful, the second one isn't needed, though.
216 status
= acpi_walk_namespace(ACPI_TYPE_ANY
, handle
, ACPI_UINT32_MAX
,
217 NULL
, acpi_bus_offline
, (void *)false,
219 if (status
== AE_SUPPORT
) {
220 dev_warn(errdev
, "Offline disabled.\n");
221 acpi_walk_namespace(ACPI_TYPE_ANY
, handle
, ACPI_UINT32_MAX
,
222 acpi_bus_online
, NULL
, NULL
, NULL
);
225 acpi_bus_offline(handle
, 0, (void *)false, (void **)&errdev
);
228 acpi_walk_namespace(ACPI_TYPE_ANY
, handle
, ACPI_UINT32_MAX
,
229 NULL
, acpi_bus_offline
, (void *)true,
232 acpi_bus_offline(handle
, 0, (void *)true,
236 dev_warn(errdev
, "Offline failed.\n");
237 acpi_bus_online(handle
, 0, NULL
, NULL
);
238 acpi_walk_namespace(ACPI_TYPE_ANY
, handle
,
239 ACPI_UINT32_MAX
, acpi_bus_online
,
247 static int acpi_scan_hot_remove(struct acpi_device
*device
)
249 acpi_handle handle
= device
->handle
;
250 unsigned long long sta
;
253 if (device
->handler
&& device
->handler
->hotplug
.demand_offline
) {
254 if (!acpi_scan_is_offline(device
, true))
257 int error
= acpi_scan_try_to_offline(device
);
262 acpi_handle_debug(handle
, "Ejecting\n");
264 acpi_bus_trim(device
);
266 acpi_evaluate_lck(handle
, 0);
270 status
= acpi_evaluate_ej0(handle
);
271 if (status
== AE_NOT_FOUND
)
273 else if (ACPI_FAILURE(status
))
277 * Verify if eject was indeed successful. If not, log an error
278 * message. No need to call _OST since _EJ0 call was made OK.
280 status
= acpi_evaluate_integer(handle
, "_STA", NULL
, &sta
);
281 if (ACPI_FAILURE(status
)) {
282 acpi_handle_warn(handle
,
283 "Status check after eject failed (0x%x)\n", status
);
284 } else if (sta
& ACPI_STA_DEVICE_ENABLED
) {
285 acpi_handle_warn(handle
,
286 "Eject incomplete - status 0x%llx\n", sta
);
292 static int acpi_scan_device_not_enumerated(struct acpi_device
*adev
)
294 if (!acpi_device_enumerated(adev
)) {
295 dev_warn(&adev
->dev
, "Still not enumerated\n");
302 static int acpi_scan_device_check(struct acpi_device
*adev
)
306 acpi_bus_get_status(adev
);
307 if (acpi_device_is_present(adev
)) {
309 * This function is only called for device objects for which
310 * matching scan handlers exist. The only situation in which
311 * the scan handler is not attached to this device object yet
312 * is when the device has just appeared (either it wasn't
313 * present at all before or it was removed and then added
317 dev_warn(&adev
->dev
, "Already enumerated\n");
320 error
= acpi_bus_scan(adev
->handle
);
322 dev_warn(&adev
->dev
, "Namespace scan failure\n");
325 if (!adev
->handler
) {
326 dev_warn(&adev
->dev
, "Enumeration failure\n");
330 error
= acpi_scan_device_not_enumerated(adev
);
335 static int acpi_scan_bus_check(struct acpi_device
*adev
, void *not_used
)
337 struct acpi_scan_handler
*handler
= adev
->handler
;
340 acpi_bus_get_status(adev
);
341 if (!acpi_device_is_present(adev
)) {
342 acpi_scan_device_not_enumerated(adev
);
345 if (handler
&& handler
->hotplug
.scan_dependent
)
346 return handler
->hotplug
.scan_dependent(adev
);
348 error
= acpi_bus_scan(adev
->handle
);
350 dev_warn(&adev
->dev
, "Namespace scan failure\n");
353 return acpi_dev_for_each_child(adev
, acpi_scan_bus_check
, NULL
);
356 static int acpi_generic_hotplug_event(struct acpi_device
*adev
, u32 type
)
359 case ACPI_NOTIFY_BUS_CHECK
:
360 return acpi_scan_bus_check(adev
, NULL
);
361 case ACPI_NOTIFY_DEVICE_CHECK
:
362 return acpi_scan_device_check(adev
);
363 case ACPI_NOTIFY_EJECT_REQUEST
:
364 case ACPI_OST_EC_OSPM_EJECT
:
365 if (adev
->handler
&& !adev
->handler
->hotplug
.enabled
) {
366 dev_info(&adev
->dev
, "Eject disabled\n");
369 acpi_evaluate_ost(adev
->handle
, ACPI_NOTIFY_EJECT_REQUEST
,
370 ACPI_OST_SC_EJECT_IN_PROGRESS
, NULL
);
371 return acpi_scan_hot_remove(adev
);
376 void acpi_device_hotplug(struct acpi_device
*adev
, u32 src
)
378 u32 ost_code
= ACPI_OST_SC_NON_SPECIFIC_FAILURE
;
381 lock_device_hotplug();
382 mutex_lock(&acpi_scan_lock
);
385 * The device object's ACPI handle cannot become invalid as long as we
386 * are holding acpi_scan_lock, but it might have become invalid before
387 * that lock was acquired.
389 if (adev
->handle
== INVALID_ACPI_HANDLE
)
392 if (adev
->flags
.is_dock_station
) {
393 error
= dock_notify(adev
, src
);
394 } else if (adev
->flags
.hotplug_notify
) {
395 error
= acpi_generic_hotplug_event(adev
, src
);
397 int (*notify
)(struct acpi_device
*, u32
);
399 acpi_lock_hp_context();
400 notify
= adev
->hp
? adev
->hp
->notify
: NULL
;
401 acpi_unlock_hp_context();
403 * There may be additional notify handlers for device objects
404 * without the .event() callback, so ignore them here.
407 error
= notify(adev
, src
);
413 ost_code
= ACPI_OST_SC_SUCCESS
;
416 ost_code
= ACPI_OST_SC_EJECT_NOT_SUPPORTED
;
419 ost_code
= ACPI_OST_SC_DEVICE_BUSY
;
422 ost_code
= ACPI_OST_SC_NON_SPECIFIC_FAILURE
;
427 acpi_evaluate_ost(adev
->handle
, src
, ost_code
, NULL
);
430 acpi_put_acpi_dev(adev
);
431 mutex_unlock(&acpi_scan_lock
);
432 unlock_device_hotplug();
435 static void acpi_free_power_resources_lists(struct acpi_device
*device
)
439 if (device
->wakeup
.flags
.valid
)
440 acpi_power_resources_list_free(&device
->wakeup
.resources
);
442 if (!device
->power
.flags
.power_resources
)
445 for (i
= ACPI_STATE_D0
; i
<= ACPI_STATE_D3_HOT
; i
++) {
446 struct acpi_device_power_state
*ps
= &device
->power
.states
[i
];
447 acpi_power_resources_list_free(&ps
->resources
);
451 static void acpi_device_release(struct device
*dev
)
453 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
455 acpi_free_properties(acpi_dev
);
456 acpi_free_pnp_ids(&acpi_dev
->pnp
);
457 acpi_free_power_resources_lists(acpi_dev
);
461 static void acpi_device_del(struct acpi_device
*device
)
463 struct acpi_device_bus_id
*acpi_device_bus_id
;
465 mutex_lock(&acpi_device_lock
);
467 list_for_each_entry(acpi_device_bus_id
, &acpi_bus_id_list
, node
)
468 if (!strcmp(acpi_device_bus_id
->bus_id
,
469 acpi_device_hid(device
))) {
470 ida_free(&acpi_device_bus_id
->instance_ida
,
471 device
->pnp
.instance_no
);
472 if (ida_is_empty(&acpi_device_bus_id
->instance_ida
)) {
473 list_del(&acpi_device_bus_id
->node
);
474 kfree_const(acpi_device_bus_id
->bus_id
);
475 kfree(acpi_device_bus_id
);
480 list_del(&device
->wakeup_list
);
482 mutex_unlock(&acpi_device_lock
);
484 acpi_power_add_remove_device(device
, false);
485 acpi_device_remove_files(device
);
487 device
->remove(device
);
489 device_del(&device
->dev
);
492 static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain
);
494 static LIST_HEAD(acpi_device_del_list
);
495 static DEFINE_MUTEX(acpi_device_del_lock
);
497 static void acpi_device_del_work_fn(struct work_struct
*work_not_used
)
500 struct acpi_device
*adev
;
502 mutex_lock(&acpi_device_del_lock
);
504 if (list_empty(&acpi_device_del_list
)) {
505 mutex_unlock(&acpi_device_del_lock
);
508 adev
= list_first_entry(&acpi_device_del_list
,
509 struct acpi_device
, del_list
);
510 list_del(&adev
->del_list
);
512 mutex_unlock(&acpi_device_del_lock
);
514 blocking_notifier_call_chain(&acpi_reconfig_chain
,
515 ACPI_RECONFIG_DEVICE_REMOVE
, adev
);
517 acpi_device_del(adev
);
519 * Drop references to all power resources that might have been
520 * used by the device.
522 acpi_power_transition(adev
, ACPI_STATE_D3_COLD
);
528 * acpi_scan_drop_device - Drop an ACPI device object.
529 * @handle: Handle of an ACPI namespace node, not used.
530 * @context: Address of the ACPI device object to drop.
532 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
533 * namespace node the device object pointed to by @context is attached to.
535 * The unregistration is carried out asynchronously to avoid running
536 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
537 * ensure the correct ordering (the device objects must be unregistered in the
538 * same order in which the corresponding namespace nodes are deleted).
540 static void acpi_scan_drop_device(acpi_handle handle
, void *context
)
542 static DECLARE_WORK(work
, acpi_device_del_work_fn
);
543 struct acpi_device
*adev
= context
;
545 mutex_lock(&acpi_device_del_lock
);
548 * Use the ACPI hotplug workqueue which is ordered, so this work item
549 * won't run after any hotplug work items submitted subsequently. That
550 * prevents attempts to register device objects identical to those being
551 * deleted from happening concurrently (such attempts result from
552 * hotplug events handled via the ACPI hotplug workqueue). It also will
553 * run after all of the work items submitted previously, which helps
554 * those work items to ensure that they are not accessing stale device
557 if (list_empty(&acpi_device_del_list
))
558 acpi_queue_hotplug_work(&work
);
560 list_add_tail(&adev
->del_list
, &acpi_device_del_list
);
561 /* Make acpi_ns_validate_handle() return NULL for this handle. */
562 adev
->handle
= INVALID_ACPI_HANDLE
;
564 mutex_unlock(&acpi_device_del_lock
);
567 static struct acpi_device
*handle_to_device(acpi_handle handle
,
568 void (*callback
)(void *))
570 struct acpi_device
*adev
= NULL
;
573 status
= acpi_get_data_full(handle
, acpi_scan_drop_device
,
574 (void **)&adev
, callback
);
575 if (ACPI_FAILURE(status
) || !adev
) {
576 acpi_handle_debug(handle
, "No context!\n");
583 * acpi_fetch_acpi_dev - Retrieve ACPI device object.
584 * @handle: ACPI handle associated with the requested ACPI device object.
586 * Return a pointer to the ACPI device object associated with @handle, if
587 * present, or NULL otherwise.
589 struct acpi_device
*acpi_fetch_acpi_dev(acpi_handle handle
)
591 return handle_to_device(handle
, NULL
);
593 EXPORT_SYMBOL_GPL(acpi_fetch_acpi_dev
);
595 static void get_acpi_device(void *dev
)
601 * acpi_get_acpi_dev - Retrieve ACPI device object and reference count it.
602 * @handle: ACPI handle associated with the requested ACPI device object.
604 * Return a pointer to the ACPI device object associated with @handle and bump
605 * up that object's reference counter (under the ACPI Namespace lock), if
606 * present, or return NULL otherwise.
608 * The ACPI device object reference acquired by this function needs to be
609 * dropped via acpi_dev_put().
611 struct acpi_device
*acpi_get_acpi_dev(acpi_handle handle
)
613 return handle_to_device(handle
, get_acpi_device
);
615 EXPORT_SYMBOL_GPL(acpi_get_acpi_dev
);
617 static struct acpi_device_bus_id
*acpi_device_bus_id_match(const char *dev_id
)
619 struct acpi_device_bus_id
*acpi_device_bus_id
;
621 /* Find suitable bus_id and instance number in acpi_bus_id_list. */
622 list_for_each_entry(acpi_device_bus_id
, &acpi_bus_id_list
, node
) {
623 if (!strcmp(acpi_device_bus_id
->bus_id
, dev_id
))
624 return acpi_device_bus_id
;
629 static int acpi_device_set_name(struct acpi_device
*device
,
630 struct acpi_device_bus_id
*acpi_device_bus_id
)
632 struct ida
*instance_ida
= &acpi_device_bus_id
->instance_ida
;
635 result
= ida_alloc(instance_ida
, GFP_KERNEL
);
639 device
->pnp
.instance_no
= result
;
640 dev_set_name(&device
->dev
, "%s:%02x", acpi_device_bus_id
->bus_id
, result
);
644 int acpi_tie_acpi_dev(struct acpi_device
*adev
)
646 acpi_handle handle
= adev
->handle
;
652 status
= acpi_attach_data(handle
, acpi_scan_drop_device
, adev
);
653 if (ACPI_FAILURE(status
)) {
654 acpi_handle_err(handle
, "Unable to attach device data\n");
661 static void acpi_store_pld_crc(struct acpi_device
*adev
)
663 struct acpi_pld_info
*pld
;
666 status
= acpi_get_physical_device_location(adev
->handle
, &pld
);
667 if (ACPI_FAILURE(status
))
670 adev
->pld_crc
= crc32(~0, pld
, sizeof(*pld
));
674 int acpi_device_add(struct acpi_device
*device
)
676 struct acpi_device_bus_id
*acpi_device_bus_id
;
682 * Link this device to its parent and siblings.
684 INIT_LIST_HEAD(&device
->wakeup_list
);
685 INIT_LIST_HEAD(&device
->physical_node_list
);
686 INIT_LIST_HEAD(&device
->del_list
);
687 mutex_init(&device
->physical_node_lock
);
689 mutex_lock(&acpi_device_lock
);
691 acpi_device_bus_id
= acpi_device_bus_id_match(acpi_device_hid(device
));
692 if (acpi_device_bus_id
) {
693 result
= acpi_device_set_name(device
, acpi_device_bus_id
);
697 acpi_device_bus_id
= kzalloc(sizeof(*acpi_device_bus_id
),
699 if (!acpi_device_bus_id
) {
703 acpi_device_bus_id
->bus_id
=
704 kstrdup_const(acpi_device_hid(device
), GFP_KERNEL
);
705 if (!acpi_device_bus_id
->bus_id
) {
706 kfree(acpi_device_bus_id
);
711 ida_init(&acpi_device_bus_id
->instance_ida
);
713 result
= acpi_device_set_name(device
, acpi_device_bus_id
);
715 kfree_const(acpi_device_bus_id
->bus_id
);
716 kfree(acpi_device_bus_id
);
720 list_add_tail(&acpi_device_bus_id
->node
, &acpi_bus_id_list
);
723 if (device
->wakeup
.flags
.valid
)
724 list_add_tail(&device
->wakeup_list
, &acpi_wakeup_device_list
);
726 acpi_store_pld_crc(device
);
728 mutex_unlock(&acpi_device_lock
);
730 result
= device_add(&device
->dev
);
732 dev_err(&device
->dev
, "Error registering device\n");
736 result
= acpi_device_setup_files(device
);
738 pr_err("Error creating sysfs interface for device %s\n",
739 dev_name(&device
->dev
));
744 mutex_lock(&acpi_device_lock
);
746 list_del(&device
->wakeup_list
);
749 mutex_unlock(&acpi_device_lock
);
751 acpi_detach_data(device
->handle
, acpi_scan_drop_device
);
756 /* --------------------------------------------------------------------------
758 -------------------------------------------------------------------------- */
759 static bool acpi_info_matches_ids(struct acpi_device_info
*info
,
760 const char * const ids
[])
762 struct acpi_pnp_device_id_list
*cid_list
= NULL
;
765 if (!(info
->valid
& ACPI_VALID_HID
))
768 index
= match_string(ids
, -1, info
->hardware_id
.string
);
772 if (info
->valid
& ACPI_VALID_CID
)
773 cid_list
= &info
->compatible_id_list
;
778 for (i
= 0; i
< cid_list
->count
; i
++) {
779 index
= match_string(ids
, -1, cid_list
->ids
[i
].string
);
787 /* List of HIDs for which we ignore matching ACPI devices, when checking _DEP lists. */
788 static const char * const acpi_ignore_dep_ids
[] = {
789 "PNP0D80", /* Windows-compatible System Power Management Controller */
790 "INT33BD", /* Intel Baytrail Mailbox Device */
791 "LATT2021", /* Lattice FW Update Client Driver */
795 /* List of HIDs for which we honor deps of matching ACPI devs, when checking _DEP lists. */
796 static const char * const acpi_honor_dep_ids
[] = {
797 "INT3472", /* Camera sensor PMIC / clk and regulator info */
798 "INTC1059", /* IVSC (TGL) driver must be loaded to allow i2c access to camera sensors */
799 "INTC1095", /* IVSC (ADL) driver must be loaded to allow i2c access to camera sensors */
800 "INTC100A", /* IVSC (RPL) driver must be loaded to allow i2c access to camera sensors */
804 static struct acpi_device
*acpi_find_parent_acpi_dev(acpi_handle handle
)
806 struct acpi_device
*adev
;
809 * Fixed hardware devices do not appear in the namespace and do not
810 * have handles, but we fabricate acpi_devices for them, so we have
811 * to deal with them specially.
819 status
= acpi_get_parent(handle
, &handle
);
820 if (ACPI_FAILURE(status
)) {
821 if (status
!= AE_NULL_ENTRY
)
826 adev
= acpi_fetch_acpi_dev(handle
);
832 acpi_bus_get_ejd(acpi_handle handle
, acpi_handle
*ejd
)
836 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
837 union acpi_object
*obj
;
839 status
= acpi_get_handle(handle
, "_EJD", &tmp
);
840 if (ACPI_FAILURE(status
))
843 status
= acpi_evaluate_object(handle
, "_EJD", NULL
, &buffer
);
844 if (ACPI_SUCCESS(status
)) {
845 obj
= buffer
.pointer
;
846 status
= acpi_get_handle(ACPI_ROOT_OBJECT
, obj
->string
.pointer
,
848 kfree(buffer
.pointer
);
852 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd
);
854 static int acpi_bus_extract_wakeup_device_power_package(struct acpi_device
*dev
)
856 acpi_handle handle
= dev
->handle
;
857 struct acpi_device_wakeup
*wakeup
= &dev
->wakeup
;
858 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
859 union acpi_object
*package
= NULL
;
860 union acpi_object
*element
= NULL
;
864 INIT_LIST_HEAD(&wakeup
->resources
);
867 status
= acpi_evaluate_object(handle
, "_PRW", NULL
, &buffer
);
868 if (ACPI_FAILURE(status
)) {
869 acpi_handle_info(handle
, "_PRW evaluation failed: %s\n",
870 acpi_format_exception(status
));
874 package
= (union acpi_object
*)buffer
.pointer
;
876 if (!package
|| package
->package
.count
< 2)
879 element
= &(package
->package
.elements
[0]);
883 if (element
->type
== ACPI_TYPE_PACKAGE
) {
884 if ((element
->package
.count
< 2) ||
885 (element
->package
.elements
[0].type
!=
886 ACPI_TYPE_LOCAL_REFERENCE
)
887 || (element
->package
.elements
[1].type
!= ACPI_TYPE_INTEGER
))
891 element
->package
.elements
[0].reference
.handle
;
893 (u32
) element
->package
.elements
[1].integer
.value
;
894 } else if (element
->type
== ACPI_TYPE_INTEGER
) {
895 wakeup
->gpe_device
= NULL
;
896 wakeup
->gpe_number
= element
->integer
.value
;
901 element
= &(package
->package
.elements
[1]);
902 if (element
->type
!= ACPI_TYPE_INTEGER
)
905 wakeup
->sleep_state
= element
->integer
.value
;
907 err
= acpi_extract_power_resources(package
, 2, &wakeup
->resources
);
911 if (!list_empty(&wakeup
->resources
)) {
914 err
= acpi_power_wakeup_list_init(&wakeup
->resources
,
917 acpi_handle_warn(handle
, "Retrieving current states "
918 "of wakeup power resources failed\n");
919 acpi_power_resources_list_free(&wakeup
->resources
);
922 if (sleep_state
< wakeup
->sleep_state
) {
923 acpi_handle_warn(handle
, "Overriding _PRW sleep state "
924 "(S%d) by S%d from power resources\n",
925 (int)wakeup
->sleep_state
, sleep_state
);
926 wakeup
->sleep_state
= sleep_state
;
931 kfree(buffer
.pointer
);
935 /* Do not use a button for S5 wakeup */
936 #define ACPI_AVOID_WAKE_FROM_S5 BIT(0)
938 static bool acpi_wakeup_gpe_init(struct acpi_device
*device
)
940 static const struct acpi_device_id button_device_ids
[] = {
941 {"PNP0C0C", 0}, /* Power button */
942 {"PNP0C0D", ACPI_AVOID_WAKE_FROM_S5
}, /* Lid */
943 {"PNP0C0E", ACPI_AVOID_WAKE_FROM_S5
}, /* Sleep button */
946 struct acpi_device_wakeup
*wakeup
= &device
->wakeup
;
947 const struct acpi_device_id
*match
;
950 wakeup
->flags
.notifier_present
= 0;
952 /* Power button, Lid switch always enable wakeup */
953 match
= acpi_match_acpi_device(button_device_ids
, device
);
955 if ((match
->driver_data
& ACPI_AVOID_WAKE_FROM_S5
) &&
956 wakeup
->sleep_state
== ACPI_STATE_S5
)
957 wakeup
->sleep_state
= ACPI_STATE_S4
;
958 acpi_mark_gpe_for_wake(wakeup
->gpe_device
, wakeup
->gpe_number
);
959 device_set_wakeup_capable(&device
->dev
, true);
963 status
= acpi_setup_gpe_for_wake(device
->handle
, wakeup
->gpe_device
,
965 return ACPI_SUCCESS(status
);
968 static void acpi_bus_get_wakeup_device_flags(struct acpi_device
*device
)
972 /* Presence of _PRW indicates wake capable */
973 if (!acpi_has_method(device
->handle
, "_PRW"))
976 err
= acpi_bus_extract_wakeup_device_power_package(device
);
978 dev_err(&device
->dev
, "Unable to extract wakeup power resources");
982 device
->wakeup
.flags
.valid
= acpi_wakeup_gpe_init(device
);
983 device
->wakeup
.prepare_count
= 0;
985 * Call _PSW/_DSW object to disable its ability to wake the sleeping
986 * system for the ACPI device with the _PRW object.
987 * The _PSW object is deprecated in ACPI 3.0 and is replaced by _DSW.
988 * So it is necessary to call _DSW object first. Only when it is not
989 * present will the _PSW object used.
991 err
= acpi_device_sleep_wake(device
, 0, 0, 0);
993 pr_debug("error in _DSW or _PSW evaluation\n");
996 static void acpi_bus_init_power_state(struct acpi_device
*device
, int state
)
998 struct acpi_device_power_state
*ps
= &device
->power
.states
[state
];
999 char pathname
[5] = { '_', 'P', 'R', '0' + state
, '\0' };
1000 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1003 INIT_LIST_HEAD(&ps
->resources
);
1005 /* Evaluate "_PRx" to get referenced power resources */
1006 status
= acpi_evaluate_object(device
->handle
, pathname
, NULL
, &buffer
);
1007 if (ACPI_SUCCESS(status
)) {
1008 union acpi_object
*package
= buffer
.pointer
;
1010 if (buffer
.length
&& package
1011 && package
->type
== ACPI_TYPE_PACKAGE
1012 && package
->package
.count
)
1013 acpi_extract_power_resources(package
, 0, &ps
->resources
);
1015 ACPI_FREE(buffer
.pointer
);
1018 /* Evaluate "_PSx" to see if we can do explicit sets */
1020 if (acpi_has_method(device
->handle
, pathname
))
1021 ps
->flags
.explicit_set
= 1;
1023 /* State is valid if there are means to put the device into it. */
1024 if (!list_empty(&ps
->resources
) || ps
->flags
.explicit_set
)
1025 ps
->flags
.valid
= 1;
1027 ps
->power
= -1; /* Unknown - driver assigned */
1028 ps
->latency
= -1; /* Unknown - driver assigned */
1031 static void acpi_bus_get_power_flags(struct acpi_device
*device
)
1033 unsigned long long dsc
= ACPI_STATE_D0
;
1036 /* Presence of _PS0|_PR0 indicates 'power manageable' */
1037 if (!acpi_has_method(device
->handle
, "_PS0") &&
1038 !acpi_has_method(device
->handle
, "_PR0"))
1041 device
->flags
.power_manageable
= 1;
1044 * Power Management Flags
1046 if (acpi_has_method(device
->handle
, "_PSC"))
1047 device
->power
.flags
.explicit_get
= 1;
1049 if (acpi_has_method(device
->handle
, "_IRC"))
1050 device
->power
.flags
.inrush_current
= 1;
1052 if (acpi_has_method(device
->handle
, "_DSW"))
1053 device
->power
.flags
.dsw_present
= 1;
1055 acpi_evaluate_integer(device
->handle
, "_DSC", NULL
, &dsc
);
1056 device
->power
.state_for_enumeration
= dsc
;
1059 * Enumerate supported power management states
1061 for (i
= ACPI_STATE_D0
; i
<= ACPI_STATE_D3_HOT
; i
++)
1062 acpi_bus_init_power_state(device
, i
);
1064 INIT_LIST_HEAD(&device
->power
.states
[ACPI_STATE_D3_COLD
].resources
);
1066 /* Set the defaults for D0 and D3hot (always supported). */
1067 device
->power
.states
[ACPI_STATE_D0
].flags
.valid
= 1;
1068 device
->power
.states
[ACPI_STATE_D0
].power
= 100;
1069 device
->power
.states
[ACPI_STATE_D3_HOT
].flags
.valid
= 1;
1072 * Use power resources only if the D0 list of them is populated, because
1073 * some platforms may provide _PR3 only to indicate D3cold support and
1074 * in those cases the power resources list returned by it may be bogus.
1076 if (!list_empty(&device
->power
.states
[ACPI_STATE_D0
].resources
)) {
1077 device
->power
.flags
.power_resources
= 1;
1079 * D3cold is supported if the D3hot list of power resources is
1082 if (!list_empty(&device
->power
.states
[ACPI_STATE_D3_HOT
].resources
))
1083 device
->power
.states
[ACPI_STATE_D3_COLD
].flags
.valid
= 1;
1086 if (acpi_bus_init_power(device
))
1087 device
->flags
.power_manageable
= 0;
1090 static void acpi_bus_get_flags(struct acpi_device
*device
)
1092 /* Presence of _STA indicates 'dynamic_status' */
1093 if (acpi_has_method(device
->handle
, "_STA"))
1094 device
->flags
.dynamic_status
= 1;
1096 /* Presence of _RMV indicates 'removable' */
1097 if (acpi_has_method(device
->handle
, "_RMV"))
1098 device
->flags
.removable
= 1;
1100 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1101 if (acpi_has_method(device
->handle
, "_EJD") ||
1102 acpi_has_method(device
->handle
, "_EJ0"))
1103 device
->flags
.ejectable
= 1;
1106 static void acpi_device_get_busid(struct acpi_device
*device
)
1108 char bus_id
[5] = { '?', 0 };
1109 struct acpi_buffer buffer
= { sizeof(bus_id
), bus_id
};
1115 * The device's Bus ID is simply the object name.
1116 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1118 if (!acpi_dev_parent(device
)) {
1119 strcpy(device
->pnp
.bus_id
, "ACPI");
1123 switch (device
->device_type
) {
1124 case ACPI_BUS_TYPE_POWER_BUTTON
:
1125 strcpy(device
->pnp
.bus_id
, "PWRF");
1127 case ACPI_BUS_TYPE_SLEEP_BUTTON
:
1128 strcpy(device
->pnp
.bus_id
, "SLPF");
1130 case ACPI_BUS_TYPE_ECDT_EC
:
1131 strcpy(device
->pnp
.bus_id
, "ECDT");
1134 acpi_get_name(device
->handle
, ACPI_SINGLE_NAME
, &buffer
);
1135 /* Clean up trailing underscores (if any) */
1136 for (i
= 3; i
> 1; i
--) {
1137 if (bus_id
[i
] == '_')
1142 strcpy(device
->pnp
.bus_id
, bus_id
);
1148 * acpi_ata_match - see if an acpi object is an ATA device
1150 * If an acpi object has one of the ACPI ATA methods defined,
1151 * then we can safely call it an ATA device.
1153 bool acpi_ata_match(acpi_handle handle
)
1155 return acpi_has_method(handle
, "_GTF") ||
1156 acpi_has_method(handle
, "_GTM") ||
1157 acpi_has_method(handle
, "_STM") ||
1158 acpi_has_method(handle
, "_SDD");
1162 * acpi_bay_match - see if an acpi object is an ejectable driver bay
1164 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1165 * then we can safely call it an ejectable drive bay
1167 bool acpi_bay_match(acpi_handle handle
)
1169 acpi_handle phandle
;
1171 if (!acpi_has_method(handle
, "_EJ0"))
1173 if (acpi_ata_match(handle
))
1175 if (ACPI_FAILURE(acpi_get_parent(handle
, &phandle
)))
1178 return acpi_ata_match(phandle
);
1181 bool acpi_device_is_battery(struct acpi_device
*adev
)
1183 struct acpi_hardware_id
*hwid
;
1185 list_for_each_entry(hwid
, &adev
->pnp
.ids
, list
)
1186 if (!strcmp("PNP0C0A", hwid
->id
))
1192 static bool is_ejectable_bay(struct acpi_device
*adev
)
1194 acpi_handle handle
= adev
->handle
;
1196 if (acpi_has_method(handle
, "_EJ0") && acpi_device_is_battery(adev
))
1199 return acpi_bay_match(handle
);
1203 * acpi_dock_match - see if an acpi object has a _DCK method
1205 bool acpi_dock_match(acpi_handle handle
)
1207 return acpi_has_method(handle
, "_DCK");
1211 acpi_backlight_cap_match(acpi_handle handle
, u32 level
, void *context
,
1212 void **return_value
)
1214 long *cap
= context
;
1216 if (acpi_has_method(handle
, "_BCM") &&
1217 acpi_has_method(handle
, "_BCL")) {
1218 acpi_handle_debug(handle
, "Found generic backlight support\n");
1219 *cap
|= ACPI_VIDEO_BACKLIGHT
;
1220 /* We have backlight support, no need to scan further */
1221 return AE_CTRL_TERMINATE
;
1226 /* Returns true if the ACPI object is a video device which can be
1227 * handled by video.ko.
1228 * The device will get a Linux specific CID added in scan.c to
1229 * identify the device as an ACPI graphics device
1230 * Be aware that the graphics device may not be physically present
1231 * Use acpi_video_get_capabilities() to detect general ACPI video
1232 * capabilities of present cards
1234 long acpi_is_video_device(acpi_handle handle
)
1236 long video_caps
= 0;
1238 /* Is this device able to support video switching ? */
1239 if (acpi_has_method(handle
, "_DOD") || acpi_has_method(handle
, "_DOS"))
1240 video_caps
|= ACPI_VIDEO_OUTPUT_SWITCHING
;
1242 /* Is this device able to retrieve a video ROM ? */
1243 if (acpi_has_method(handle
, "_ROM"))
1244 video_caps
|= ACPI_VIDEO_ROM_AVAILABLE
;
1246 /* Is this device able to configure which video head to be POSTed ? */
1247 if (acpi_has_method(handle
, "_VPO") &&
1248 acpi_has_method(handle
, "_GPD") &&
1249 acpi_has_method(handle
, "_SPD"))
1250 video_caps
|= ACPI_VIDEO_DEVICE_POSTING
;
1252 /* Only check for backlight functionality if one of the above hit. */
1254 acpi_walk_namespace(ACPI_TYPE_DEVICE
, handle
,
1255 ACPI_UINT32_MAX
, acpi_backlight_cap_match
, NULL
,
1260 EXPORT_SYMBOL(acpi_is_video_device
);
1262 const char *acpi_device_hid(struct acpi_device
*device
)
1264 struct acpi_hardware_id
*hid
;
1266 if (list_empty(&device
->pnp
.ids
))
1269 hid
= list_first_entry(&device
->pnp
.ids
, struct acpi_hardware_id
, list
);
1272 EXPORT_SYMBOL(acpi_device_hid
);
1274 static void acpi_add_id(struct acpi_device_pnp
*pnp
, const char *dev_id
)
1276 struct acpi_hardware_id
*id
;
1278 id
= kmalloc(sizeof(*id
), GFP_KERNEL
);
1282 id
->id
= kstrdup_const(dev_id
, GFP_KERNEL
);
1288 list_add_tail(&id
->list
, &pnp
->ids
);
1289 pnp
->type
.hardware_id
= 1;
1293 * Old IBM workstations have a DSDT bug wherein the SMBus object
1294 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1295 * prefix. Work around this.
1297 static bool acpi_ibm_smbus_match(acpi_handle handle
)
1299 char node_name
[ACPI_PATH_SEGMENT_LENGTH
];
1300 struct acpi_buffer path
= { sizeof(node_name
), node_name
};
1302 if (!dmi_name_in_vendors("IBM"))
1305 /* Look for SMBS object */
1306 if (ACPI_FAILURE(acpi_get_name(handle
, ACPI_SINGLE_NAME
, &path
)) ||
1307 strcmp("SMBS", path
.pointer
))
1310 /* Does it have the necessary (but misnamed) methods? */
1311 if (acpi_has_method(handle
, "SBI") &&
1312 acpi_has_method(handle
, "SBR") &&
1313 acpi_has_method(handle
, "SBW"))
1319 static bool acpi_object_is_system_bus(acpi_handle handle
)
1323 if (ACPI_SUCCESS(acpi_get_handle(NULL
, "\\_SB", &tmp
)) &&
1326 if (ACPI_SUCCESS(acpi_get_handle(NULL
, "\\_TZ", &tmp
)) &&
1333 static void acpi_set_pnp_ids(acpi_handle handle
, struct acpi_device_pnp
*pnp
,
1336 struct acpi_device_info
*info
= NULL
;
1337 struct acpi_pnp_device_id_list
*cid_list
;
1340 switch (device_type
) {
1341 case ACPI_BUS_TYPE_DEVICE
:
1342 if (handle
== ACPI_ROOT_OBJECT
) {
1343 acpi_add_id(pnp
, ACPI_SYSTEM_HID
);
1347 acpi_get_object_info(handle
, &info
);
1349 pr_err("%s: Error reading device info\n", __func__
);
1353 if (info
->valid
& ACPI_VALID_HID
) {
1354 acpi_add_id(pnp
, info
->hardware_id
.string
);
1355 pnp
->type
.platform_id
= 1;
1357 if (info
->valid
& ACPI_VALID_CID
) {
1358 cid_list
= &info
->compatible_id_list
;
1359 for (i
= 0; i
< cid_list
->count
; i
++)
1360 acpi_add_id(pnp
, cid_list
->ids
[i
].string
);
1362 if (info
->valid
& ACPI_VALID_ADR
) {
1363 pnp
->bus_address
= info
->address
;
1364 pnp
->type
.bus_address
= 1;
1366 if (info
->valid
& ACPI_VALID_UID
)
1367 pnp
->unique_id
= kstrdup(info
->unique_id
.string
,
1369 if (info
->valid
& ACPI_VALID_CLS
)
1370 acpi_add_id(pnp
, info
->class_code
.string
);
1375 * Some devices don't reliably have _HIDs & _CIDs, so add
1376 * synthetic HIDs to make sure drivers can find them.
1378 if (acpi_is_video_device(handle
)) {
1379 acpi_add_id(pnp
, ACPI_VIDEO_HID
);
1380 pnp
->type
.backlight
= 1;
1383 if (acpi_bay_match(handle
))
1384 acpi_add_id(pnp
, ACPI_BAY_HID
);
1385 else if (acpi_dock_match(handle
))
1386 acpi_add_id(pnp
, ACPI_DOCK_HID
);
1387 else if (acpi_ibm_smbus_match(handle
))
1388 acpi_add_id(pnp
, ACPI_SMBUS_IBM_HID
);
1389 else if (list_empty(&pnp
->ids
) &&
1390 acpi_object_is_system_bus(handle
)) {
1391 /* \_SB, \_TZ, LNXSYBUS */
1392 acpi_add_id(pnp
, ACPI_BUS_HID
);
1393 strcpy(pnp
->device_name
, ACPI_BUS_DEVICE_NAME
);
1394 strcpy(pnp
->device_class
, ACPI_BUS_CLASS
);
1398 case ACPI_BUS_TYPE_POWER
:
1399 acpi_add_id(pnp
, ACPI_POWER_HID
);
1401 case ACPI_BUS_TYPE_PROCESSOR
:
1402 acpi_add_id(pnp
, ACPI_PROCESSOR_OBJECT_HID
);
1404 case ACPI_BUS_TYPE_THERMAL
:
1405 acpi_add_id(pnp
, ACPI_THERMAL_HID
);
1407 case ACPI_BUS_TYPE_POWER_BUTTON
:
1408 acpi_add_id(pnp
, ACPI_BUTTON_HID_POWERF
);
1410 case ACPI_BUS_TYPE_SLEEP_BUTTON
:
1411 acpi_add_id(pnp
, ACPI_BUTTON_HID_SLEEPF
);
1413 case ACPI_BUS_TYPE_ECDT_EC
:
1414 acpi_add_id(pnp
, ACPI_ECDT_HID
);
1419 void acpi_free_pnp_ids(struct acpi_device_pnp
*pnp
)
1421 struct acpi_hardware_id
*id
, *tmp
;
1423 list_for_each_entry_safe(id
, tmp
, &pnp
->ids
, list
) {
1424 kfree_const(id
->id
);
1427 kfree(pnp
->unique_id
);
1431 * acpi_dma_supported - Check DMA support for the specified device.
1432 * @adev: The pointer to acpi device
1434 * Return false if DMA is not supported. Otherwise, return true
1436 bool acpi_dma_supported(const struct acpi_device
*adev
)
1441 if (adev
->flags
.cca_seen
)
1445 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent
1446 * DMA on "Intel platforms". Presumably that includes all x86 and
1447 * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y.
1449 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED
))
1456 * acpi_get_dma_attr - Check the supported DMA attr for the specified device.
1457 * @adev: The pointer to acpi device
1459 * Return enum dev_dma_attr.
1461 enum dev_dma_attr
acpi_get_dma_attr(struct acpi_device
*adev
)
1463 if (!acpi_dma_supported(adev
))
1464 return DEV_DMA_NOT_SUPPORTED
;
1466 if (adev
->flags
.coherent_dma
)
1467 return DEV_DMA_COHERENT
;
1469 return DEV_DMA_NON_COHERENT
;
1473 * acpi_dma_get_range() - Get device DMA parameters.
1475 * @dev: device to configure
1476 * @map: pointer to DMA ranges result
1478 * Evaluate DMA regions and return pointer to DMA regions on
1479 * parsing success; it does not update the passed in values on failure.
1481 * Return 0 on success, < 0 on failure.
1483 int acpi_dma_get_range(struct device
*dev
, const struct bus_dma_region
**map
)
1485 struct acpi_device
*adev
;
1487 struct resource_entry
*rentry
;
1489 struct device
*dma_dev
= dev
;
1490 struct bus_dma_region
*r
;
1493 * Walk the device tree chasing an ACPI companion with a _DMA
1494 * object while we go. Stop if we find a device with an ACPI
1495 * companion containing a _DMA method.
1498 adev
= ACPI_COMPANION(dma_dev
);
1499 if (adev
&& acpi_has_method(adev
->handle
, METHOD_NAME__DMA
))
1502 dma_dev
= dma_dev
->parent
;
1508 if (!acpi_has_method(adev
->handle
, METHOD_NAME__CRS
)) {
1509 acpi_handle_warn(adev
->handle
, "_DMA is valid only if _CRS is present\n");
1513 ret
= acpi_dev_get_dma_resources(adev
, &list
);
1515 r
= kcalloc(ret
+ 1, sizeof(*r
), GFP_KERNEL
);
1523 list_for_each_entry(rentry
, &list
, node
) {
1524 if (rentry
->res
->start
>= rentry
->res
->end
) {
1528 dev_dbg(dma_dev
, "Invalid DMA regions configuration\n");
1532 r
->cpu_start
= rentry
->res
->start
;
1533 r
->dma_start
= rentry
->res
->start
- rentry
->offset
;
1534 r
->size
= resource_size(rentry
->res
);
1539 acpi_dev_free_resource_list(&list
);
1541 return ret
>= 0 ? 0 : ret
;
1544 #ifdef CONFIG_IOMMU_API
1545 int acpi_iommu_fwspec_init(struct device
*dev
, u32 id
,
1546 struct fwnode_handle
*fwnode
,
1547 const struct iommu_ops
*ops
)
1549 int ret
= iommu_fwspec_init(dev
, fwnode
, ops
);
1552 ret
= iommu_fwspec_add_ids(dev
, &id
, 1);
1557 static inline const struct iommu_ops
*acpi_iommu_fwspec_ops(struct device
*dev
)
1559 struct iommu_fwspec
*fwspec
= dev_iommu_fwspec_get(dev
);
1561 return fwspec
? fwspec
->ops
: NULL
;
1564 static const struct iommu_ops
*acpi_iommu_configure_id(struct device
*dev
,
1568 const struct iommu_ops
*ops
;
1570 /* Serialise to make dev->iommu stable under our potential fwspec */
1571 mutex_lock(&iommu_probe_device_lock
);
1573 * If we already translated the fwspec there is nothing left to do,
1574 * return the iommu_ops.
1576 ops
= acpi_iommu_fwspec_ops(dev
);
1578 mutex_unlock(&iommu_probe_device_lock
);
1582 err
= iort_iommu_configure_id(dev
, id_in
);
1583 if (err
&& err
!= -EPROBE_DEFER
)
1584 err
= viot_iommu_configure(dev
);
1585 mutex_unlock(&iommu_probe_device_lock
);
1588 * If we have reason to believe the IOMMU driver missed the initial
1589 * iommu_probe_device() call for dev, replay it to get things in order.
1591 if (!err
&& dev
->bus
)
1592 err
= iommu_probe_device(dev
);
1594 /* Ignore all other errors apart from EPROBE_DEFER */
1595 if (err
== -EPROBE_DEFER
) {
1596 return ERR_PTR(err
);
1598 dev_dbg(dev
, "Adding to IOMMU failed: %d\n", err
);
1601 return acpi_iommu_fwspec_ops(dev
);
1604 #else /* !CONFIG_IOMMU_API */
1606 int acpi_iommu_fwspec_init(struct device
*dev
, u32 id
,
1607 struct fwnode_handle
*fwnode
,
1608 const struct iommu_ops
*ops
)
1613 static const struct iommu_ops
*acpi_iommu_configure_id(struct device
*dev
,
1619 #endif /* !CONFIG_IOMMU_API */
1622 * acpi_dma_configure_id - Set-up DMA configuration for the device.
1623 * @dev: The pointer to the device
1624 * @attr: device dma attributes
1625 * @input_id: input device id const value pointer
1627 int acpi_dma_configure_id(struct device
*dev
, enum dev_dma_attr attr
,
1628 const u32
*input_id
)
1630 const struct iommu_ops
*iommu
;
1632 if (attr
== DEV_DMA_NOT_SUPPORTED
) {
1633 set_dma_ops(dev
, &dma_dummy_ops
);
1637 acpi_arch_dma_setup(dev
);
1639 iommu
= acpi_iommu_configure_id(dev
, input_id
);
1640 if (PTR_ERR(iommu
) == -EPROBE_DEFER
)
1641 return -EPROBE_DEFER
;
1643 arch_setup_dma_ops(dev
, 0, U64_MAX
,
1644 iommu
, attr
== DEV_DMA_COHERENT
);
1648 EXPORT_SYMBOL_GPL(acpi_dma_configure_id
);
1650 static void acpi_init_coherency(struct acpi_device
*adev
)
1652 unsigned long long cca
= 0;
1654 struct acpi_device
*parent
= acpi_dev_parent(adev
);
1656 if (parent
&& parent
->flags
.cca_seen
) {
1658 * From ACPI spec, OSPM will ignore _CCA if an ancestor
1661 adev
->flags
.cca_seen
= 1;
1662 cca
= parent
->flags
.coherent_dma
;
1664 status
= acpi_evaluate_integer(adev
->handle
, "_CCA",
1666 if (ACPI_SUCCESS(status
))
1667 adev
->flags
.cca_seen
= 1;
1668 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED
))
1670 * If architecture does not specify that _CCA is
1671 * required for DMA-able devices (e.g. x86),
1672 * we default to _CCA=1.
1676 acpi_handle_debug(adev
->handle
,
1677 "ACPI device is missing _CCA.\n");
1680 adev
->flags
.coherent_dma
= cca
;
1683 static int acpi_check_serial_bus_slave(struct acpi_resource
*ares
, void *data
)
1685 bool *is_serial_bus_slave_p
= data
;
1687 if (ares
->type
!= ACPI_RESOURCE_TYPE_SERIAL_BUS
)
1690 *is_serial_bus_slave_p
= true;
1692 /* no need to do more checking */
1696 static bool acpi_is_indirect_io_slave(struct acpi_device
*device
)
1698 struct acpi_device
*parent
= acpi_dev_parent(device
);
1699 static const struct acpi_device_id indirect_io_hosts
[] = {
1704 return parent
&& !acpi_match_device_ids(parent
, indirect_io_hosts
);
1707 static bool acpi_device_enumeration_by_parent(struct acpi_device
*device
)
1709 struct list_head resource_list
;
1710 bool is_serial_bus_slave
= false;
1711 static const struct acpi_device_id ignore_serial_bus_ids
[] = {
1713 * These devices have multiple SerialBus resources and a client
1714 * device must be instantiated for each of them, each with
1715 * its own device id.
1716 * Normally we only instantiate one client device for the first
1717 * resource, using the ACPI HID as id. These special cases are handled
1718 * by the drivers/platform/x86/serial-multi-instantiate.c driver, which
1719 * knows which client device id to use for each resource.
1727 /* Non-conforming _HID for Cirrus Logic already released */
1731 * Some ACPI devs contain SerialBus resources even though they are not
1732 * attached to a serial bus at all.
1737 * HIDs of device with an UartSerialBusV2 resource for which userspace
1738 * expects a regular tty cdev to be created (instead of the in kernel
1739 * serdev) and which have a kernel driver which expects a platform_dev
1740 * such as the rfkill-gpio driver.
1747 if (acpi_is_indirect_io_slave(device
))
1750 /* Macs use device properties in lieu of _CRS resources */
1751 if (x86_apple_machine
&&
1752 (fwnode_property_present(&device
->fwnode
, "spiSclkPeriod") ||
1753 fwnode_property_present(&device
->fwnode
, "i2cAddress") ||
1754 fwnode_property_present(&device
->fwnode
, "baud")))
1757 if (!acpi_match_device_ids(device
, ignore_serial_bus_ids
))
1760 INIT_LIST_HEAD(&resource_list
);
1761 acpi_dev_get_resources(device
, &resource_list
,
1762 acpi_check_serial_bus_slave
,
1763 &is_serial_bus_slave
);
1764 acpi_dev_free_resource_list(&resource_list
);
1766 return is_serial_bus_slave
;
1769 void acpi_init_device_object(struct acpi_device
*device
, acpi_handle handle
,
1770 int type
, void (*release
)(struct device
*))
1772 struct acpi_device
*parent
= acpi_find_parent_acpi_dev(handle
);
1774 INIT_LIST_HEAD(&device
->pnp
.ids
);
1775 device
->device_type
= type
;
1776 device
->handle
= handle
;
1777 device
->dev
.parent
= parent
? &parent
->dev
: NULL
;
1778 device
->dev
.release
= release
;
1779 device
->dev
.bus
= &acpi_bus_type
;
1780 fwnode_init(&device
->fwnode
, &acpi_device_fwnode_ops
);
1781 acpi_set_device_status(device
, ACPI_STA_DEFAULT
);
1782 acpi_device_get_busid(device
);
1783 acpi_set_pnp_ids(handle
, &device
->pnp
, type
);
1784 acpi_init_properties(device
);
1785 acpi_bus_get_flags(device
);
1786 device
->flags
.match_driver
= false;
1787 device
->flags
.initialized
= true;
1788 device
->flags
.enumeration_by_parent
=
1789 acpi_device_enumeration_by_parent(device
);
1790 acpi_device_clear_enumerated(device
);
1791 device_initialize(&device
->dev
);
1792 dev_set_uevent_suppress(&device
->dev
, true);
1793 acpi_init_coherency(device
);
1796 static void acpi_scan_dep_init(struct acpi_device
*adev
)
1798 struct acpi_dep_data
*dep
;
1800 list_for_each_entry(dep
, &acpi_dep_list
, node
) {
1801 if (dep
->consumer
== adev
->handle
) {
1803 adev
->flags
.honor_deps
= 1;
1810 void acpi_device_add_finalize(struct acpi_device
*device
)
1812 dev_set_uevent_suppress(&device
->dev
, false);
1813 kobject_uevent(&device
->dev
.kobj
, KOBJ_ADD
);
1816 static void acpi_scan_init_status(struct acpi_device
*adev
)
1818 if (acpi_bus_get_status(adev
))
1819 acpi_set_device_status(adev
, 0);
1822 static int acpi_add_single_object(struct acpi_device
**child
,
1823 acpi_handle handle
, int type
, bool dep_init
)
1825 struct acpi_device
*device
;
1826 bool release_dep_lock
= false;
1829 device
= kzalloc(sizeof(struct acpi_device
), GFP_KERNEL
);
1833 acpi_init_device_object(device
, handle
, type
, acpi_device_release
);
1835 * Getting the status is delayed till here so that we can call
1836 * acpi_bus_get_status() and use its quirk handling. Note that
1837 * this must be done before the get power-/wakeup_dev-flags calls.
1839 if (type
== ACPI_BUS_TYPE_DEVICE
|| type
== ACPI_BUS_TYPE_PROCESSOR
) {
1841 mutex_lock(&acpi_dep_list_lock
);
1843 * Hold the lock until the acpi_tie_acpi_dev() call
1844 * below to prevent concurrent acpi_scan_clear_dep()
1845 * from deleting a dependency list entry without
1846 * updating dep_unmet for the device.
1848 release_dep_lock
= true;
1849 acpi_scan_dep_init(device
);
1851 acpi_scan_init_status(device
);
1854 acpi_bus_get_power_flags(device
);
1855 acpi_bus_get_wakeup_device_flags(device
);
1857 result
= acpi_tie_acpi_dev(device
);
1859 if (release_dep_lock
)
1860 mutex_unlock(&acpi_dep_list_lock
);
1863 result
= acpi_device_add(device
);
1866 acpi_device_release(&device
->dev
);
1870 acpi_power_add_remove_device(device
, true);
1871 acpi_device_add_finalize(device
);
1873 acpi_handle_debug(handle
, "Added as %s, parent %s\n",
1874 dev_name(&device
->dev
), device
->dev
.parent
?
1875 dev_name(device
->dev
.parent
) : "(null)");
1881 static acpi_status
acpi_get_resource_memory(struct acpi_resource
*ares
,
1884 struct resource
*res
= context
;
1886 if (acpi_dev_resource_memory(ares
, res
))
1887 return AE_CTRL_TERMINATE
;
1892 static bool acpi_device_should_be_hidden(acpi_handle handle
)
1895 struct resource res
;
1897 /* Check if it should ignore the UART device */
1898 if (!(spcr_uart_addr
&& acpi_has_method(handle
, METHOD_NAME__CRS
)))
1902 * The UART device described in SPCR table is assumed to have only one
1903 * memory resource present. So we only look for the first one here.
1905 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
1906 acpi_get_resource_memory
, &res
);
1907 if (ACPI_FAILURE(status
) || res
.start
!= spcr_uart_addr
)
1910 acpi_handle_info(handle
, "The UART device @%pa in SPCR table will be hidden\n",
1916 bool acpi_device_is_present(const struct acpi_device
*adev
)
1918 return adev
->status
.present
|| adev
->status
.functional
;
1921 static bool acpi_scan_handler_matching(struct acpi_scan_handler
*handler
,
1923 const struct acpi_device_id
**matchid
)
1925 const struct acpi_device_id
*devid
;
1928 return handler
->match(idstr
, matchid
);
1930 for (devid
= handler
->ids
; devid
->id
[0]; devid
++)
1931 if (!strcmp((char *)devid
->id
, idstr
)) {
1941 static struct acpi_scan_handler
*acpi_scan_match_handler(const char *idstr
,
1942 const struct acpi_device_id
**matchid
)
1944 struct acpi_scan_handler
*handler
;
1946 list_for_each_entry(handler
, &acpi_scan_handlers_list
, list_node
)
1947 if (acpi_scan_handler_matching(handler
, idstr
, matchid
))
1953 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile
*hotplug
, bool val
)
1955 if (!!hotplug
->enabled
== !!val
)
1958 mutex_lock(&acpi_scan_lock
);
1960 hotplug
->enabled
= val
;
1962 mutex_unlock(&acpi_scan_lock
);
1965 static void acpi_scan_init_hotplug(struct acpi_device
*adev
)
1967 struct acpi_hardware_id
*hwid
;
1969 if (acpi_dock_match(adev
->handle
) || is_ejectable_bay(adev
)) {
1970 acpi_dock_add(adev
);
1973 list_for_each_entry(hwid
, &adev
->pnp
.ids
, list
) {
1974 struct acpi_scan_handler
*handler
;
1976 handler
= acpi_scan_match_handler(hwid
->id
, NULL
);
1978 adev
->flags
.hotplug_notify
= true;
1984 static u32
acpi_scan_check_dep(acpi_handle handle
)
1986 struct acpi_handle_list dep_devices
;
1991 * Check for _HID here to avoid deferring the enumeration of:
1993 * 2. ACPI nodes describing USB ports.
1994 * Still, checking for _HID catches more then just these cases ...
1996 if (!acpi_has_method(handle
, "_DEP") || !acpi_has_method(handle
, "_HID"))
1999 if (!acpi_evaluate_reference(handle
, "_DEP", NULL
, &dep_devices
)) {
2000 acpi_handle_debug(handle
, "Failed to evaluate _DEP.\n");
2004 for (count
= 0, i
= 0; i
< dep_devices
.count
; i
++) {
2005 struct acpi_device_info
*info
;
2006 struct acpi_dep_data
*dep
;
2007 bool skip
, honor_dep
;
2010 status
= acpi_get_object_info(dep_devices
.handles
[i
], &info
);
2011 if (ACPI_FAILURE(status
)) {
2012 acpi_handle_debug(handle
, "Error reading _DEP device info\n");
2016 skip
= acpi_info_matches_ids(info
, acpi_ignore_dep_ids
);
2017 honor_dep
= acpi_info_matches_ids(info
, acpi_honor_dep_ids
);
2023 dep
= kzalloc(sizeof(*dep
), GFP_KERNEL
);
2029 dep
->supplier
= dep_devices
.handles
[i
];
2030 dep
->consumer
= handle
;
2031 dep
->honor_dep
= honor_dep
;
2033 mutex_lock(&acpi_dep_list_lock
);
2034 list_add_tail(&dep
->node
, &acpi_dep_list
);
2035 mutex_unlock(&acpi_dep_list_lock
);
2038 acpi_handle_list_free(&dep_devices
);
2042 static acpi_status
acpi_scan_check_crs_csi2_cb(acpi_handle handle
, u32 a
, void *b
, void **c
)
2044 acpi_mipi_check_crs_csi2(handle
);
2048 static acpi_status
acpi_bus_check_add(acpi_handle handle
, bool first_pass
,
2049 struct acpi_device
**adev_p
)
2051 struct acpi_device
*device
= acpi_fetch_acpi_dev(handle
);
2052 acpi_object_type acpi_type
;
2058 if (ACPI_FAILURE(acpi_get_type(handle
, &acpi_type
)))
2061 switch (acpi_type
) {
2062 case ACPI_TYPE_DEVICE
:
2063 if (acpi_device_should_be_hidden(handle
))
2067 acpi_mipi_check_crs_csi2(handle
);
2069 /* Bail out if there are dependencies. */
2070 if (acpi_scan_check_dep(handle
) > 0) {
2072 * The entire CSI-2 connection graph needs to be
2073 * extracted before any drivers or scan handlers
2074 * are bound to struct device objects, so scan
2075 * _CRS CSI-2 resource descriptors for all
2076 * devices below the current handle.
2078 acpi_walk_namespace(ACPI_TYPE_DEVICE
, handle
,
2080 acpi_scan_check_crs_csi2_cb
,
2082 return AE_CTRL_DEPTH
;
2087 case ACPI_TYPE_ANY
: /* for ACPI_ROOT_OBJECT */
2088 type
= ACPI_BUS_TYPE_DEVICE
;
2091 case ACPI_TYPE_PROCESSOR
:
2092 type
= ACPI_BUS_TYPE_PROCESSOR
;
2095 case ACPI_TYPE_THERMAL
:
2096 type
= ACPI_BUS_TYPE_THERMAL
;
2099 case ACPI_TYPE_POWER
:
2100 acpi_add_power_resource(handle
);
2107 * If first_pass is true at this point, the device has no dependencies,
2108 * or the creation of the device object would have been postponed above.
2110 acpi_add_single_object(&device
, handle
, type
, !first_pass
);
2112 return AE_CTRL_DEPTH
;
2114 acpi_scan_init_hotplug(device
);
2123 static acpi_status
acpi_bus_check_add_1(acpi_handle handle
, u32 lvl_not_used
,
2124 void *not_used
, void **ret_p
)
2126 return acpi_bus_check_add(handle
, true, (struct acpi_device
**)ret_p
);
2129 static acpi_status
acpi_bus_check_add_2(acpi_handle handle
, u32 lvl_not_used
,
2130 void *not_used
, void **ret_p
)
2132 return acpi_bus_check_add(handle
, false, (struct acpi_device
**)ret_p
);
2135 static void acpi_default_enumeration(struct acpi_device
*device
)
2138 * Do not enumerate devices with enumeration_by_parent flag set as
2139 * they will be enumerated by their respective parents.
2141 if (!device
->flags
.enumeration_by_parent
) {
2142 acpi_create_platform_device(device
, NULL
);
2143 acpi_device_set_enumerated(device
);
2145 blocking_notifier_call_chain(&acpi_reconfig_chain
,
2146 ACPI_RECONFIG_DEVICE_ADD
, device
);
2150 static const struct acpi_device_id generic_device_ids
[] = {
2151 {ACPI_DT_NAMESPACE_HID
, },
2155 static int acpi_generic_device_attach(struct acpi_device
*adev
,
2156 const struct acpi_device_id
*not_used
)
2159 * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test
2160 * below can be unconditional.
2162 if (adev
->data
.of_compatible
)
2163 acpi_default_enumeration(adev
);
2168 static struct acpi_scan_handler generic_device_handler
= {
2169 .ids
= generic_device_ids
,
2170 .attach
= acpi_generic_device_attach
,
2173 static int acpi_scan_attach_handler(struct acpi_device
*device
)
2175 struct acpi_hardware_id
*hwid
;
2178 list_for_each_entry(hwid
, &device
->pnp
.ids
, list
) {
2179 const struct acpi_device_id
*devid
;
2180 struct acpi_scan_handler
*handler
;
2182 handler
= acpi_scan_match_handler(hwid
->id
, &devid
);
2184 if (!handler
->attach
) {
2185 device
->pnp
.type
.platform_id
= 0;
2188 device
->handler
= handler
;
2189 ret
= handler
->attach(device
, devid
);
2193 device
->handler
= NULL
;
2202 static int acpi_bus_attach(struct acpi_device
*device
, void *first_pass
)
2204 bool skip
= !first_pass
&& device
->flags
.visited
;
2211 if (ACPI_SUCCESS(acpi_bus_get_ejd(device
->handle
, &ejd
)))
2212 register_dock_dependent_device(device
, ejd
);
2214 acpi_bus_get_status(device
);
2215 /* Skip devices that are not ready for enumeration (e.g. not present) */
2216 if (!acpi_dev_ready_for_enumeration(device
)) {
2217 device
->flags
.initialized
= false;
2218 acpi_device_clear_enumerated(device
);
2219 device
->flags
.power_manageable
= 0;
2222 if (device
->handler
)
2225 if (!device
->flags
.initialized
) {
2226 device
->flags
.power_manageable
=
2227 device
->power
.states
[ACPI_STATE_D0
].flags
.valid
;
2228 if (acpi_bus_init_power(device
))
2229 device
->flags
.power_manageable
= 0;
2231 device
->flags
.initialized
= true;
2232 } else if (device
->flags
.visited
) {
2236 ret
= acpi_scan_attach_handler(device
);
2240 device
->flags
.match_driver
= true;
2241 if (ret
> 0 && !device
->flags
.enumeration_by_parent
) {
2242 acpi_device_set_enumerated(device
);
2246 ret
= device_attach(&device
->dev
);
2250 if (device
->pnp
.type
.platform_id
|| device
->flags
.enumeration_by_parent
)
2251 acpi_default_enumeration(device
);
2253 acpi_device_set_enumerated(device
);
2256 acpi_dev_for_each_child(device
, acpi_bus_attach
, first_pass
);
2258 if (!skip
&& device
->handler
&& device
->handler
->hotplug
.notify_online
)
2259 device
->handler
->hotplug
.notify_online(device
);
2264 static int acpi_dev_get_next_consumer_dev_cb(struct acpi_dep_data
*dep
, void *data
)
2266 struct acpi_device
**adev_p
= data
;
2267 struct acpi_device
*adev
= *adev_p
;
2270 * If we're passed a 'previous' consumer device then we need to skip
2271 * any consumers until we meet the previous one, and then NULL @data
2272 * so the next one can be returned.
2275 if (dep
->consumer
== adev
->handle
)
2281 adev
= acpi_get_acpi_dev(dep
->consumer
);
2283 *(struct acpi_device
**)data
= adev
;
2286 /* Continue parsing if the device object is not present. */
2290 struct acpi_scan_clear_dep_work
{
2291 struct work_struct work
;
2292 struct acpi_device
*adev
;
2295 static void acpi_scan_clear_dep_fn(struct work_struct
*work
)
2297 struct acpi_scan_clear_dep_work
*cdw
;
2299 cdw
= container_of(work
, struct acpi_scan_clear_dep_work
, work
);
2301 acpi_scan_lock_acquire();
2302 acpi_bus_attach(cdw
->adev
, (void *)true);
2303 acpi_scan_lock_release();
2305 acpi_dev_put(cdw
->adev
);
2309 static bool acpi_scan_clear_dep_queue(struct acpi_device
*adev
)
2311 struct acpi_scan_clear_dep_work
*cdw
;
2313 if (adev
->dep_unmet
)
2316 cdw
= kmalloc(sizeof(*cdw
), GFP_KERNEL
);
2321 INIT_WORK(&cdw
->work
, acpi_scan_clear_dep_fn
);
2323 * Since the work function may block on the lock until the entire
2324 * initial enumeration of devices is complete, put it into the unbound
2327 queue_work(system_unbound_wq
, &cdw
->work
);
2332 static void acpi_scan_delete_dep_data(struct acpi_dep_data
*dep
)
2334 list_del(&dep
->node
);
2338 static int acpi_scan_clear_dep(struct acpi_dep_data
*dep
, void *data
)
2340 struct acpi_device
*adev
= acpi_get_acpi_dev(dep
->consumer
);
2344 if (!acpi_scan_clear_dep_queue(adev
))
2348 if (dep
->free_when_met
)
2349 acpi_scan_delete_dep_data(dep
);
2357 * acpi_walk_dep_device_list - Apply a callback to every entry in acpi_dep_list
2358 * @handle: The ACPI handle of the supplier device
2359 * @callback: Pointer to the callback function to apply
2360 * @data: Pointer to some data to pass to the callback
2362 * The return value of the callback determines this function's behaviour. If 0
2363 * is returned we continue to iterate over acpi_dep_list. If a positive value
2364 * is returned then the loop is broken but this function returns 0. If a
2365 * negative value is returned by the callback then the loop is broken and that
2366 * value is returned as the final error.
2368 static int acpi_walk_dep_device_list(acpi_handle handle
,
2369 int (*callback
)(struct acpi_dep_data
*, void *),
2372 struct acpi_dep_data
*dep
, *tmp
;
2375 mutex_lock(&acpi_dep_list_lock
);
2376 list_for_each_entry_safe(dep
, tmp
, &acpi_dep_list
, node
) {
2377 if (dep
->supplier
== handle
) {
2378 ret
= callback(dep
, data
);
2383 mutex_unlock(&acpi_dep_list_lock
);
2385 return ret
> 0 ? 0 : ret
;
2389 * acpi_dev_clear_dependencies - Inform consumers that the device is now active
2390 * @supplier: Pointer to the supplier &struct acpi_device
2392 * Clear dependencies on the given device.
2394 void acpi_dev_clear_dependencies(struct acpi_device
*supplier
)
2396 acpi_walk_dep_device_list(supplier
->handle
, acpi_scan_clear_dep
, NULL
);
2398 EXPORT_SYMBOL_GPL(acpi_dev_clear_dependencies
);
2401 * acpi_dev_ready_for_enumeration - Check if the ACPI device is ready for enumeration
2402 * @device: Pointer to the &struct acpi_device to check
2404 * Check if the device is present and has no unmet dependencies.
2406 * Return true if the device is ready for enumeratino. Otherwise, return false.
2408 bool acpi_dev_ready_for_enumeration(const struct acpi_device
*device
)
2410 if (device
->flags
.honor_deps
&& device
->dep_unmet
)
2413 return acpi_device_is_present(device
);
2415 EXPORT_SYMBOL_GPL(acpi_dev_ready_for_enumeration
);
2418 * acpi_dev_get_next_consumer_dev - Return the next adev dependent on @supplier
2419 * @supplier: Pointer to the dependee device
2420 * @start: Pointer to the current dependent device
2422 * Returns the next &struct acpi_device which declares itself dependent on
2423 * @supplier via the _DEP buffer, parsed from the acpi_dep_list.
2425 * If the returned adev is not passed as @start to this function, the caller is
2426 * responsible for putting the reference to adev when it is no longer needed.
2428 struct acpi_device
*acpi_dev_get_next_consumer_dev(struct acpi_device
*supplier
,
2429 struct acpi_device
*start
)
2431 struct acpi_device
*adev
= start
;
2433 acpi_walk_dep_device_list(supplier
->handle
,
2434 acpi_dev_get_next_consumer_dev_cb
, &adev
);
2436 acpi_dev_put(start
);
2443 EXPORT_SYMBOL_GPL(acpi_dev_get_next_consumer_dev
);
2445 static void acpi_scan_postponed_branch(acpi_handle handle
)
2447 struct acpi_device
*adev
= NULL
;
2449 if (ACPI_FAILURE(acpi_bus_check_add(handle
, false, &adev
)))
2452 acpi_walk_namespace(ACPI_TYPE_ANY
, handle
, ACPI_UINT32_MAX
,
2453 acpi_bus_check_add_2
, NULL
, NULL
, (void **)&adev
);
2456 * Populate the ACPI _CRS CSI-2 software nodes for the ACPI devices that
2457 * have been added above.
2459 acpi_mipi_init_crs_csi2_swnodes();
2461 acpi_bus_attach(adev
, NULL
);
2464 static void acpi_scan_postponed(void)
2466 struct acpi_dep_data
*dep
, *tmp
;
2468 mutex_lock(&acpi_dep_list_lock
);
2470 list_for_each_entry_safe(dep
, tmp
, &acpi_dep_list
, node
) {
2471 acpi_handle handle
= dep
->consumer
;
2474 * In case there are multiple acpi_dep_list entries with the
2475 * same consumer, skip the current entry if the consumer device
2476 * object corresponding to it is present already.
2478 if (!acpi_fetch_acpi_dev(handle
)) {
2480 * Even though the lock is released here, tmp is
2481 * guaranteed to be valid, because none of the list
2482 * entries following dep is marked as "free when met"
2483 * and so they cannot be deleted.
2485 mutex_unlock(&acpi_dep_list_lock
);
2487 acpi_scan_postponed_branch(handle
);
2489 mutex_lock(&acpi_dep_list_lock
);
2493 acpi_scan_delete_dep_data(dep
);
2495 dep
->free_when_met
= true;
2498 mutex_unlock(&acpi_dep_list_lock
);
2502 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2503 * @handle: Root of the namespace scope to scan.
2505 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
2508 * If no devices were found, -ENODEV is returned, but it does not mean that
2509 * there has been a real error. There just have been no suitable ACPI objects
2510 * in the table trunk from which the kernel could create a device and add an
2511 * appropriate driver.
2513 * Must be called under acpi_scan_lock.
2515 int acpi_bus_scan(acpi_handle handle
)
2517 struct acpi_device
*device
= NULL
;
2519 /* Pass 1: Avoid enumerating devices with missing dependencies. */
2521 if (ACPI_SUCCESS(acpi_bus_check_add(handle
, true, &device
)))
2522 acpi_walk_namespace(ACPI_TYPE_ANY
, handle
, ACPI_UINT32_MAX
,
2523 acpi_bus_check_add_1
, NULL
, NULL
,
2530 * Set up ACPI _CRS CSI-2 software nodes using information extracted
2531 * from the _CRS CSI-2 resource descriptors during the ACPI namespace
2532 * walk above and MIPI DisCo for Imaging device properties.
2534 acpi_mipi_scan_crs_csi2();
2535 acpi_mipi_init_crs_csi2_swnodes();
2537 acpi_bus_attach(device
, (void *)true);
2539 /* Pass 2: Enumerate all of the remaining devices. */
2541 acpi_scan_postponed();
2543 acpi_mipi_crs_csi2_cleanup();
2547 EXPORT_SYMBOL(acpi_bus_scan
);
2549 static int acpi_bus_trim_one(struct acpi_device
*adev
, void *not_used
)
2551 struct acpi_scan_handler
*handler
= adev
->handler
;
2553 acpi_dev_for_each_child_reverse(adev
, acpi_bus_trim_one
, NULL
);
2555 adev
->flags
.match_driver
= false;
2557 if (handler
->detach
)
2558 handler
->detach(adev
);
2560 adev
->handler
= NULL
;
2562 device_release_driver(&adev
->dev
);
2565 * Most likely, the device is going away, so put it into D3cold before
2568 acpi_device_set_power(adev
, ACPI_STATE_D3_COLD
);
2569 adev
->flags
.initialized
= false;
2570 acpi_device_clear_enumerated(adev
);
2576 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
2577 * @adev: Root of the ACPI namespace scope to walk.
2579 * Must be called under acpi_scan_lock.
2581 void acpi_bus_trim(struct acpi_device
*adev
)
2583 acpi_bus_trim_one(adev
, NULL
);
2585 EXPORT_SYMBOL_GPL(acpi_bus_trim
);
2587 int acpi_bus_register_early_device(int type
)
2589 struct acpi_device
*device
= NULL
;
2592 result
= acpi_add_single_object(&device
, NULL
, type
, false);
2596 device
->flags
.match_driver
= true;
2597 return device_attach(&device
->dev
);
2599 EXPORT_SYMBOL_GPL(acpi_bus_register_early_device
);
2601 static void acpi_bus_scan_fixed(void)
2603 if (!(acpi_gbl_FADT
.flags
& ACPI_FADT_POWER_BUTTON
)) {
2604 struct acpi_device
*adev
= NULL
;
2606 acpi_add_single_object(&adev
, NULL
, ACPI_BUS_TYPE_POWER_BUTTON
,
2609 adev
->flags
.match_driver
= true;
2610 if (device_attach(&adev
->dev
) >= 0)
2611 device_init_wakeup(&adev
->dev
, true);
2613 dev_dbg(&adev
->dev
, "No driver\n");
2617 if (!(acpi_gbl_FADT
.flags
& ACPI_FADT_SLEEP_BUTTON
)) {
2618 struct acpi_device
*adev
= NULL
;
2620 acpi_add_single_object(&adev
, NULL
, ACPI_BUS_TYPE_SLEEP_BUTTON
,
2623 adev
->flags
.match_driver
= true;
2624 if (device_attach(&adev
->dev
) < 0)
2625 dev_dbg(&adev
->dev
, "No driver\n");
2630 static void __init
acpi_get_spcr_uart_addr(void)
2633 struct acpi_table_spcr
*spcr_ptr
;
2635 status
= acpi_get_table(ACPI_SIG_SPCR
, 0,
2636 (struct acpi_table_header
**)&spcr_ptr
);
2637 if (ACPI_FAILURE(status
)) {
2638 pr_warn("STAO table present, but SPCR is missing\n");
2642 spcr_uart_addr
= spcr_ptr
->serial_port
.address
;
2643 acpi_put_table((struct acpi_table_header
*)spcr_ptr
);
2646 static bool acpi_scan_initialized
;
2648 void __init
acpi_scan_init(void)
2651 struct acpi_table_stao
*stao_ptr
;
2653 acpi_pci_root_init();
2654 acpi_pci_link_init();
2655 acpi_processor_init();
2656 acpi_platform_init();
2659 acpi_cmos_rtc_init();
2660 acpi_container_init();
2661 acpi_memory_hotplug_init();
2662 acpi_watchdog_init();
2664 acpi_int340x_thermal_init();
2667 acpi_scan_add_handler(&generic_device_handler
);
2670 * If there is STAO table, check whether it needs to ignore the UART
2671 * device in SPCR table.
2673 status
= acpi_get_table(ACPI_SIG_STAO
, 0,
2674 (struct acpi_table_header
**)&stao_ptr
);
2675 if (ACPI_SUCCESS(status
)) {
2676 if (stao_ptr
->header
.length
> sizeof(struct acpi_table_stao
))
2677 pr_info("STAO Name List not yet supported.\n");
2679 if (stao_ptr
->ignore_uart
)
2680 acpi_get_spcr_uart_addr();
2682 acpi_put_table((struct acpi_table_header
*)stao_ptr
);
2685 acpi_gpe_apply_masked_gpes();
2686 acpi_update_all_gpes();
2689 * Although we call __add_memory() that is documented to require the
2690 * device_hotplug_lock, it is not necessary here because this is an
2691 * early code when userspace or any other code path cannot trigger
2692 * hotplug/hotunplug operations.
2694 mutex_lock(&acpi_scan_lock
);
2696 * Enumerate devices in the ACPI namespace.
2698 if (acpi_bus_scan(ACPI_ROOT_OBJECT
))
2701 acpi_root
= acpi_fetch_acpi_dev(ACPI_ROOT_OBJECT
);
2705 /* Fixed feature devices do not exist on HW-reduced platform */
2706 if (!acpi_gbl_reduced_hardware
)
2707 acpi_bus_scan_fixed();
2709 acpi_turn_off_unused_power_resources();
2711 acpi_scan_initialized
= true;
2714 mutex_unlock(&acpi_scan_lock
);
2717 static struct acpi_probe_entry
*ape
;
2718 static int acpi_probe_count
;
2719 static DEFINE_MUTEX(acpi_probe_mutex
);
2721 static int __init
acpi_match_madt(union acpi_subtable_headers
*header
,
2722 const unsigned long end
)
2724 if (!ape
->subtable_valid
|| ape
->subtable_valid(&header
->common
, ape
))
2725 if (!ape
->probe_subtbl(header
, end
))
2731 int __init
__acpi_probe_device_table(struct acpi_probe_entry
*ap_head
, int nr
)
2738 mutex_lock(&acpi_probe_mutex
);
2739 for (ape
= ap_head
; nr
; ape
++, nr
--) {
2740 if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT
, ape
->id
)) {
2741 acpi_probe_count
= 0;
2742 acpi_table_parse_madt(ape
->type
, acpi_match_madt
, 0);
2743 count
+= acpi_probe_count
;
2746 res
= acpi_table_parse(ape
->id
, ape
->probe_table
);
2751 mutex_unlock(&acpi_probe_mutex
);
2756 static void acpi_table_events_fn(struct work_struct
*work
)
2758 acpi_scan_lock_acquire();
2759 acpi_bus_scan(ACPI_ROOT_OBJECT
);
2760 acpi_scan_lock_release();
2765 void acpi_scan_table_notify(void)
2767 struct work_struct
*work
;
2769 if (!acpi_scan_initialized
)
2772 work
= kmalloc(sizeof(*work
), GFP_KERNEL
);
2776 INIT_WORK(work
, acpi_table_events_fn
);
2777 schedule_work(work
);
2780 int acpi_reconfig_notifier_register(struct notifier_block
*nb
)
2782 return blocking_notifier_chain_register(&acpi_reconfig_chain
, nb
);
2784 EXPORT_SYMBOL(acpi_reconfig_notifier_register
);
2786 int acpi_reconfig_notifier_unregister(struct notifier_block
*nb
)
2788 return blocking_notifier_chain_unregister(&acpi_reconfig_chain
, nb
);
2790 EXPORT_SYMBOL(acpi_reconfig_notifier_unregister
);