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