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