1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* scan.c - support for transforming the ACPI namespace into individual objects
4	*/
5
6	#define pr_fmt(fmt) "ACPI: " fmt
7
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>
24
25	#include "internal.h"
26	#include "sleep.h"
27
28	#define ACPI_BUS_CLASS "system_bus"
29	#define ACPI_BUS_HID "LNXSYBUS"
30	#define ACPI_BUS_DEVICE_NAME "System Bus"
31
32	#define INVALID_ACPI_HANDLE ((acpi_handle)ZERO_PAGE(0))
33
34	static const char *dummy_hid = "device";
35
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);
44
45	/*
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
48	* table.
49	*/
50	static u64 spcr_uart_addr;
51
52	void acpi_scan_lock_acquire(void)
53	{
54	mutex_lock(&acpi_scan_lock);
55	}
56	EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
57
58	void acpi_scan_lock_release(void)
59	{
60	mutex_unlock(lock: &acpi_scan_lock);
61	}
62	EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
63
64	void acpi_lock_hp_context(void)
65	{
66	mutex_lock(&acpi_hp_context_lock);
67	}
68
69	void acpi_unlock_hp_context(void)
70	{
71	mutex_unlock(lock: &acpi_hp_context_lock);
72	}
73
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))
78	{
79	acpi_lock_hp_context();
80	hp->notify = notify;
81	hp->uevent = uevent;
82	acpi_set_hp_context(adev, hp);
83	acpi_unlock_hp_context();
84	}
85	EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
86
87	int acpi_scan_add_handler(struct acpi_scan_handler *handler)
88	{
89	if (!handler)
90	return -EINVAL;
91
92	list_add_tail(new: &handler->list_node, head: &acpi_scan_handlers_list);
93	return 0;
94	}
95
96	int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
97	const char *hotplug_profile_name)
98	{
99	int error;
100
101	error = acpi_scan_add_handler(handler);
102	if (error)
103	return error;
104
105	acpi_sysfs_add_hotplug_profile(hotplug: &handler->hotplug, name: hotplug_profile_name);
106	return 0;
107	}
108
109	bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
110	{
111	struct acpi_device_physical_node *pn;
112	bool offline = true;
113	char *envp[] = { "EVENT=offline", NULL };
114
115	/*
116	* acpi_container_offline() calls this for all of the container's
117	* children under the container's physical_node_lock lock.
118	*/
119	mutex_lock_nested(lock: &adev->physical_node_lock, SINGLE_DEPTH_NESTING);
120
121	list_for_each_entry(pn, &adev->physical_node_list, node)
122	if (device_supports_offline(dev: pn->dev) && !pn->dev->offline) {
123	if (uevent)
124	kobject_uevent_env(kobj: &pn->dev->kobj, action: KOBJ_CHANGE, envp);
125
126	offline = false;
127	break;
128	}
129
130	mutex_unlock(lock: &adev->physical_node_lock);
131	return offline;
132	}
133
134	static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
135	void **ret_p)
136	{
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;
141
142	if (!device)
143	return AE_OK;
144
145	if (device->handler && !device->handler->hotplug.enabled) {
146	*ret_p = &device->dev;
147	return AE_SUPPORT;
148	}
149
150	mutex_lock(&device->physical_node_lock);
151
152	list_for_each_entry(pn, &device->physical_node_list, node) {
153	int ret;
154
155	if (second_pass) {
156	/* Skip devices offlined by the first pass. */
157	if (pn->put_online)
158	continue;
159	} else {
160	pn->put_online = false;
161	}
162	ret = device_offline(dev: pn->dev);
163	if (ret >= 0) {
164	pn->put_online = !ret;
165	} else {
166	*ret_p = pn->dev;
167	if (second_pass) {
168	status = AE_ERROR;
169	break;
170	}
171	}
172	}
173
174	mutex_unlock(lock: &device->physical_node_lock);
175
176	return status;
177	}
178
179	static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
180	void **ret_p)
181	{
182	struct acpi_device *device = acpi_fetch_acpi_dev(handle);
183	struct acpi_device_physical_node *pn;
184
185	if (!device)
186	return AE_OK;
187
188	mutex_lock(&device->physical_node_lock);
189
190	list_for_each_entry(pn, &device->physical_node_list, node)
191	if (pn->put_online) {
192	device_online(dev: pn->dev);
193	pn->put_online = false;
194	}
195
196	mutex_unlock(lock: &device->physical_node_lock);
197
198	return AE_OK;
199	}
200
201	static int acpi_scan_try_to_offline(struct acpi_device *device)
202	{
203	acpi_handle handle = device->handle;
204	struct device *errdev = NULL;
205	acpi_status status;
206
207	/*
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
212	* block holds them.
213	*
214	* If the first pass is successful, the second one isn't needed, though.
215	*/
216	status = acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle, ACPI_UINT32_MAX,
217	NULL, ascending_callback: acpi_bus_offline, context: (void *)false,
218	return_value: (void **)&errdev);
219	if (status == AE_SUPPORT) {
220	dev_warn(errdev, "Offline disabled.\n");
221	acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle, ACPI_UINT32_MAX,
222	descending_callback: acpi_bus_online, NULL, NULL, NULL);
223	return -EPERM;
224	}
225	acpi_bus_offline(handle, lvl: 0, data: (void *)false, ret_p: (void **)&errdev);
226	if (errdev) {
227	errdev = NULL;
228	acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle, ACPI_UINT32_MAX,
229	NULL, ascending_callback: acpi_bus_offline, context: (void *)true,
230	return_value: (void **)&errdev);
231	if (!errdev)
232	acpi_bus_offline(handle, lvl: 0, data: (void *)true,
233	ret_p: (void **)&errdev);
234
235	if (errdev) {
236	dev_warn(errdev, "Offline failed.\n");
237	acpi_bus_online(handle, lvl: 0, NULL, NULL);
238	acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle,
239	ACPI_UINT32_MAX, descending_callback: acpi_bus_online,
240	NULL, NULL, NULL);
241	return -EBUSY;
242	}
243	}
244	return 0;
245	}
246
247	static int acpi_scan_check_and_detach(struct acpi_device *adev, void *check)
248	{
249	struct acpi_scan_handler *handler = adev->handler;
250
251	acpi_dev_for_each_child_reverse(adev, fn: acpi_scan_check_and_detach, data: check);
252
253	if (check) {
254	acpi_bus_get_status(device: adev);
255	/*
256	* Skip devices that are still there and take the enabled
257	* flag into account.
258	*/
259	if (acpi_device_is_enabled(adev))
260	return 0;
261
262	/* Skip device that have not been enumerated. */
263	if (!acpi_device_enumerated(adev)) {
264	dev_dbg(&adev->dev, "Still not enumerated\n");
265	return 0;
266	}
267	}
268
269	adev->flags.match_driver = false;
270	if (handler) {
271	if (handler->detach)
272	handler->detach(adev);
273
274	adev->handler = NULL;
275	} else {
276	device_release_driver(dev: &adev->dev);
277	}
278	/*
279	* Most likely, the device is going away, so put it into D3cold before
280	* that.
281	*/
282	acpi_device_set_power(device: adev, ACPI_STATE_D3_COLD);
283	adev->flags.initialized = false;
284	acpi_device_clear_enumerated(adev);
285
286	return 0;
287	}
288
289	static void acpi_scan_check_subtree(struct acpi_device *adev)
290	{
291	acpi_scan_check_and_detach(adev, check: (void *)true);
292	}
293
294	static int acpi_scan_hot_remove(struct acpi_device *device)
295	{
296	acpi_handle handle = device->handle;
297	unsigned long long sta;
298	acpi_status status;
299
300	if (device->handler && device->handler->hotplug.demand_offline) {
301	if (!acpi_scan_is_offline(adev: device, uevent: true))
302	return -EBUSY;
303	} else {
304	int error = acpi_scan_try_to_offline(device);
305	if (error)
306	return error;
307	}
308
309	acpi_handle_debug(handle, "Ejecting\n");
310
311	acpi_bus_trim(start: device);
312
313	acpi_evaluate_lck(handle, lock: 0);
314	/*
315	* TBD: _EJD support.
316	*/
317	status = acpi_evaluate_ej0(handle);
318	if (status == AE_NOT_FOUND)
319	return -ENODEV;
320	else if (ACPI_FAILURE(status))
321	return -EIO;
322
323	/*
324	* Verify if eject was indeed successful. If not, log an error
325	* message. No need to call _OST since _EJ0 call was made OK.
326	*/
327	status = acpi_evaluate_integer(handle, pathname: "_STA", NULL, data: &sta);
328	if (ACPI_FAILURE(status)) {
329	acpi_handle_warn(handle,
330	"Status check after eject failed (0x%x)\n", status);
331	} else if (sta & ACPI_STA_DEVICE_ENABLED) {
332	acpi_handle_warn(handle,
333	"Eject incomplete - status 0x%llx\n", sta);
334	}
335
336	return 0;
337	}
338
339	static int acpi_scan_rescan_bus(struct acpi_device *adev)
340	{
341	struct acpi_scan_handler *handler = adev->handler;
342	int ret;
343
344	if (handler && handler->hotplug.scan_dependent)
345	ret = handler->hotplug.scan_dependent(adev);
346	else
347	ret = acpi_bus_scan(handle: adev->handle);
348
349	if (ret)
350	dev_info(&adev->dev, "Namespace scan failure\n");
351
352	return ret;
353	}
354
355	static int acpi_scan_device_check(struct acpi_device *adev)
356	{
357	struct acpi_device *parent;
358
359	acpi_scan_check_subtree(adev);
360
361	if (!acpi_device_is_present(adev))
362	return 0;
363
364	/*
365	* This function is only called for device objects for which matching
366	* scan handlers exist. The only situation in which the scan handler
367	* is not attached to this device object yet is when the device has
368	* just appeared (either it wasn't present at all before or it was
369	* removed and then added again).
370	*/
371	if (adev->handler) {
372	dev_dbg(&adev->dev, "Already enumerated\n");
373	return 0;
374	}
375
376	parent = acpi_dev_parent(adev);
377	if (!parent)
378	parent = adev;
379
380	return acpi_scan_rescan_bus(adev: parent);
381	}
382
383	static int acpi_scan_bus_check(struct acpi_device *adev)
384	{
385	acpi_scan_check_subtree(adev);
386
387	return acpi_scan_rescan_bus(adev);
388	}
389
390	static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
391	{
392	switch (type) {
393	case ACPI_NOTIFY_BUS_CHECK:
394	return acpi_scan_bus_check(adev);
395	case ACPI_NOTIFY_DEVICE_CHECK:
396	return acpi_scan_device_check(adev);
397	case ACPI_NOTIFY_EJECT_REQUEST:
398	case ACPI_OST_EC_OSPM_EJECT:
399	if (adev->handler && !adev->handler->hotplug.enabled) {
400	dev_info(&adev->dev, "Eject disabled\n");
401	return -EPERM;
402	}
403	acpi_evaluate_ost(handle: adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
404	ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
405	return acpi_scan_hot_remove(device: adev);
406	}
407	return -EINVAL;
408	}
409
410	void acpi_device_hotplug(struct acpi_device *adev, u32 src)
411	{
412	u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
413	int error = -ENODEV;
414
415	lock_device_hotplug();
416	mutex_lock(&acpi_scan_lock);
417
418	/*
419	* The device object's ACPI handle cannot become invalid as long as we
420	* are holding acpi_scan_lock, but it might have become invalid before
421	* that lock was acquired.
422	*/
423	if (adev->handle == INVALID_ACPI_HANDLE)
424	goto err_out;
425
426	if (adev->flags.is_dock_station) {
427	error = dock_notify(adev, event: src);
428	} else if (adev->flags.hotplug_notify) {
429	error = acpi_generic_hotplug_event(adev, type: src);
430	} else {
431	int (*notify)(struct acpi_device *, u32);
432
433	acpi_lock_hp_context();
434	notify = adev->hp ? adev->hp->notify : NULL;
435	acpi_unlock_hp_context();
436	/*
437	* There may be additional notify handlers for device objects
438	* without the .event() callback, so ignore them here.
439	*/
440	if (notify)
441	error = notify(adev, src);
442	else
443	goto out;
444	}
445	switch (error) {
446	case 0:
447	ost_code = ACPI_OST_SC_SUCCESS;
448	break;
449	case -EPERM:
450	ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
451	break;
452	case -EBUSY:
453	ost_code = ACPI_OST_SC_DEVICE_BUSY;
454	break;
455	default:
456	ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
457	break;
458	}
459
460	err_out:
461	acpi_evaluate_ost(handle: adev->handle, source_event: src, status_code: ost_code, NULL);
462
463	out:
464	acpi_put_acpi_dev(adev);
465	mutex_unlock(lock: &acpi_scan_lock);
466	unlock_device_hotplug();
467	}
468
469	static void acpi_free_power_resources_lists(struct acpi_device *device)
470	{
471	int i;
472
473	if (device->wakeup.flags.valid)
474	acpi_power_resources_list_free(list: &device->wakeup.resources);
475
476	if (!device->power.flags.power_resources)
477	return;
478
479	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
480	struct acpi_device_power_state *ps = &device->power.states[i];
481	acpi_power_resources_list_free(list: &ps->resources);
482	}
483	}
484
485	static void acpi_device_release(struct device *dev)
486	{
487	struct acpi_device *acpi_dev = to_acpi_device(dev);
488
489	acpi_free_properties(adev: acpi_dev);
490	acpi_free_pnp_ids(pnp: &acpi_dev->pnp);
491	acpi_free_power_resources_lists(device: acpi_dev);
492	kfree(objp: acpi_dev);
493	}
494
495	static void acpi_device_del(struct acpi_device *device)
496	{
497	struct acpi_device_bus_id *acpi_device_bus_id;
498
499	mutex_lock(&acpi_device_lock);
500
501	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
502	if (!strcmp(acpi_device_bus_id->bus_id,
503	acpi_device_hid(device))) {
504	ida_free(&acpi_device_bus_id->instance_ida,
505	id: device->pnp.instance_no);
506	if (ida_is_empty(ida: &acpi_device_bus_id->instance_ida)) {
507	list_del(entry: &acpi_device_bus_id->node);
508	kfree_const(x: acpi_device_bus_id->bus_id);
509	kfree(objp: acpi_device_bus_id);
510	}
511	break;
512	}
513
514	list_del(entry: &device->wakeup_list);
515
516	mutex_unlock(lock: &acpi_device_lock);
517
518	acpi_power_add_remove_device(adev: device, add: false);
519	acpi_device_remove_files(dev: device);
520	if (device->remove)
521	device->remove(device);
522
523	device_del(dev: &device->dev);
524	}
525
526	static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
527
528	static LIST_HEAD(acpi_device_del_list);
529	static DEFINE_MUTEX(acpi_device_del_lock);
530
531	static void acpi_device_del_work_fn(struct work_struct *work_not_used)
532	{
533	for (;;) {
534	struct acpi_device *adev;
535
536	mutex_lock(&acpi_device_del_lock);
537
538	if (list_empty(head: &acpi_device_del_list)) {
539	mutex_unlock(lock: &acpi_device_del_lock);
540	break;
541	}
542	adev = list_first_entry(&acpi_device_del_list,
543	struct acpi_device, del_list);
544	list_del(entry: &adev->del_list);
545
546	mutex_unlock(lock: &acpi_device_del_lock);
547
548	blocking_notifier_call_chain(nh: &acpi_reconfig_chain,
549	val: ACPI_RECONFIG_DEVICE_REMOVE, v: adev);
550
551	acpi_device_del(device: adev);
552	/*
553	* Drop references to all power resources that might have been
554	* used by the device.
555	*/
556	acpi_power_transition(device: adev, ACPI_STATE_D3_COLD);
557	acpi_dev_put(adev);
558	}
559	}
560
561	/**
562	* acpi_scan_drop_device - Drop an ACPI device object.
563	* @handle: Handle of an ACPI namespace node, not used.
564	* @context: Address of the ACPI device object to drop.
565	*
566	* This is invoked by acpi_ns_delete_node() during the removal of the ACPI
567	* namespace node the device object pointed to by @context is attached to.
568	*
569	* The unregistration is carried out asynchronously to avoid running
570	* acpi_device_del() under the ACPICA's namespace mutex and the list is used to
571	* ensure the correct ordering (the device objects must be unregistered in the
572	* same order in which the corresponding namespace nodes are deleted).
573	*/
574	static void acpi_scan_drop_device(acpi_handle handle, void *context)
575	{
576	static DECLARE_WORK(work, acpi_device_del_work_fn);
577	struct acpi_device *adev = context;
578
579	mutex_lock(&acpi_device_del_lock);
580
581	/*
582	* Use the ACPI hotplug workqueue which is ordered, so this work item
583	* won't run after any hotplug work items submitted subsequently. That
584	* prevents attempts to register device objects identical to those being
585	* deleted from happening concurrently (such attempts result from
586	* hotplug events handled via the ACPI hotplug workqueue). It also will
587	* run after all of the work items submitted previously, which helps
588	* those work items to ensure that they are not accessing stale device
589	* objects.
590	*/
591	if (list_empty(head: &acpi_device_del_list))
592	acpi_queue_hotplug_work(work: &work);
593
594	list_add_tail(new: &adev->del_list, head: &acpi_device_del_list);
595	/* Make acpi_ns_validate_handle() return NULL for this handle. */
596	adev->handle = INVALID_ACPI_HANDLE;
597
598	mutex_unlock(lock: &acpi_device_del_lock);
599	}
600
601	static struct acpi_device *handle_to_device(acpi_handle handle,
602	void (*callback)(void *))
603	{
604	struct acpi_device *adev = NULL;
605	acpi_status status;
606
607	status = acpi_get_data_full(object: handle, handler: acpi_scan_drop_device,
608	data: (void **)&adev, callback);
609	if (ACPI_FAILURE(status) || !adev) {
610	acpi_handle_debug(handle, "No context!\n");
611	return NULL;
612	}
613	return adev;
614	}
615
616	/**
617	* acpi_fetch_acpi_dev - Retrieve ACPI device object.
618	* @handle: ACPI handle associated with the requested ACPI device object.
619	*
620	* Return a pointer to the ACPI device object associated with @handle, if
621	* present, or NULL otherwise.
622	*/
623	struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle)
624	{
625	return handle_to_device(handle, NULL);
626	}
627	EXPORT_SYMBOL_GPL(acpi_fetch_acpi_dev);
628
629	static void get_acpi_device(void *dev)
630	{
631	acpi_dev_get(adev: dev);
632	}
633
634	/**
635	* acpi_get_acpi_dev - Retrieve ACPI device object and reference count it.
636	* @handle: ACPI handle associated with the requested ACPI device object.
637	*
638	* Return a pointer to the ACPI device object associated with @handle and bump
639	* up that object's reference counter (under the ACPI Namespace lock), if
640	* present, or return NULL otherwise.
641	*
642	* The ACPI device object reference acquired by this function needs to be
643	* dropped via acpi_dev_put().
644	*/
645	struct acpi_device *acpi_get_acpi_dev(acpi_handle handle)
646	{
647	return handle_to_device(handle, callback: get_acpi_device);
648	}
649	EXPORT_SYMBOL_GPL(acpi_get_acpi_dev);
650
651	static struct acpi_device_bus_id *acpi_device_bus_id_match(const char *dev_id)
652	{
653	struct acpi_device_bus_id *acpi_device_bus_id;
654
655	/* Find suitable bus_id and instance number in acpi_bus_id_list. */
656	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
657	if (!strcmp(acpi_device_bus_id->bus_id, dev_id))
658	return acpi_device_bus_id;
659	}
660	return NULL;
661	}
662
663	static int acpi_device_set_name(struct acpi_device *device,
664	struct acpi_device_bus_id *acpi_device_bus_id)
665	{
666	struct ida *instance_ida = &acpi_device_bus_id->instance_ida;
667	int result;
668
669	result = ida_alloc(ida: instance_ida, GFP_KERNEL);
670	if (result < 0)
671	return result;
672
673	device->pnp.instance_no = result;
674	dev_set_name(dev: &device->dev, name: "%s:%02x", acpi_device_bus_id->bus_id, result);
675	return 0;
676	}
677
678	int acpi_tie_acpi_dev(struct acpi_device *adev)
679	{
680	acpi_handle handle = adev->handle;
681	acpi_status status;
682
683	if (!handle)
684	return 0;
685
686	status = acpi_attach_data(object: handle, handler: acpi_scan_drop_device, data: adev);
687	if (ACPI_FAILURE(status)) {
688	acpi_handle_err(handle, "Unable to attach device data\n");
689	return -ENODEV;
690	}
691
692	return 0;
693	}
694
695	static void acpi_store_pld_crc(struct acpi_device *adev)
696	{
697	struct acpi_pld_info *pld;
698	acpi_status status;
699
700	status = acpi_get_physical_device_location(handle: adev->handle, pld: &pld);
701	if (ACPI_FAILURE(status))
702	return;
703
704	adev->pld_crc = crc32(~0, pld, sizeof(*pld));
705	ACPI_FREE(pld);
706	}
707
708	int acpi_device_add(struct acpi_device *device)
709	{
710	struct acpi_device_bus_id *acpi_device_bus_id;
711	int result;
712
713	/*
714	* Linkage
715	* -------
716	* Link this device to its parent and siblings.
717	*/
718	INIT_LIST_HEAD(list: &device->wakeup_list);
719	INIT_LIST_HEAD(list: &device->physical_node_list);
720	INIT_LIST_HEAD(list: &device->del_list);
721	mutex_init(&device->physical_node_lock);
722
723	mutex_lock(&acpi_device_lock);
724
725	acpi_device_bus_id = acpi_device_bus_id_match(dev_id: acpi_device_hid(device));
726	if (acpi_device_bus_id) {
727	result = acpi_device_set_name(device, acpi_device_bus_id);
728	if (result)
729	goto err_unlock;
730	} else {
731	acpi_device_bus_id = kzalloc(size: sizeof(*acpi_device_bus_id),
732	GFP_KERNEL);
733	if (!acpi_device_bus_id) {
734	result = -ENOMEM;
735	goto err_unlock;
736	}
737	acpi_device_bus_id->bus_id =
738	kstrdup_const(s: acpi_device_hid(device), GFP_KERNEL);
739	if (!acpi_device_bus_id->bus_id) {
740	kfree(objp: acpi_device_bus_id);
741	result = -ENOMEM;
742	goto err_unlock;
743	}
744
745	ida_init(ida: &acpi_device_bus_id->instance_ida);
746
747	result = acpi_device_set_name(device, acpi_device_bus_id);
748	if (result) {
749	kfree_const(x: acpi_device_bus_id->bus_id);
750	kfree(objp: acpi_device_bus_id);
751	goto err_unlock;
752	}
753
754	list_add_tail(new: &acpi_device_bus_id->node, head: &acpi_bus_id_list);
755	}
756
757	if (device->wakeup.flags.valid)
758	list_add_tail(new: &device->wakeup_list, head: &acpi_wakeup_device_list);
759
760	acpi_store_pld_crc(adev: device);
761
762	mutex_unlock(lock: &acpi_device_lock);
763
764	result = device_add(dev: &device->dev);
765	if (result) {
766	dev_err(&device->dev, "Error registering device\n");
767	goto err;
768	}
769
770	result = acpi_device_setup_files(dev: device);
771	if (result)
772	pr_err("Error creating sysfs interface for device %s\n",
773	dev_name(&device->dev));
774
775	return 0;
776
777	err:
778	mutex_lock(&acpi_device_lock);
779
780	list_del(entry: &device->wakeup_list);
781
782	err_unlock:
783	mutex_unlock(lock: &acpi_device_lock);
784
785	acpi_detach_data(object: device->handle, handler: acpi_scan_drop_device);
786
787	return result;
788	}
789
790	/* --------------------------------------------------------------------------
791	Device Enumeration
792	-------------------------------------------------------------------------- */
793	static bool acpi_info_matches_ids(struct acpi_device_info *info,
794	const char * const ids[])
795	{
796	struct acpi_pnp_device_id_list *cid_list = NULL;
797	int i, index;
798
799	if (!(info->valid & ACPI_VALID_HID))
800	return false;
801
802	index = match_string(array: ids, n: -1, string: info->hardware_id.string);
803	if (index >= 0)
804	return true;
805
806	if (info->valid & ACPI_VALID_CID)
807	cid_list = &info->compatible_id_list;
808
809	if (!cid_list)
810	return false;
811
812	for (i = 0; i < cid_list->count; i++) {
813	index = match_string(array: ids, n: -1, string: cid_list->ids[i].string);
814	if (index >= 0)
815	return true;
816	}
817
818	return false;
819	}
820
821	/* List of HIDs for which we ignore matching ACPI devices, when checking _DEP lists. */
822	static const char * const acpi_ignore_dep_ids[] = {
823	"PNP0D80", /* Windows-compatible System Power Management Controller */
824	"INT33BD", /* Intel Baytrail Mailbox Device */
825	"LATT2021", /* Lattice FW Update Client Driver */
826	NULL
827	};
828
829	/* List of HIDs for which we honor deps of matching ACPI devs, when checking _DEP lists. */
830	static const char * const acpi_honor_dep_ids[] = {
831	"INT3472", /* Camera sensor PMIC / clk and regulator info */
832	"INTC1059", /* IVSC (TGL) driver must be loaded to allow i2c access to camera sensors */
833	"INTC1095", /* IVSC (ADL) driver must be loaded to allow i2c access to camera sensors */
834	"INTC100A", /* IVSC (RPL) driver must be loaded to allow i2c access to camera sensors */
835	"INTC10CF", /* IVSC (MTL) driver must be loaded to allow i2c access to camera sensors */
836	NULL
837	};
838
839	static struct acpi_device *acpi_find_parent_acpi_dev(acpi_handle handle)
840	{
841	struct acpi_device *adev;
842
843	/*
844	* Fixed hardware devices do not appear in the namespace and do not
845	* have handles, but we fabricate acpi_devices for them, so we have
846	* to deal with them specially.
847	*/
848	if (!handle)
849	return acpi_root;
850
851	do {
852	acpi_status status;
853
854	status = acpi_get_parent(object: handle, out_handle: &handle);
855	if (ACPI_FAILURE(status)) {
856	if (status != AE_NULL_ENTRY)
857	return acpi_root;
858
859	return NULL;
860	}
861	adev = acpi_fetch_acpi_dev(handle);
862	} while (!adev);
863	return adev;
864	}
865
866	acpi_status
867	acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
868	{
869	acpi_status status;
870	acpi_handle tmp;
871	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
872	union acpi_object *obj;
873
874	status = acpi_get_handle(parent: handle, pathname: "_EJD", ret_handle: &tmp);
875	if (ACPI_FAILURE(status))
876	return status;
877
878	status = acpi_evaluate_object(object: handle, pathname: "_EJD", NULL, return_object_buffer: &buffer);
879	if (ACPI_SUCCESS(status)) {
880	obj = buffer.pointer;
881	status = acpi_get_handle(ACPI_ROOT_OBJECT, pathname: obj->string.pointer,
882	ret_handle: ejd);
883	kfree(objp: buffer.pointer);
884	}
885	return status;
886	}
887	EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
888
889	static int acpi_bus_extract_wakeup_device_power_package(struct acpi_device *dev)
890	{
891	acpi_handle handle = dev->handle;
892	struct acpi_device_wakeup *wakeup = &dev->wakeup;
893	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
894	union acpi_object *package = NULL;
895	union acpi_object *element = NULL;
896	acpi_status status;
897	int err = -ENODATA;
898
899	INIT_LIST_HEAD(list: &wakeup->resources);
900
901	/* _PRW */
902	status = acpi_evaluate_object(object: handle, pathname: "_PRW", NULL, return_object_buffer: &buffer);
903	if (ACPI_FAILURE(status)) {
904	acpi_handle_info(handle, "_PRW evaluation failed: %s\n",
905	acpi_format_exception(status));
906	return err;
907	}
908
909	package = (union acpi_object *)buffer.pointer;
910
911	if (!package || package->package.count < 2)
912	goto out;
913
914	element = &(package->package.elements[0]);
915	if (!element)
916	goto out;
917
918	if (element->type == ACPI_TYPE_PACKAGE) {
919	if ((element->package.count < 2) ||
920	(element->package.elements[0].type !=
921	ACPI_TYPE_LOCAL_REFERENCE)
922	|| (element->package.elements[1].type != ACPI_TYPE_INTEGER))
923	goto out;
924
925	wakeup->gpe_device =
926	element->package.elements[0].reference.handle;
927	wakeup->gpe_number =
928	(u32) element->package.elements[1].integer.value;
929	} else if (element->type == ACPI_TYPE_INTEGER) {
930	wakeup->gpe_device = NULL;
931	wakeup->gpe_number = element->integer.value;
932	} else {
933	goto out;
934	}
935
936	element = &(package->package.elements[1]);
937	if (element->type != ACPI_TYPE_INTEGER)
938	goto out;
939
940	wakeup->sleep_state = element->integer.value;
941
942	err = acpi_extract_power_resources(package, start: 2, list: &wakeup->resources);
943	if (err)
944	goto out;
945
946	if (!list_empty(head: &wakeup->resources)) {
947	int sleep_state;
948
949	err = acpi_power_wakeup_list_init(list: &wakeup->resources,
950	system_level: &sleep_state);
951	if (err) {
952	acpi_handle_warn(handle, "Retrieving current states "
953	"of wakeup power resources failed\n");
954	acpi_power_resources_list_free(list: &wakeup->resources);
955	goto out;
956	}
957	if (sleep_state < wakeup->sleep_state) {
958	acpi_handle_warn(handle, "Overriding _PRW sleep state "
959	"(S%d) by S%d from power resources\n",
960	(int)wakeup->sleep_state, sleep_state);
961	wakeup->sleep_state = sleep_state;
962	}
963	}
964
965	out:
966	kfree(objp: buffer.pointer);
967	return err;
968	}
969
970	/* Do not use a button for S5 wakeup */
971	#define ACPI_AVOID_WAKE_FROM_S5 BIT(0)
972
973	static bool acpi_wakeup_gpe_init(struct acpi_device *device)
974	{
975	static const struct acpi_device_id button_device_ids[] = {
976	{"PNP0C0C", 0}, /* Power button */
977	{"PNP0C0D", ACPI_AVOID_WAKE_FROM_S5}, /* Lid */
978	{"PNP0C0E", ACPI_AVOID_WAKE_FROM_S5}, /* Sleep button */
979	{"", 0},
980	};
981	struct acpi_device_wakeup *wakeup = &device->wakeup;
982	const struct acpi_device_id *match;
983	acpi_status status;
984
985	wakeup->flags.notifier_present = 0;
986
987	/* Power button, Lid switch always enable wakeup */
988	match = acpi_match_acpi_device(ids: button_device_ids, adev: device);
989	if (match) {
990	if ((match->driver_data & ACPI_AVOID_WAKE_FROM_S5) &&
991	wakeup->sleep_state == ACPI_STATE_S5)
992	wakeup->sleep_state = ACPI_STATE_S4;
993	acpi_mark_gpe_for_wake(gpe_device: wakeup->gpe_device, gpe_number: wakeup->gpe_number);
994	device_set_wakeup_capable(dev: &device->dev, capable: true);
995	return true;
996	}
997
998	status = acpi_setup_gpe_for_wake(parent_device: device->handle, gpe_device: wakeup->gpe_device,
999	gpe_number: wakeup->gpe_number);
1000	return ACPI_SUCCESS(status);
1001	}
1002
1003	static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
1004	{
1005	int err;
1006
1007	/* Presence of _PRW indicates wake capable */
1008	if (!acpi_has_method(handle: device->handle, name: "_PRW"))
1009	return;
1010
1011	err = acpi_bus_extract_wakeup_device_power_package(dev: device);
1012	if (err) {
1013	dev_err(&device->dev, "Unable to extract wakeup power resources");
1014	return;
1015	}
1016
1017	device->wakeup.flags.valid = acpi_wakeup_gpe_init(device);
1018	device->wakeup.prepare_count = 0;
1019	/*
1020	* Call _PSW/_DSW object to disable its ability to wake the sleeping
1021	* system for the ACPI device with the _PRW object.
1022	* The _PSW object is deprecated in ACPI 3.0 and is replaced by _DSW.
1023	* So it is necessary to call _DSW object first. Only when it is not
1024	* present will the _PSW object used.
1025	*/
1026	err = acpi_device_sleep_wake(dev: device, enable: 0, sleep_state: 0, dev_state: 0);
1027	if (err)
1028	pr_debug("error in _DSW or _PSW evaluation\n");
1029	}
1030
1031	static void acpi_bus_init_power_state(struct acpi_device *device, int state)
1032	{
1033	struct acpi_device_power_state *ps = &device->power.states[state];
1034	char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
1035	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1036	acpi_status status;
1037
1038	INIT_LIST_HEAD(list: &ps->resources);
1039
1040	/* Evaluate "_PRx" to get referenced power resources */
1041	status = acpi_evaluate_object(object: device->handle, pathname, NULL, return_object_buffer: &buffer);
1042	if (ACPI_SUCCESS(status)) {
1043	union acpi_object *package = buffer.pointer;
1044
1045	if (buffer.length && package
1046	&& package->type == ACPI_TYPE_PACKAGE
1047	&& package->package.count)
1048	acpi_extract_power_resources(package, start: 0, list: &ps->resources);
1049
1050	ACPI_FREE(buffer.pointer);
1051	}
1052
1053	/* Evaluate "_PSx" to see if we can do explicit sets */
1054	pathname[2] = 'S';
1055	if (acpi_has_method(handle: device->handle, name: pathname))
1056	ps->flags.explicit_set = 1;
1057
1058	/* State is valid if there are means to put the device into it. */
1059	if (!list_empty(head: &ps->resources) || ps->flags.explicit_set)
1060	ps->flags.valid = 1;
1061
1062	ps->power = -1; /* Unknown - driver assigned */
1063	ps->latency = -1; /* Unknown - driver assigned */
1064	}
1065
1066	static void acpi_bus_get_power_flags(struct acpi_device *device)
1067	{
1068	unsigned long long dsc = ACPI_STATE_D0;
1069	u32 i;
1070
1071	/* Presence of _PS0|_PR0 indicates 'power manageable' */
1072	if (!acpi_has_method(handle: device->handle, name: "_PS0") &&
1073	!acpi_has_method(handle: device->handle, name: "_PR0"))
1074	return;
1075
1076	device->flags.power_manageable = 1;
1077
1078	/*
1079	* Power Management Flags
1080	*/
1081	if (acpi_has_method(handle: device->handle, name: "_PSC"))
1082	device->power.flags.explicit_get = 1;
1083
1084	if (acpi_has_method(handle: device->handle, name: "_IRC"))
1085	device->power.flags.inrush_current = 1;
1086
1087	if (acpi_has_method(handle: device->handle, name: "_DSW"))
1088	device->power.flags.dsw_present = 1;
1089
1090	acpi_evaluate_integer(handle: device->handle, pathname: "_DSC", NULL, data: &dsc);
1091	device->power.state_for_enumeration = dsc;
1092
1093	/*
1094	* Enumerate supported power management states
1095	*/
1096	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
1097	acpi_bus_init_power_state(device, state: i);
1098
1099	INIT_LIST_HEAD(list: &device->power.states[ACPI_STATE_D3_COLD].resources);
1100
1101	/* Set the defaults for D0 and D3hot (always supported). */
1102	device->power.states[ACPI_STATE_D0].flags.valid = 1;
1103	device->power.states[ACPI_STATE_D0].power = 100;
1104	device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1;
1105
1106	/*
1107	* Use power resources only if the D0 list of them is populated, because
1108	* some platforms may provide _PR3 only to indicate D3cold support and
1109	* in those cases the power resources list returned by it may be bogus.
1110	*/
1111	if (!list_empty(head: &device->power.states[ACPI_STATE_D0].resources)) {
1112	device->power.flags.power_resources = 1;
1113	/*
1114	* D3cold is supported if the D3hot list of power resources is
1115	* not empty.
1116	*/
1117	if (!list_empty(head: &device->power.states[ACPI_STATE_D3_HOT].resources))
1118	device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
1119	}
1120
1121	if (acpi_bus_init_power(device))
1122	device->flags.power_manageable = 0;
1123	}
1124
1125	static void acpi_bus_get_flags(struct acpi_device *device)
1126	{
1127	/* Presence of _STA indicates 'dynamic_status' */
1128	if (acpi_has_method(handle: device->handle, name: "_STA"))
1129	device->flags.dynamic_status = 1;
1130
1131	/* Presence of _RMV indicates 'removable' */
1132	if (acpi_has_method(handle: device->handle, name: "_RMV"))
1133	device->flags.removable = 1;
1134
1135	/* Presence of _EJD|_EJ0 indicates 'ejectable' */
1136	if (acpi_has_method(handle: device->handle, name: "_EJD") ||
1137	acpi_has_method(handle: device->handle, name: "_EJ0"))
1138	device->flags.ejectable = 1;
1139	}
1140
1141	static void acpi_device_get_busid(struct acpi_device *device)
1142	{
1143	char bus_id[5] = { '?', 0 };
1144	struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1145	int i = 0;
1146
1147	/*
1148	* Bus ID
1149	* ------
1150	* The device's Bus ID is simply the object name.
1151	* TBD: Shouldn't this value be unique (within the ACPI namespace)?
1152	*/
1153	if (!acpi_dev_parent(adev: device)) {
1154	strcpy(p: device->pnp.bus_id, q: "ACPI");
1155	return;
1156	}
1157
1158	switch (device->device_type) {
1159	case ACPI_BUS_TYPE_POWER_BUTTON:
1160	strcpy(p: device->pnp.bus_id, q: "PWRF");
1161	break;
1162	case ACPI_BUS_TYPE_SLEEP_BUTTON:
1163	strcpy(p: device->pnp.bus_id, q: "SLPF");
1164	break;
1165	case ACPI_BUS_TYPE_ECDT_EC:
1166	strcpy(p: device->pnp.bus_id, q: "ECDT");
1167	break;
1168	default:
1169	acpi_get_name(object: device->handle, ACPI_SINGLE_NAME, ret_path_ptr: &buffer);
1170	/* Clean up trailing underscores (if any) */
1171	for (i = 3; i > 1; i--) {
1172	if (bus_id[i] == '_')
1173	bus_id[i] = '\0';
1174	else
1175	break;
1176	}
1177	strcpy(p: device->pnp.bus_id, q: bus_id);
1178	break;
1179	}
1180	}
1181
1182	/*
1183	* acpi_ata_match - see if an acpi object is an ATA device
1184	*
1185	* If an acpi object has one of the ACPI ATA methods defined,
1186	* then we can safely call it an ATA device.
1187	*/
1188	bool acpi_ata_match(acpi_handle handle)
1189	{
1190	return acpi_has_method(handle, name: "_GTF") ||
1191	acpi_has_method(handle, name: "_GTM") ||
1192	acpi_has_method(handle, name: "_STM") ||
1193	acpi_has_method(handle, name: "_SDD");
1194	}
1195
1196	/*
1197	* acpi_bay_match - see if an acpi object is an ejectable driver bay
1198	*
1199	* If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1200	* then we can safely call it an ejectable drive bay
1201	*/
1202	bool acpi_bay_match(acpi_handle handle)
1203	{
1204	acpi_handle phandle;
1205
1206	if (!acpi_has_method(handle, name: "_EJ0"))
1207	return false;
1208	if (acpi_ata_match(handle))
1209	return true;
1210	if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1211	return false;
1212
1213	return acpi_ata_match(handle: phandle);
1214	}
1215
1216	bool acpi_device_is_battery(struct acpi_device *adev)
1217	{
1218	struct acpi_hardware_id *hwid;
1219
1220	list_for_each_entry(hwid, &adev->pnp.ids, list)
1221	if (!strcmp("PNP0C0A", hwid->id))
1222	return true;
1223
1224	return false;
1225	}
1226
1227	static bool is_ejectable_bay(struct acpi_device *adev)
1228	{
1229	acpi_handle handle = adev->handle;
1230
1231	if (acpi_has_method(handle, name: "_EJ0") && acpi_device_is_battery(adev))
1232	return true;
1233
1234	return acpi_bay_match(handle);
1235	}
1236
1237	/*
1238	* acpi_dock_match - see if an acpi object has a _DCK method
1239	*/
1240	bool acpi_dock_match(acpi_handle handle)
1241	{
1242	return acpi_has_method(handle, name: "_DCK");
1243	}
1244
1245	static acpi_status
1246	acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
1247	void **return_value)
1248	{
1249	long *cap = context;
1250
1251	if (acpi_has_method(handle, name: "_BCM") &&
1252	acpi_has_method(handle, name: "_BCL")) {
1253	acpi_handle_debug(handle, "Found generic backlight support\n");
1254	*cap |= ACPI_VIDEO_BACKLIGHT;
1255	/* We have backlight support, no need to scan further */
1256	return AE_CTRL_TERMINATE;
1257	}
1258	return 0;
1259	}
1260
1261	/* Returns true if the ACPI object is a video device which can be
1262	* handled by video.ko.
1263	* The device will get a Linux specific CID added in scan.c to
1264	* identify the device as an ACPI graphics device
1265	* Be aware that the graphics device may not be physically present
1266	* Use acpi_video_get_capabilities() to detect general ACPI video
1267	* capabilities of present cards
1268	*/
1269	long acpi_is_video_device(acpi_handle handle)
1270	{
1271	long video_caps = 0;
1272
1273	/* Is this device able to support video switching ? */
1274	if (acpi_has_method(handle, name: "_DOD") || acpi_has_method(handle, name: "_DOS"))
1275	video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
1276
1277	/* Is this device able to retrieve a video ROM ? */
1278	if (acpi_has_method(handle, name: "_ROM"))
1279	video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
1280
1281	/* Is this device able to configure which video head to be POSTed ? */
1282	if (acpi_has_method(handle, name: "_VPO") &&
1283	acpi_has_method(handle, name: "_GPD") &&
1284	acpi_has_method(handle, name: "_SPD"))
1285	video_caps |= ACPI_VIDEO_DEVICE_POSTING;
1286
1287	/* Only check for backlight functionality if one of the above hit. */
1288	if (video_caps)
1289	acpi_walk_namespace(ACPI_TYPE_DEVICE, start_object: handle,
1290	ACPI_UINT32_MAX, descending_callback: acpi_backlight_cap_match, NULL,
1291	context: &video_caps, NULL);
1292
1293	return video_caps;
1294	}
1295	EXPORT_SYMBOL(acpi_is_video_device);
1296
1297	const char *acpi_device_hid(struct acpi_device *device)
1298	{
1299	struct acpi_hardware_id *hid;
1300
1301	if (list_empty(head: &device->pnp.ids))
1302	return dummy_hid;
1303
1304	hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1305	return hid->id;
1306	}
1307	EXPORT_SYMBOL(acpi_device_hid);
1308
1309	static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1310	{
1311	struct acpi_hardware_id *id;
1312
1313	id = kmalloc(size: sizeof(*id), GFP_KERNEL);
1314	if (!id)
1315	return;
1316
1317	id->id = kstrdup_const(s: dev_id, GFP_KERNEL);
1318	if (!id->id) {
1319	kfree(objp: id);
1320	return;
1321	}
1322
1323	list_add_tail(new: &id->list, head: &pnp->ids);
1324	pnp->type.hardware_id = 1;
1325	}
1326
1327	/*
1328	* Old IBM workstations have a DSDT bug wherein the SMBus object
1329	* lacks the SMBUS01 HID and the methods do not have the necessary "_"
1330	* prefix. Work around this.
1331	*/
1332	static bool acpi_ibm_smbus_match(acpi_handle handle)
1333	{
1334	char node_name[ACPI_PATH_SEGMENT_LENGTH];
1335	struct acpi_buffer path = { sizeof(node_name), node_name };
1336
1337	if (!dmi_name_in_vendors(str: "IBM"))
1338	return false;
1339
1340	/* Look for SMBS object */
1341	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1342	strcmp("SMBS", path.pointer))
1343	return false;
1344
1345	/* Does it have the necessary (but misnamed) methods? */
1346	if (acpi_has_method(handle, name: "SBI") &&
1347	acpi_has_method(handle, name: "SBR") &&
1348	acpi_has_method(handle, name: "SBW"))
1349	return true;
1350
1351	return false;
1352	}
1353
1354	static bool acpi_object_is_system_bus(acpi_handle handle)
1355	{
1356	acpi_handle tmp;
1357
1358	if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
1359	tmp == handle)
1360	return true;
1361	if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
1362	tmp == handle)
1363	return true;
1364
1365	return false;
1366	}
1367
1368	static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1369	int device_type)
1370	{
1371	struct acpi_device_info *info = NULL;
1372	struct acpi_pnp_device_id_list *cid_list;
1373	int i;
1374
1375	switch (device_type) {
1376	case ACPI_BUS_TYPE_DEVICE:
1377	if (handle == ACPI_ROOT_OBJECT) {
1378	acpi_add_id(pnp, ACPI_SYSTEM_HID);
1379	break;
1380	}
1381
1382	acpi_get_object_info(object: handle, return_buffer: &info);
1383	if (!info) {
1384	pr_err("%s: Error reading device info\n", __func__);
1385	return;
1386	}
1387
1388	if (info->valid & ACPI_VALID_HID) {
1389	acpi_add_id(pnp, dev_id: info->hardware_id.string);
1390	pnp->type.platform_id = 1;
1391	}
1392	if (info->valid & ACPI_VALID_CID) {
1393	cid_list = &info->compatible_id_list;
1394	for (i = 0; i < cid_list->count; i++)
1395	acpi_add_id(pnp, dev_id: cid_list->ids[i].string);
1396	}
1397	if (info->valid & ACPI_VALID_ADR) {
1398	pnp->bus_address = info->address;
1399	pnp->type.bus_address = 1;
1400	}
1401	if (info->valid & ACPI_VALID_UID)
1402	pnp->unique_id = kstrdup(s: info->unique_id.string,
1403	GFP_KERNEL);
1404	if (info->valid & ACPI_VALID_CLS)
1405	acpi_add_id(pnp, dev_id: info->class_code.string);
1406
1407	kfree(objp: info);
1408
1409	/*
1410	* Some devices don't reliably have _HIDs & _CIDs, so add
1411	* synthetic HIDs to make sure drivers can find them.
1412	*/
1413	if (acpi_is_video_device(handle)) {
1414	acpi_add_id(pnp, ACPI_VIDEO_HID);
1415	pnp->type.backlight = 1;
1416	break;
1417	}
1418	if (acpi_bay_match(handle))
1419	acpi_add_id(pnp, ACPI_BAY_HID);
1420	else if (acpi_dock_match(handle))
1421	acpi_add_id(pnp, ACPI_DOCK_HID);
1422	else if (acpi_ibm_smbus_match(handle))
1423	acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
1424	else if (list_empty(head: &pnp->ids) &&
1425	acpi_object_is_system_bus(handle)) {
1426	/* \_SB, \_TZ, LNXSYBUS */
1427	acpi_add_id(pnp, ACPI_BUS_HID);
1428	strcpy(p: pnp->device_name, ACPI_BUS_DEVICE_NAME);
1429	strcpy(p: pnp->device_class, ACPI_BUS_CLASS);
1430	}
1431
1432	break;
1433	case ACPI_BUS_TYPE_POWER:
1434	acpi_add_id(pnp, ACPI_POWER_HID);
1435	break;
1436	case ACPI_BUS_TYPE_PROCESSOR:
1437	acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
1438	break;
1439	case ACPI_BUS_TYPE_THERMAL:
1440	acpi_add_id(pnp, ACPI_THERMAL_HID);
1441	break;
1442	case ACPI_BUS_TYPE_POWER_BUTTON:
1443	acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
1444	break;
1445	case ACPI_BUS_TYPE_SLEEP_BUTTON:
1446	acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
1447	break;
1448	case ACPI_BUS_TYPE_ECDT_EC:
1449	acpi_add_id(pnp, ACPI_ECDT_HID);
1450	break;
1451	}
1452	}
1453
1454	void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1455	{
1456	struct acpi_hardware_id *id, *tmp;
1457
1458	list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
1459	kfree_const(x: id->id);
1460	kfree(objp: id);
1461	}
1462	kfree(objp: pnp->unique_id);
1463	}
1464
1465	/**
1466	* acpi_dma_supported - Check DMA support for the specified device.
1467	* @adev: The pointer to acpi device
1468	*
1469	* Return false if DMA is not supported. Otherwise, return true
1470	*/
1471	bool acpi_dma_supported(const struct acpi_device *adev)
1472	{
1473	if (!adev)
1474	return false;
1475
1476	if (adev->flags.cca_seen)
1477	return true;
1478
1479	/*
1480	* Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent
1481	* DMA on "Intel platforms". Presumably that includes all x86 and
1482	* ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y.
1483	*/
1484	if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1485	return true;
1486
1487	return false;
1488	}
1489
1490	/**
1491	* acpi_get_dma_attr - Check the supported DMA attr for the specified device.
1492	* @adev: The pointer to acpi device
1493	*
1494	* Return enum dev_dma_attr.
1495	*/
1496	enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
1497	{
1498	if (!acpi_dma_supported(adev))
1499	return DEV_DMA_NOT_SUPPORTED;
1500
1501	if (adev->flags.coherent_dma)
1502	return DEV_DMA_COHERENT;
1503	else
1504	return DEV_DMA_NON_COHERENT;
1505	}
1506
1507	/**
1508	* acpi_dma_get_range() - Get device DMA parameters.
1509	*
1510	* @dev: device to configure
1511	* @map: pointer to DMA ranges result
1512	*
1513	* Evaluate DMA regions and return pointer to DMA regions on
1514	* parsing success; it does not update the passed in values on failure.
1515	*
1516	* Return 0 on success, < 0 on failure.
1517	*/
1518	int acpi_dma_get_range(struct device *dev, const struct bus_dma_region **map)
1519	{
1520	struct acpi_device *adev;
1521	LIST_HEAD(list);
1522	struct resource_entry *rentry;
1523	int ret;
1524	struct device *dma_dev = dev;
1525	struct bus_dma_region *r;
1526
1527	/*
1528	* Walk the device tree chasing an ACPI companion with a _DMA
1529	* object while we go. Stop if we find a device with an ACPI
1530	* companion containing a _DMA method.
1531	*/
1532	do {
1533	adev = ACPI_COMPANION(dma_dev);
1534	if (adev && acpi_has_method(handle: adev->handle, METHOD_NAME__DMA))
1535	break;
1536
1537	dma_dev = dma_dev->parent;
1538	} while (dma_dev);
1539
1540	if (!dma_dev)
1541	return -ENODEV;
1542
1543	if (!acpi_has_method(handle: adev->handle, METHOD_NAME__CRS)) {
1544	acpi_handle_warn(adev->handle, "_DMA is valid only if _CRS is present\n");
1545	return -EINVAL;
1546	}
1547
1548	ret = acpi_dev_get_dma_resources(adev, list: &list);
1549	if (ret > 0) {
1550	r = kcalloc(n: ret + 1, size: sizeof(*r), GFP_KERNEL);
1551	if (!r) {
1552	ret = -ENOMEM;
1553	goto out;
1554	}
1555
1556	*map = r;
1557
1558	list_for_each_entry(rentry, &list, node) {
1559	if (rentry->res->start >= rentry->res->end) {
1560	kfree(objp: *map);
1561	*map = NULL;
1562	ret = -EINVAL;
1563	dev_dbg(dma_dev, "Invalid DMA regions configuration\n");
1564	goto out;
1565	}
1566
1567	r->cpu_start = rentry->res->start;
1568	r->dma_start = rentry->res->start - rentry->offset;
1569	r->size = resource_size(res: rentry->res);
1570	r++;
1571	}
1572	}
1573	out:
1574	acpi_dev_free_resource_list(list: &list);
1575
1576	return ret >= 0 ? 0 : ret;
1577	}
1578
1579	#ifdef CONFIG_IOMMU_API
1580	int acpi_iommu_fwspec_init(struct device *dev, u32 id,
1581	struct fwnode_handle *fwnode,
1582	const struct iommu_ops *ops)
1583	{
1584	int ret = iommu_fwspec_init(dev, iommu_fwnode: fwnode, ops);
1585
1586	if (!ret)
1587	ret = iommu_fwspec_add_ids(dev, ids: &id, num_ids: 1);
1588
1589	return ret;
1590	}
1591
1592	static inline const struct iommu_ops *acpi_iommu_fwspec_ops(struct device *dev)
1593	{
1594	struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
1595
1596	return fwspec ? fwspec->ops : NULL;
1597	}
1598
1599	static int acpi_iommu_configure_id(struct device *dev, const u32 *id_in)
1600	{
1601	int err;
1602	const struct iommu_ops *ops;
1603
1604	/* Serialise to make dev->iommu stable under our potential fwspec */
1605	mutex_lock(&iommu_probe_device_lock);
1606	/*
1607	* If we already translated the fwspec there is nothing left to do,
1608	* return the iommu_ops.
1609	*/
1610	ops = acpi_iommu_fwspec_ops(dev);
1611	if (ops) {
1612	mutex_unlock(lock: &iommu_probe_device_lock);
1613	return 0;
1614	}
1615
1616	err = iort_iommu_configure_id(dev, id_in);
1617	if (err && err != -EPROBE_DEFER)
1618	err = viot_iommu_configure(dev);
1619	mutex_unlock(lock: &iommu_probe_device_lock);
1620
1621	/*
1622	* If we have reason to believe the IOMMU driver missed the initial
1623	* iommu_probe_device() call for dev, replay it to get things in order.
1624	*/
1625	if (!err && dev->bus)
1626	err = iommu_probe_device(dev);
1627
1628	/* Ignore all other errors apart from EPROBE_DEFER */
1629	if (err == -EPROBE_DEFER) {
1630	return err;
1631	} else if (err) {
1632	dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
1633	return -ENODEV;
1634	}
1635	if (!acpi_iommu_fwspec_ops(dev))
1636	return -ENODEV;
1637	return 0;
1638	}
1639
1640	#else /* !CONFIG_IOMMU_API */
1641
1642	int acpi_iommu_fwspec_init(struct device *dev, u32 id,
1643	struct fwnode_handle *fwnode,
1644	const struct iommu_ops *ops)
1645	{
1646	return -ENODEV;
1647	}
1648
1649	static int acpi_iommu_configure_id(struct device *dev, const u32 *id_in)
1650	{
1651	return -ENODEV;
1652	}
1653
1654	#endif /* !CONFIG_IOMMU_API */
1655
1656	/**
1657	* acpi_dma_configure_id - Set-up DMA configuration for the device.
1658	* @dev: The pointer to the device
1659	* @attr: device dma attributes
1660	* @input_id: input device id const value pointer
1661	*/
1662	int acpi_dma_configure_id(struct device *dev, enum dev_dma_attr attr,
1663	const u32 *input_id)
1664	{
1665	int ret;
1666
1667	if (attr == DEV_DMA_NOT_SUPPORTED) {
1668	set_dma_ops(dev, dma_ops: &dma_dummy_ops);
1669	return 0;
1670	}
1671
1672	acpi_arch_dma_setup(dev);
1673
1674	ret = acpi_iommu_configure_id(dev, id_in: input_id);
1675	if (ret == -EPROBE_DEFER)
1676	return -EPROBE_DEFER;
1677
1678	/*
1679	* Historically this routine doesn't fail driver probing due to errors
1680	* in acpi_iommu_configure_id()
1681	*/
1682
1683	arch_setup_dma_ops(dev, dma_base: 0, U64_MAX, coherent: attr == DEV_DMA_COHERENT);
1684
1685	return 0;
1686	}
1687	EXPORT_SYMBOL_GPL(acpi_dma_configure_id);
1688
1689	static void acpi_init_coherency(struct acpi_device *adev)
1690	{
1691	unsigned long long cca = 0;
1692	acpi_status status;
1693	struct acpi_device *parent = acpi_dev_parent(adev);
1694
1695	if (parent && parent->flags.cca_seen) {
1696	/*
1697	* From ACPI spec, OSPM will ignore _CCA if an ancestor
1698	* already saw one.
1699	*/
1700	adev->flags.cca_seen = 1;
1701	cca = parent->flags.coherent_dma;
1702	} else {
1703	status = acpi_evaluate_integer(handle: adev->handle, pathname: "_CCA",
1704	NULL, data: &cca);
1705	if (ACPI_SUCCESS(status))
1706	adev->flags.cca_seen = 1;
1707	else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
1708	/*
1709	* If architecture does not specify that _CCA is
1710	* required for DMA-able devices (e.g. x86),
1711	* we default to _CCA=1.
1712	*/
1713	cca = 1;
1714	else
1715	acpi_handle_debug(adev->handle,
1716	"ACPI device is missing _CCA.\n");
1717	}
1718
1719	adev->flags.coherent_dma = cca;
1720	}
1721
1722	static int acpi_check_serial_bus_slave(struct acpi_resource *ares, void *data)
1723	{
1724	bool *is_serial_bus_slave_p = data;
1725
1726	if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
1727	return 1;
1728
1729	*is_serial_bus_slave_p = true;
1730
1731	/* no need to do more checking */
1732	return -1;
1733	}
1734
1735	static bool acpi_is_indirect_io_slave(struct acpi_device *device)
1736	{
1737	struct acpi_device *parent = acpi_dev_parent(adev: device);
1738	static const struct acpi_device_id indirect_io_hosts[] = {
1739	{"HISI0191", 0},
1740	{}
1741	};
1742
1743	return parent && !acpi_match_device_ids(device: parent, ids: indirect_io_hosts);
1744	}
1745
1746	static bool acpi_device_enumeration_by_parent(struct acpi_device *device)
1747	{
1748	struct list_head resource_list;
1749	bool is_serial_bus_slave = false;
1750	static const struct acpi_device_id ignore_serial_bus_ids[] = {
1751	/*
1752	* These devices have multiple SerialBus resources and a client
1753	* device must be instantiated for each of them, each with
1754	* its own device id.
1755	* Normally we only instantiate one client device for the first
1756	* resource, using the ACPI HID as id. These special cases are handled
1757	* by the drivers/platform/x86/serial-multi-instantiate.c driver, which
1758	* knows which client device id to use for each resource.
1759	*/
1760	{"BSG1160", },
1761	{"BSG2150", },
1762	{"CSC3551", },
1763	{"CSC3554", },
1764	{"CSC3556", },
1765	{"CSC3557", },
1766	{"INT33FE", },
1767	{"INT3515", },
1768	/* Non-conforming _HID for Cirrus Logic already released */
1769	{"CLSA0100", },
1770	{"CLSA0101", },
1771	/*
1772	* Some ACPI devs contain SerialBus resources even though they are not
1773	* attached to a serial bus at all.
1774	*/
1775	{ACPI_VIDEO_HID, },
1776	{"MSHW0028", },
1777	/*
1778	* HIDs of device with an UartSerialBusV2 resource for which userspace
1779	* expects a regular tty cdev to be created (instead of the in kernel
1780	* serdev) and which have a kernel driver which expects a platform_dev
1781	* such as the rfkill-gpio driver.
1782	*/
1783	{"BCM4752", },
1784	{"LNV4752", },
1785	{}
1786	};
1787
1788	if (acpi_is_indirect_io_slave(device))
1789	return true;
1790
1791	/* Macs use device properties in lieu of _CRS resources */
1792	if (x86_apple_machine &&
1793	(fwnode_property_present(fwnode: &device->fwnode, propname: "spiSclkPeriod") ||
1794	fwnode_property_present(fwnode: &device->fwnode, propname: "i2cAddress") ||
1795	fwnode_property_present(fwnode: &device->fwnode, propname: "baud")))
1796	return true;
1797
1798	if (!acpi_match_device_ids(device, ids: ignore_serial_bus_ids))
1799	return false;
1800
1801	INIT_LIST_HEAD(list: &resource_list);
1802	acpi_dev_get_resources(adev: device, list: &resource_list,
1803	preproc: acpi_check_serial_bus_slave,
1804	preproc_data: &is_serial_bus_slave);
1805	acpi_dev_free_resource_list(list: &resource_list);
1806
1807	return is_serial_bus_slave;
1808	}
1809
1810	void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1811	int type, void (*release)(struct device *))
1812	{
1813	struct acpi_device *parent = acpi_find_parent_acpi_dev(handle);
1814
1815	INIT_LIST_HEAD(list: &device->pnp.ids);
1816	device->device_type = type;
1817	device->handle = handle;
1818	device->dev.parent = parent ? &parent->dev : NULL;
1819	device->dev.release = release;
1820	device->dev.bus = &acpi_bus_type;
1821	fwnode_init(fwnode: &device->fwnode, ops: &acpi_device_fwnode_ops);
1822	acpi_set_device_status(adev: device, ACPI_STA_DEFAULT);
1823	acpi_device_get_busid(device);
1824	acpi_set_pnp_ids(handle, pnp: &device->pnp, device_type: type);
1825	acpi_init_properties(adev: device);
1826	acpi_bus_get_flags(device);
1827	device->flags.match_driver = false;
1828	device->flags.initialized = true;
1829	device->flags.enumeration_by_parent =
1830	acpi_device_enumeration_by_parent(device);
1831	acpi_device_clear_enumerated(adev: device);
1832	device_initialize(dev: &device->dev);
1833	dev_set_uevent_suppress(dev: &device->dev, val: true);
1834	acpi_init_coherency(adev: device);
1835	}
1836
1837	static void acpi_scan_dep_init(struct acpi_device *adev)
1838	{
1839	struct acpi_dep_data *dep;
1840
1841	list_for_each_entry(dep, &acpi_dep_list, node) {
1842	if (dep->consumer == adev->handle) {
1843	if (dep->honor_dep)
1844	adev->flags.honor_deps = 1;
1845
1846	if (!dep->met)
1847	adev->dep_unmet++;
1848	}
1849	}
1850	}
1851
1852	void acpi_device_add_finalize(struct acpi_device *device)
1853	{
1854	dev_set_uevent_suppress(dev: &device->dev, val: false);
1855	kobject_uevent(kobj: &device->dev.kobj, action: KOBJ_ADD);
1856	}
1857
1858	static void acpi_scan_init_status(struct acpi_device *adev)
1859	{
1860	if (acpi_bus_get_status(device: adev))
1861	acpi_set_device_status(adev, sta: 0);
1862	}
1863
1864	static int acpi_add_single_object(struct acpi_device **child,
1865	acpi_handle handle, int type, bool dep_init)
1866	{
1867	struct acpi_device *device;
1868	bool release_dep_lock = false;
1869	int result;
1870
1871	device = kzalloc(size: sizeof(struct acpi_device), GFP_KERNEL);
1872	if (!device)
1873	return -ENOMEM;
1874
1875	acpi_init_device_object(device, handle, type, release: acpi_device_release);
1876	/*
1877	* Getting the status is delayed till here so that we can call
1878	* acpi_bus_get_status() and use its quirk handling. Note that
1879	* this must be done before the get power-/wakeup_dev-flags calls.
1880	*/
1881	if (type == ACPI_BUS_TYPE_DEVICE || type == ACPI_BUS_TYPE_PROCESSOR) {
1882	if (dep_init) {
1883	mutex_lock(&acpi_dep_list_lock);
1884	/*
1885	* Hold the lock until the acpi_tie_acpi_dev() call
1886	* below to prevent concurrent acpi_scan_clear_dep()
1887	* from deleting a dependency list entry without
1888	* updating dep_unmet for the device.
1889	*/
1890	release_dep_lock = true;
1891	acpi_scan_dep_init(adev: device);
1892	}
1893	acpi_scan_init_status(adev: device);
1894	}
1895
1896	acpi_bus_get_power_flags(device);
1897	acpi_bus_get_wakeup_device_flags(device);
1898
1899	result = acpi_tie_acpi_dev(adev: device);
1900
1901	if (release_dep_lock)
1902	mutex_unlock(lock: &acpi_dep_list_lock);
1903
1904	if (!result)
1905	result = acpi_device_add(device);
1906
1907	if (result) {
1908	acpi_device_release(dev: &device->dev);
1909	return result;
1910	}
1911
1912	acpi_power_add_remove_device(adev: device, add: true);
1913	acpi_device_add_finalize(device);
1914
1915	acpi_handle_debug(handle, "Added as %s, parent %s\n",
1916	dev_name(&device->dev), device->dev.parent ?
1917	dev_name(device->dev.parent) : "(null)");
1918
1919	*child = device;
1920	return 0;
1921	}
1922
1923	static acpi_status acpi_get_resource_memory(struct acpi_resource *ares,
1924	void *context)
1925	{
1926	struct resource *res = context;
1927
1928	if (acpi_dev_resource_memory(ares, res))
1929	return AE_CTRL_TERMINATE;
1930
1931	return AE_OK;
1932	}
1933
1934	static bool acpi_device_should_be_hidden(acpi_handle handle)
1935	{
1936	acpi_status status;
1937	struct resource res;
1938
1939	/* Check if it should ignore the UART device */
1940	if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS)))
1941	return false;
1942
1943	/*
1944	* The UART device described in SPCR table is assumed to have only one
1945	* memory resource present. So we only look for the first one here.
1946	*/
1947	status = acpi_walk_resources(device: handle, METHOD_NAME__CRS,
1948	user_function: acpi_get_resource_memory, context: &res);
1949	if (ACPI_FAILURE(status) || res.start != spcr_uart_addr)
1950	return false;
1951
1952	acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n",
1953	&res.start);
1954
1955	return true;
1956	}
1957
1958	bool acpi_device_is_present(const struct acpi_device *adev)
1959	{
1960	return adev->status.present || adev->status.functional;
1961	}
1962
1963	bool acpi_device_is_enabled(const struct acpi_device *adev)
1964	{
1965	return adev->status.present && adev->status.enabled;
1966	}
1967
1968	static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
1969	const char *idstr,
1970	const struct acpi_device_id **matchid)
1971	{
1972	const struct acpi_device_id *devid;
1973
1974	if (handler->match)
1975	return handler->match(idstr, matchid);
1976
1977	for (devid = handler->ids; devid->id[0]; devid++)
1978	if (!strcmp((char *)devid->id, idstr)) {
1979	if (matchid)
1980	*matchid = devid;
1981
1982	return true;
1983	}
1984
1985	return false;
1986	}
1987
1988	static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr,
1989	const struct acpi_device_id **matchid)
1990	{
1991	struct acpi_scan_handler *handler;
1992
1993	list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
1994	if (acpi_scan_handler_matching(handler, idstr, matchid))
1995	return handler;
1996
1997	return NULL;
1998	}
1999
2000	void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
2001	{
2002	if (!!hotplug->enabled == !!val)
2003	return;
2004
2005	mutex_lock(&acpi_scan_lock);
2006
2007	hotplug->enabled = val;
2008
2009	mutex_unlock(lock: &acpi_scan_lock);
2010	}
2011
2012	static void acpi_scan_init_hotplug(struct acpi_device *adev)
2013	{
2014	struct acpi_hardware_id *hwid;
2015
2016	if (acpi_dock_match(handle: adev->handle) || is_ejectable_bay(adev)) {
2017	acpi_dock_add(adev);
2018	return;
2019	}
2020	list_for_each_entry(hwid, &adev->pnp.ids, list) {
2021	struct acpi_scan_handler *handler;
2022
2023	handler = acpi_scan_match_handler(idstr: hwid->id, NULL);
2024	if (handler) {
2025	adev->flags.hotplug_notify = true;
2026	break;
2027	}
2028	}
2029	}
2030
2031	static u32 acpi_scan_check_dep(acpi_handle handle)
2032	{
2033	struct acpi_handle_list dep_devices;
2034	u32 count;
2035	int i;
2036
2037	/*
2038	* Check for _HID here to avoid deferring the enumeration of:
2039	* 1. PCI devices.
2040	* 2. ACPI nodes describing USB ports.
2041	* Still, checking for _HID catches more then just these cases ...
2042	*/
2043	if (!acpi_has_method(handle, name: "_DEP") || !acpi_has_method(handle, name: "_HID"))
2044	return 0;
2045
2046	if (!acpi_evaluate_reference(handle, pathname: "_DEP", NULL, list: &dep_devices)) {
2047	acpi_handle_debug(handle, "Failed to evaluate _DEP.\n");
2048	return 0;
2049	}
2050
2051	for (count = 0, i = 0; i < dep_devices.count; i++) {
2052	struct acpi_device_info *info;
2053	struct acpi_dep_data *dep;
2054	bool skip, honor_dep;
2055	acpi_status status;
2056
2057	status = acpi_get_object_info(object: dep_devices.handles[i], return_buffer: &info);
2058	if (ACPI_FAILURE(status)) {
2059	acpi_handle_debug(handle, "Error reading _DEP device info\n");
2060	continue;
2061	}
2062
2063	skip = acpi_info_matches_ids(info, ids: acpi_ignore_dep_ids);
2064	honor_dep = acpi_info_matches_ids(info, ids: acpi_honor_dep_ids);
2065	kfree(objp: info);
2066
2067	if (skip)
2068	continue;
2069
2070	dep = kzalloc(size: sizeof(*dep), GFP_KERNEL);
2071	if (!dep)
2072	continue;
2073
2074	count++;
2075
2076	dep->supplier = dep_devices.handles[i];
2077	dep->consumer = handle;
2078	dep->honor_dep = honor_dep;
2079
2080	mutex_lock(&acpi_dep_list_lock);
2081	list_add_tail(new: &dep->node , head: &acpi_dep_list);
2082	mutex_unlock(lock: &acpi_dep_list_lock);
2083	}
2084
2085	acpi_handle_list_free(list: &dep_devices);
2086	return count;
2087	}
2088
2089	static acpi_status acpi_scan_check_crs_csi2_cb(acpi_handle handle, u32 a, void *b, void **c)
2090	{
2091	acpi_mipi_check_crs_csi2(handle);
2092	return AE_OK;
2093	}
2094
2095	static acpi_status acpi_bus_check_add(acpi_handle handle, bool first_pass,
2096	struct acpi_device **adev_p)
2097	{
2098	struct acpi_device *device = acpi_fetch_acpi_dev(handle);
2099	acpi_object_type acpi_type;
2100	int type;
2101
2102	if (device)
2103	goto out;
2104
2105	if (ACPI_FAILURE(acpi_get_type(handle, &acpi_type)))
2106	return AE_OK;
2107
2108	switch (acpi_type) {
2109	case ACPI_TYPE_DEVICE:
2110	if (acpi_device_should_be_hidden(handle))
2111	return AE_OK;
2112
2113	if (first_pass) {
2114	acpi_mipi_check_crs_csi2(handle);
2115
2116	/* Bail out if there are dependencies. */
2117	if (acpi_scan_check_dep(handle) > 0) {
2118	/*
2119	* The entire CSI-2 connection graph needs to be
2120	* extracted before any drivers or scan handlers
2121	* are bound to struct device objects, so scan
2122	* _CRS CSI-2 resource descriptors for all
2123	* devices below the current handle.
2124	*/
2125	acpi_walk_namespace(ACPI_TYPE_DEVICE, start_object: handle,
2126	ACPI_UINT32_MAX,
2127	descending_callback: acpi_scan_check_crs_csi2_cb,
2128	NULL, NULL, NULL);
2129	return AE_CTRL_DEPTH;
2130	}
2131	}
2132
2133	fallthrough;
2134	case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
2135	type = ACPI_BUS_TYPE_DEVICE;
2136	break;
2137
2138	case ACPI_TYPE_PROCESSOR:
2139	type = ACPI_BUS_TYPE_PROCESSOR;
2140	break;
2141
2142	case ACPI_TYPE_THERMAL:
2143	type = ACPI_BUS_TYPE_THERMAL;
2144	break;
2145
2146	case ACPI_TYPE_POWER:
2147	acpi_add_power_resource(handle);
2148	fallthrough;
2149	default:
2150	return AE_OK;
2151	}
2152
2153	/*
2154	* If first_pass is true at this point, the device has no dependencies,
2155	* or the creation of the device object would have been postponed above.
2156	*/
2157	acpi_add_single_object(child: &device, handle, type, dep_init: !first_pass);
2158	if (!device)
2159	return AE_CTRL_DEPTH;
2160
2161	acpi_scan_init_hotplug(adev: device);
2162
2163	out:
2164	if (!*adev_p)
2165	*adev_p = device;
2166
2167	return AE_OK;
2168	}
2169
2170	static acpi_status acpi_bus_check_add_1(acpi_handle handle, u32 lvl_not_used,
2171	void *not_used, void **ret_p)
2172	{
2173	return acpi_bus_check_add(handle, first_pass: true, adev_p: (struct acpi_device **)ret_p);
2174	}
2175
2176	static acpi_status acpi_bus_check_add_2(acpi_handle handle, u32 lvl_not_used,
2177	void *not_used, void **ret_p)
2178	{
2179	return acpi_bus_check_add(handle, first_pass: false, adev_p: (struct acpi_device **)ret_p);
2180	}
2181
2182	static void acpi_default_enumeration(struct acpi_device *device)
2183	{
2184	/*
2185	* Do not enumerate devices with enumeration_by_parent flag set as
2186	* they will be enumerated by their respective parents.
2187	*/
2188	if (!device->flags.enumeration_by_parent) {
2189	acpi_create_platform_device(device, NULL);
2190	acpi_device_set_enumerated(adev: device);
2191	} else {
2192	blocking_notifier_call_chain(nh: &acpi_reconfig_chain,
2193	val: ACPI_RECONFIG_DEVICE_ADD, v: device);
2194	}
2195	}
2196
2197	static const struct acpi_device_id generic_device_ids[] = {
2198	{ACPI_DT_NAMESPACE_HID, },
2199	{"", },
2200	};
2201
2202	static int acpi_generic_device_attach(struct acpi_device *adev,
2203	const struct acpi_device_id *not_used)
2204	{
2205	/*
2206	* Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test
2207	* below can be unconditional.
2208	*/
2209	if (adev->data.of_compatible)
2210	acpi_default_enumeration(device: adev);
2211
2212	return 1;
2213	}
2214
2215	static struct acpi_scan_handler generic_device_handler = {
2216	.ids = generic_device_ids,
2217	.attach = acpi_generic_device_attach,
2218	};
2219
2220	static int acpi_scan_attach_handler(struct acpi_device *device)
2221	{
2222	struct acpi_hardware_id *hwid;
2223	int ret = 0;
2224
2225	list_for_each_entry(hwid, &device->pnp.ids, list) {
2226	const struct acpi_device_id *devid;
2227	struct acpi_scan_handler *handler;
2228
2229	handler = acpi_scan_match_handler(idstr: hwid->id, matchid: &devid);
2230	if (handler) {
2231	if (!handler->attach) {
2232	device->pnp.type.platform_id = 0;
2233	continue;
2234	}
2235	device->handler = handler;
2236	ret = handler->attach(device, devid);
2237	if (ret > 0)
2238	break;
2239
2240	device->handler = NULL;
2241	if (ret < 0)
2242	break;
2243	}
2244	}
2245
2246	return ret;
2247	}
2248
2249	static int acpi_bus_attach(struct acpi_device *device, void *first_pass)
2250	{
2251	bool skip = !first_pass && device->flags.visited;
2252	acpi_handle ejd;
2253	int ret;
2254
2255	if (skip)
2256	goto ok;
2257
2258	if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
2259	register_dock_dependent_device(adev: device, dshandle: ejd);
2260
2261	acpi_bus_get_status(device);
2262	/* Skip devices that are not ready for enumeration (e.g. not present) */
2263	if (!acpi_dev_ready_for_enumeration(device)) {
2264	device->flags.initialized = false;
2265	acpi_device_clear_enumerated(adev: device);
2266	device->flags.power_manageable = 0;
2267	return 0;
2268	}
2269	if (device->handler)
2270	goto ok;
2271
2272	if (!device->flags.initialized) {
2273	device->flags.power_manageable =
2274	device->power.states[ACPI_STATE_D0].flags.valid;
2275	if (acpi_bus_init_power(device))
2276	device->flags.power_manageable = 0;
2277
2278	device->flags.initialized = true;
2279	} else if (device->flags.visited) {
2280	goto ok;
2281	}
2282
2283	ret = acpi_scan_attach_handler(device);
2284	if (ret < 0)
2285	return 0;
2286
2287	device->flags.match_driver = true;
2288	if (ret > 0 && !device->flags.enumeration_by_parent) {
2289	acpi_device_set_enumerated(adev: device);
2290	goto ok;
2291	}
2292
2293	ret = device_attach(dev: &device->dev);
2294	if (ret < 0)
2295	return 0;
2296
2297	if (device->pnp.type.platform_id || device->flags.enumeration_by_parent)
2298	acpi_default_enumeration(device);
2299	else
2300	acpi_device_set_enumerated(adev: device);
2301
2302	ok:
2303	acpi_dev_for_each_child(adev: device, fn: acpi_bus_attach, data: first_pass);
2304
2305	if (!skip && device->handler && device->handler->hotplug.notify_online)
2306	device->handler->hotplug.notify_online(device);
2307
2308	return 0;
2309	}
2310
2311	static int acpi_dev_get_next_consumer_dev_cb(struct acpi_dep_data *dep, void *data)
2312	{
2313	struct acpi_device **adev_p = data;
2314	struct acpi_device *adev = *adev_p;
2315
2316	/*
2317	* If we're passed a 'previous' consumer device then we need to skip
2318	* any consumers until we meet the previous one, and then NULL @data
2319	* so the next one can be returned.
2320	*/
2321	if (adev) {
2322	if (dep->consumer == adev->handle)
2323	*adev_p = NULL;
2324
2325	return 0;
2326	}
2327
2328	adev = acpi_get_acpi_dev(dep->consumer);
2329	if (adev) {
2330	*(struct acpi_device **)data = adev;
2331	return 1;
2332	}
2333	/* Continue parsing if the device object is not present. */
2334	return 0;
2335	}
2336
2337	struct acpi_scan_clear_dep_work {
2338	struct work_struct work;
2339	struct acpi_device *adev;
2340	};
2341
2342	static void acpi_scan_clear_dep_fn(struct work_struct *work)
2343	{
2344	struct acpi_scan_clear_dep_work *cdw;
2345
2346	cdw = container_of(work, struct acpi_scan_clear_dep_work, work);
2347
2348	acpi_scan_lock_acquire();
2349	acpi_bus_attach(device: cdw->adev, first_pass: (void *)true);
2350	acpi_scan_lock_release();
2351
2352	acpi_dev_put(adev: cdw->adev);
2353	kfree(objp: cdw);
2354	}
2355
2356	static bool acpi_scan_clear_dep_queue(struct acpi_device *adev)
2357	{
2358	struct acpi_scan_clear_dep_work *cdw;
2359
2360	if (adev->dep_unmet)
2361	return false;
2362
2363	cdw = kmalloc(size: sizeof(*cdw), GFP_KERNEL);
2364	if (!cdw)
2365	return false;
2366
2367	cdw->adev = adev;
2368	INIT_WORK(&cdw->work, acpi_scan_clear_dep_fn);
2369	/*
2370	* Since the work function may block on the lock until the entire
2371	* initial enumeration of devices is complete, put it into the unbound
2372	* workqueue.
2373	*/
2374	queue_work(wq: system_unbound_wq, work: &cdw->work);
2375
2376	return true;
2377	}
2378
2379	static void acpi_scan_delete_dep_data(struct acpi_dep_data *dep)
2380	{
2381	list_del(entry: &dep->node);
2382	kfree(objp: dep);
2383	}
2384
2385	static int acpi_scan_clear_dep(struct acpi_dep_data *dep, void *data)
2386	{
2387	struct acpi_device *adev = acpi_get_acpi_dev(dep->consumer);
2388
2389	if (adev) {
2390	adev->dep_unmet--;
2391	if (!acpi_scan_clear_dep_queue(adev))
2392	acpi_dev_put(adev);
2393	}
2394
2395	if (dep->free_when_met)
2396	acpi_scan_delete_dep_data(dep);
2397	else
2398	dep->met = true;
2399
2400	return 0;
2401	}
2402
2403	/**
2404	* acpi_walk_dep_device_list - Apply a callback to every entry in acpi_dep_list
2405	* @handle: The ACPI handle of the supplier device
2406	* @callback: Pointer to the callback function to apply
2407	* @data: Pointer to some data to pass to the callback
2408	*
2409	* The return value of the callback determines this function's behaviour. If 0
2410	* is returned we continue to iterate over acpi_dep_list. If a positive value
2411	* is returned then the loop is broken but this function returns 0. If a
2412	* negative value is returned by the callback then the loop is broken and that
2413	* value is returned as the final error.
2414	*/
2415	static int acpi_walk_dep_device_list(acpi_handle handle,
2416	int (*callback)(struct acpi_dep_data *, void *),
2417	void *data)
2418	{
2419	struct acpi_dep_data *dep, *tmp;
2420	int ret = 0;
2421
2422	mutex_lock(&acpi_dep_list_lock);
2423	list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
2424	if (dep->supplier == handle) {
2425	ret = callback(dep, data);
2426	if (ret)
2427	break;
2428	}
2429	}
2430	mutex_unlock(lock: &acpi_dep_list_lock);
2431
2432	return ret > 0 ? 0 : ret;
2433	}
2434
2435	/**
2436	* acpi_dev_clear_dependencies - Inform consumers that the device is now active
2437	* @supplier: Pointer to the supplier &struct acpi_device
2438	*
2439	* Clear dependencies on the given device.
2440	*/
2441	void acpi_dev_clear_dependencies(struct acpi_device *supplier)
2442	{
2443	acpi_walk_dep_device_list(handle: supplier->handle, callback: acpi_scan_clear_dep, NULL);
2444	}
2445	EXPORT_SYMBOL_GPL(acpi_dev_clear_dependencies);
2446
2447	/**
2448	* acpi_dev_ready_for_enumeration - Check if the ACPI device is ready for enumeration
2449	* @device: Pointer to the &struct acpi_device to check
2450	*
2451	* Check if the device is present and has no unmet dependencies.
2452	*
2453	* Return true if the device is ready for enumeratino. Otherwise, return false.
2454	*/
2455	bool acpi_dev_ready_for_enumeration(const struct acpi_device *device)
2456	{
2457	if (device->flags.honor_deps && device->dep_unmet)
2458	return false;
2459
2460	return acpi_device_is_present(adev: device);
2461	}
2462	EXPORT_SYMBOL_GPL(acpi_dev_ready_for_enumeration);
2463
2464	/**
2465	* acpi_dev_get_next_consumer_dev - Return the next adev dependent on @supplier
2466	* @supplier: Pointer to the dependee device
2467	* @start: Pointer to the current dependent device
2468	*
2469	* Returns the next &struct acpi_device which declares itself dependent on
2470	* @supplier via the _DEP buffer, parsed from the acpi_dep_list.
2471	*
2472	* If the returned adev is not passed as @start to this function, the caller is
2473	* responsible for putting the reference to adev when it is no longer needed.
2474	*/
2475	struct acpi_device *acpi_dev_get_next_consumer_dev(struct acpi_device *supplier,
2476	struct acpi_device *start)
2477	{
2478	struct acpi_device *adev = start;
2479
2480	acpi_walk_dep_device_list(handle: supplier->handle,
2481	callback: acpi_dev_get_next_consumer_dev_cb, data: &adev);
2482
2483	acpi_dev_put(adev: start);
2484
2485	if (adev == start)
2486	return NULL;
2487
2488	return adev;
2489	}
2490	EXPORT_SYMBOL_GPL(acpi_dev_get_next_consumer_dev);
2491
2492	static void acpi_scan_postponed_branch(acpi_handle handle)
2493	{
2494	struct acpi_device *adev = NULL;
2495
2496	if (ACPI_FAILURE(acpi_bus_check_add(handle, false, &adev)))
2497	return;
2498
2499	acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle, ACPI_UINT32_MAX,
2500	descending_callback: acpi_bus_check_add_2, NULL, NULL, return_value: (void **)&adev);
2501
2502	/*
2503	* Populate the ACPI _CRS CSI-2 software nodes for the ACPI devices that
2504	* have been added above.
2505	*/
2506	acpi_mipi_init_crs_csi2_swnodes();
2507
2508	acpi_bus_attach(device: adev, NULL);
2509	}
2510
2511	static void acpi_scan_postponed(void)
2512	{
2513	struct acpi_dep_data *dep, *tmp;
2514
2515	mutex_lock(&acpi_dep_list_lock);
2516
2517	list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
2518	acpi_handle handle = dep->consumer;
2519
2520	/*
2521	* In case there are multiple acpi_dep_list entries with the
2522	* same consumer, skip the current entry if the consumer device
2523	* object corresponding to it is present already.
2524	*/
2525	if (!acpi_fetch_acpi_dev(handle)) {
2526	/*
2527	* Even though the lock is released here, tmp is
2528	* guaranteed to be valid, because none of the list
2529	* entries following dep is marked as "free when met"
2530	* and so they cannot be deleted.
2531	*/
2532	mutex_unlock(lock: &acpi_dep_list_lock);
2533
2534	acpi_scan_postponed_branch(handle);
2535
2536	mutex_lock(&acpi_dep_list_lock);
2537	}
2538
2539	if (dep->met)
2540	acpi_scan_delete_dep_data(dep);
2541	else
2542	dep->free_when_met = true;
2543	}
2544
2545	mutex_unlock(lock: &acpi_dep_list_lock);
2546	}
2547
2548	/**
2549	* acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2550	* @handle: Root of the namespace scope to scan.
2551	*
2552	* Scan a given ACPI tree (probably recently hot-plugged) and create and add
2553	* found devices.
2554	*
2555	* If no devices were found, -ENODEV is returned, but it does not mean that
2556	* there has been a real error. There just have been no suitable ACPI objects
2557	* in the table trunk from which the kernel could create a device and add an
2558	* appropriate driver.
2559	*
2560	* Must be called under acpi_scan_lock.
2561	*/
2562	int acpi_bus_scan(acpi_handle handle)
2563	{
2564	struct acpi_device *device = NULL;
2565
2566	/* Pass 1: Avoid enumerating devices with missing dependencies. */
2567
2568	if (ACPI_SUCCESS(acpi_bus_check_add(handle, true, &device)))
2569	acpi_walk_namespace(ACPI_TYPE_ANY, start_object: handle, ACPI_UINT32_MAX,
2570	descending_callback: acpi_bus_check_add_1, NULL, NULL,
2571	return_value: (void **)&device);
2572
2573	if (!device)
2574	return -ENODEV;
2575
2576	/*
2577	* Set up ACPI _CRS CSI-2 software nodes using information extracted
2578	* from the _CRS CSI-2 resource descriptors during the ACPI namespace
2579	* walk above and MIPI DisCo for Imaging device properties.
2580	*/
2581	acpi_mipi_scan_crs_csi2();
2582	acpi_mipi_init_crs_csi2_swnodes();
2583
2584	acpi_bus_attach(device, first_pass: (void *)true);
2585
2586	/* Pass 2: Enumerate all of the remaining devices. */
2587
2588	acpi_scan_postponed();
2589
2590	acpi_mipi_crs_csi2_cleanup();
2591
2592	return 0;
2593	}
2594	EXPORT_SYMBOL(acpi_bus_scan);
2595
2596	/**
2597	* acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
2598	* @adev: Root of the ACPI namespace scope to walk.
2599	*
2600	* Must be called under acpi_scan_lock.
2601	*/
2602	void acpi_bus_trim(struct acpi_device *adev)
2603	{
2604	acpi_scan_check_and_detach(adev, NULL);
2605	}
2606	EXPORT_SYMBOL_GPL(acpi_bus_trim);
2607
2608	int acpi_bus_register_early_device(int type)
2609	{
2610	struct acpi_device *device = NULL;
2611	int result;
2612
2613	result = acpi_add_single_object(child: &device, NULL, type, dep_init: false);
2614	if (result)
2615	return result;
2616
2617	device->flags.match_driver = true;
2618	return device_attach(dev: &device->dev);
2619	}
2620	EXPORT_SYMBOL_GPL(acpi_bus_register_early_device);
2621
2622	static void acpi_bus_scan_fixed(void)
2623	{
2624	if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
2625	struct acpi_device *adev = NULL;
2626
2627	acpi_add_single_object(child: &adev, NULL, type: ACPI_BUS_TYPE_POWER_BUTTON,
2628	dep_init: false);
2629	if (adev) {
2630	adev->flags.match_driver = true;
2631	if (device_attach(dev: &adev->dev) >= 0)
2632	device_init_wakeup(dev: &adev->dev, enable: true);
2633	else
2634	dev_dbg(&adev->dev, "No driver\n");
2635	}
2636	}
2637
2638	if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
2639	struct acpi_device *adev = NULL;
2640
2641	acpi_add_single_object(child: &adev, NULL, type: ACPI_BUS_TYPE_SLEEP_BUTTON,
2642	dep_init: false);
2643	if (adev) {
2644	adev->flags.match_driver = true;
2645	if (device_attach(dev: &adev->dev) < 0)
2646	dev_dbg(&adev->dev, "No driver\n");
2647	}
2648	}
2649	}
2650
2651	static void __init acpi_get_spcr_uart_addr(void)
2652	{
2653	acpi_status status;
2654	struct acpi_table_spcr *spcr_ptr;
2655
2656	status = acpi_get_table(ACPI_SIG_SPCR, instance: 0,
2657	out_table: (struct acpi_table_header **)&spcr_ptr);
2658	if (ACPI_FAILURE(status)) {
2659	pr_warn("STAO table present, but SPCR is missing\n");
2660	return;
2661	}
2662
2663	spcr_uart_addr = spcr_ptr->serial_port.address;
2664	acpi_put_table(table: (struct acpi_table_header *)spcr_ptr);
2665	}
2666
2667	static bool acpi_scan_initialized;
2668
2669	void __init acpi_scan_init(void)
2670	{
2671	acpi_status status;
2672	struct acpi_table_stao *stao_ptr;
2673
2674	acpi_pci_root_init();
2675	acpi_pci_link_init();
2676	acpi_processor_init();
2677	acpi_platform_init();
2678	acpi_lpss_init();
2679	acpi_apd_init();
2680	acpi_cmos_rtc_init();
2681	acpi_container_init();
2682	acpi_memory_hotplug_init();
2683	acpi_watchdog_init();
2684	acpi_pnp_init();
2685	acpi_int340x_thermal_init();
2686	acpi_init_lpit();
2687
2688	acpi_scan_add_handler(handler: &generic_device_handler);
2689
2690	/*
2691	* If there is STAO table, check whether it needs to ignore the UART
2692	* device in SPCR table.
2693	*/
2694	status = acpi_get_table(ACPI_SIG_STAO, instance: 0,
2695	out_table: (struct acpi_table_header **)&stao_ptr);
2696	if (ACPI_SUCCESS(status)) {
2697	if (stao_ptr->header.length > sizeof(struct acpi_table_stao))
2698	pr_info("STAO Name List not yet supported.\n");
2699
2700	if (stao_ptr->ignore_uart)
2701	acpi_get_spcr_uart_addr();
2702
2703	acpi_put_table(table: (struct acpi_table_header *)stao_ptr);
2704	}
2705
2706	acpi_gpe_apply_masked_gpes();
2707	acpi_update_all_gpes();
2708
2709	/*
2710	* Although we call __add_memory() that is documented to require the
2711	* device_hotplug_lock, it is not necessary here because this is an
2712	* early code when userspace or any other code path cannot trigger
2713	* hotplug/hotunplug operations.
2714	*/
2715	mutex_lock(&acpi_scan_lock);
2716	/*
2717	* Enumerate devices in the ACPI namespace.
2718	*/
2719	if (acpi_bus_scan(ACPI_ROOT_OBJECT))
2720	goto unlock;
2721
2722	acpi_root = acpi_fetch_acpi_dev(ACPI_ROOT_OBJECT);
2723	if (!acpi_root)
2724	goto unlock;
2725
2726	/* Fixed feature devices do not exist on HW-reduced platform */
2727	if (!acpi_gbl_reduced_hardware)
2728	acpi_bus_scan_fixed();
2729
2730	acpi_turn_off_unused_power_resources();
2731
2732	acpi_scan_initialized = true;
2733
2734	unlock:
2735	mutex_unlock(lock: &acpi_scan_lock);
2736	}
2737
2738	static struct acpi_probe_entry *ape;
2739	static int acpi_probe_count;
2740	static DEFINE_MUTEX(acpi_probe_mutex);
2741
2742	static int __init acpi_match_madt(union acpi_subtable_headers *header,
2743	const unsigned long end)
2744	{
2745	if (!ape->subtable_valid || ape->subtable_valid(&header->common, ape))
2746	if (!ape->probe_subtbl(header, end))
2747	acpi_probe_count++;
2748
2749	return 0;
2750	}
2751
2752	int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
2753	{
2754	int count = 0;
2755
2756	if (acpi_disabled)
2757	return 0;
2758
2759	mutex_lock(&acpi_probe_mutex);
2760	for (ape = ap_head; nr; ape++, nr--) {
2761	if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT, ape->id)) {
2762	acpi_probe_count = 0;
2763	acpi_table_parse_madt(id: ape->type, handler: acpi_match_madt, max_entries: 0);
2764	count += acpi_probe_count;
2765	} else {
2766	int res;
2767	res = acpi_table_parse(id: ape->id, handler: ape->probe_table);
2768	if (!res)
2769	count++;
2770	}
2771	}
2772	mutex_unlock(lock: &acpi_probe_mutex);
2773
2774	return count;
2775	}
2776
2777	static void acpi_table_events_fn(struct work_struct *work)
2778	{
2779	acpi_scan_lock_acquire();
2780	acpi_bus_scan(ACPI_ROOT_OBJECT);
2781	acpi_scan_lock_release();
2782
2783	kfree(objp: work);
2784	}
2785
2786	void acpi_scan_table_notify(void)
2787	{
2788	struct work_struct *work;
2789
2790	if (!acpi_scan_initialized)
2791	return;
2792
2793	work = kmalloc(size: sizeof(*work), GFP_KERNEL);
2794	if (!work)
2795	return;
2796
2797	INIT_WORK(work, acpi_table_events_fn);
2798	schedule_work(work);
2799	}
2800
2801	int acpi_reconfig_notifier_register(struct notifier_block *nb)
2802	{
2803	return blocking_notifier_chain_register(nh: &acpi_reconfig_chain, nb);
2804	}
2805	EXPORT_SYMBOL(acpi_reconfig_notifier_register);
2806
2807	int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
2808	{
2809	return blocking_notifier_chain_unregister(nh: &acpi_reconfig_chain, nb);
2810	}
2811	EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);
2812