Lines Matching +full:device +full:- +full:handle
1 // SPDX-License-Identifier: GPL-2.0-only
3 * scan.c - support for transforming the ACPI namespace into individual objects
19 #include <linux/dma-map-ops.h>
23 #include <linux/dma-direct.h>
34 static const char *dummy_hid = "device";
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
80 hp->notify = notify; in acpi_initialize_hp_context()
81 hp->uevent = uevent; in acpi_initialize_hp_context()
90 return -EINVAL; in acpi_scan_add_handler()
92 list_add_tail(&handler->list_node, &acpi_scan_handlers_list); in acpi_scan_add_handler()
105 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name); in acpi_scan_add_handler_with_hotplug()
119 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING); in acpi_scan_is_offline()
121 list_for_each_entry(pn, &adev->physical_node_list, node) in acpi_scan_is_offline()
122 if (device_supports_offline(pn->dev) && !pn->dev->offline) { in acpi_scan_is_offline()
124 kobject_uevent_env(&pn->dev->kobj, KOBJ_CHANGE, envp); in acpi_scan_is_offline()
130 mutex_unlock(&adev->physical_node_lock); in acpi_scan_is_offline()
134 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data, in acpi_bus_offline() argument
137 struct acpi_device *device = acpi_fetch_acpi_dev(handle); in acpi_bus_offline() local
142 if (!device) in acpi_bus_offline()
145 if (device->handler && !device->handler->hotplug.enabled) { in acpi_bus_offline()
146 *ret_p = &device->dev; in acpi_bus_offline()
150 mutex_lock(&device->physical_node_lock); in acpi_bus_offline()
152 list_for_each_entry(pn, &device->physical_node_list, node) { in acpi_bus_offline()
157 if (pn->put_online) in acpi_bus_offline()
160 pn->put_online = false; in acpi_bus_offline()
162 ret = device_offline(pn->dev); in acpi_bus_offline()
164 pn->put_online = !ret; in acpi_bus_offline()
166 *ret_p = pn->dev; in acpi_bus_offline()
174 mutex_unlock(&device->physical_node_lock); in acpi_bus_offline()
179 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data, in acpi_bus_online() argument
182 struct acpi_device *device = acpi_fetch_acpi_dev(handle); in acpi_bus_online() local
185 if (!device) in acpi_bus_online()
188 mutex_lock(&device->physical_node_lock); in acpi_bus_online()
190 list_for_each_entry(pn, &device->physical_node_list, node) in acpi_bus_online()
191 if (pn->put_online) { in acpi_bus_online()
192 device_online(pn->dev); in acpi_bus_online()
193 pn->put_online = false; in acpi_bus_online()
196 mutex_unlock(&device->physical_node_lock); in acpi_bus_online()
201 static int acpi_scan_try_to_offline(struct acpi_device *device) in acpi_scan_try_to_offline() argument
203 acpi_handle handle = device->handle; in acpi_scan_try_to_offline() local
204 struct device *errdev = NULL; in acpi_scan_try_to_offline()
216 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, in acpi_scan_try_to_offline()
221 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, in acpi_scan_try_to_offline()
223 return -EPERM; in acpi_scan_try_to_offline()
225 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev); in acpi_scan_try_to_offline()
228 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, in acpi_scan_try_to_offline()
232 acpi_bus_offline(handle, 0, (void *)true, in acpi_scan_try_to_offline()
237 acpi_bus_online(handle, 0, NULL, NULL); in acpi_scan_try_to_offline()
238 acpi_walk_namespace(ACPI_TYPE_ANY, handle, in acpi_scan_try_to_offline()
241 return -EBUSY; in acpi_scan_try_to_offline()
247 static int acpi_scan_hot_remove(struct acpi_device *device) in acpi_scan_hot_remove() argument
249 acpi_handle handle = device->handle; in acpi_scan_hot_remove() local
253 if (device->handler && device->handler->hotplug.demand_offline) { in acpi_scan_hot_remove()
254 if (!acpi_scan_is_offline(device, true)) in acpi_scan_hot_remove()
255 return -EBUSY; in acpi_scan_hot_remove()
257 int error = acpi_scan_try_to_offline(device); in acpi_scan_hot_remove()
262 acpi_handle_debug(handle, "Ejecting\n"); in acpi_scan_hot_remove()
264 acpi_bus_trim(device); in acpi_scan_hot_remove()
266 acpi_evaluate_lck(handle, 0); in acpi_scan_hot_remove()
270 status = acpi_evaluate_ej0(handle); in acpi_scan_hot_remove()
272 return -ENODEV; in acpi_scan_hot_remove()
274 return -EIO; in acpi_scan_hot_remove()
280 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); in acpi_scan_hot_remove()
282 acpi_handle_warn(handle, in acpi_scan_hot_remove()
285 acpi_handle_warn(handle, in acpi_scan_hot_remove()
286 "Eject incomplete - status 0x%llx\n", sta); in acpi_scan_hot_remove()
295 dev_warn(&adev->dev, "Still not present\n"); in acpi_scan_device_not_present()
296 return -EALREADY; in acpi_scan_device_not_present()
307 if (adev->status.present || adev->status.functional) { in acpi_scan_device_check()
309 * This function is only called for device objects for which in acpi_scan_device_check()
311 * the scan handler is not attached to this device object yet in acpi_scan_device_check()
312 * is when the device has just appeared (either it wasn't in acpi_scan_device_check()
316 if (adev->handler) { in acpi_scan_device_check()
317 dev_dbg(&adev->dev, "Already enumerated\n"); in acpi_scan_device_check()
320 error = acpi_bus_scan(adev->handle); in acpi_scan_device_check()
322 dev_warn(&adev->dev, "Namespace scan failure\n"); in acpi_scan_device_check()
333 struct acpi_scan_handler *handler = adev->handler; in acpi_scan_bus_check()
337 if (!(adev->status.present || adev->status.functional)) { in acpi_scan_bus_check()
341 if (handler && handler->hotplug.scan_dependent) in acpi_scan_bus_check()
342 return handler->hotplug.scan_dependent(adev); in acpi_scan_bus_check()
344 error = acpi_bus_scan(adev->handle); in acpi_scan_bus_check()
346 dev_warn(&adev->dev, "Namespace scan failure\n"); in acpi_scan_bus_check()
361 if (adev->handler && !adev->handler->hotplug.enabled) { in acpi_generic_hotplug_event()
362 dev_info(&adev->dev, "Eject disabled\n"); in acpi_generic_hotplug_event()
363 return -EPERM; in acpi_generic_hotplug_event()
365 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST, in acpi_generic_hotplug_event()
369 return -EINVAL; in acpi_generic_hotplug_event()
375 int error = -ENODEV; in acpi_device_hotplug()
381 * The device object's ACPI handle cannot become invalid as long as we in acpi_device_hotplug()
385 if (adev->handle == INVALID_ACPI_HANDLE) in acpi_device_hotplug()
388 if (adev->flags.is_dock_station) { in acpi_device_hotplug()
390 } else if (adev->flags.hotplug_notify) { in acpi_device_hotplug()
396 notify = adev->hp ? adev->hp->notify : NULL; in acpi_device_hotplug()
399 * There may be additional notify handlers for device objects in acpi_device_hotplug()
411 case -EPERM: in acpi_device_hotplug()
414 case -EBUSY: in acpi_device_hotplug()
423 acpi_evaluate_ost(adev->handle, src, ost_code, NULL); in acpi_device_hotplug()
431 static void acpi_free_power_resources_lists(struct acpi_device *device) in acpi_free_power_resources_lists() argument
435 if (device->wakeup.flags.valid) in acpi_free_power_resources_lists()
436 acpi_power_resources_list_free(&device->wakeup.resources); in acpi_free_power_resources_lists()
438 if (!device->power.flags.power_resources) in acpi_free_power_resources_lists()
442 struct acpi_device_power_state *ps = &device->power.states[i]; in acpi_free_power_resources_lists()
443 acpi_power_resources_list_free(&ps->resources); in acpi_free_power_resources_lists()
447 static void acpi_device_release(struct device *dev) in acpi_device_release()
452 acpi_free_pnp_ids(&acpi_dev->pnp); in acpi_device_release()
457 static void acpi_device_del(struct acpi_device *device) in acpi_device_del() argument
464 if (!strcmp(acpi_device_bus_id->bus_id, in acpi_device_del()
465 acpi_device_hid(device))) { in acpi_device_del()
466 ida_free(&acpi_device_bus_id->instance_ida, in acpi_device_del()
467 device->pnp.instance_no); in acpi_device_del()
468 if (ida_is_empty(&acpi_device_bus_id->instance_ida)) { in acpi_device_del()
469 list_del(&acpi_device_bus_id->node); in acpi_device_del()
470 kfree_const(acpi_device_bus_id->bus_id); in acpi_device_del()
476 list_del(&device->wakeup_list); in acpi_device_del()
480 acpi_power_add_remove_device(device, false); in acpi_device_del()
481 acpi_device_remove_files(device); in acpi_device_del()
482 if (device->remove) in acpi_device_del()
483 device->remove(device); in acpi_device_del()
485 device_del(&device->dev); in acpi_device_del()
506 list_del(&adev->del_list); in acpi_device_del_work_fn()
516 * used by the device. in acpi_device_del_work_fn()
524 * acpi_scan_drop_device - Drop an ACPI device object.
525 * @handle: Handle of an ACPI namespace node, not used.
526 * @context: Address of the ACPI device object to drop.
529 * namespace node the device object pointed to by @context is attached to.
533 * ensure the correct ordering (the device objects must be unregistered in the
536 static void acpi_scan_drop_device(acpi_handle handle, void *context) in acpi_scan_drop_device() argument
546 * prevents attempts to register device objects identical to those being in acpi_scan_drop_device()
550 * those work items to ensure that they are not accessing stale device in acpi_scan_drop_device()
556 list_add_tail(&adev->del_list, &acpi_device_del_list); in acpi_scan_drop_device()
557 /* Make acpi_ns_validate_handle() return NULL for this handle. */ in acpi_scan_drop_device()
558 adev->handle = INVALID_ACPI_HANDLE; in acpi_scan_drop_device()
563 static struct acpi_device *handle_to_device(acpi_handle handle, in handle_to_device() argument
569 status = acpi_get_data_full(handle, acpi_scan_drop_device, in handle_to_device()
572 acpi_handle_debug(handle, "No context!\n"); in handle_to_device()
579 * acpi_fetch_acpi_dev - Retrieve ACPI device object.
580 * @handle: ACPI handle associated with the requested ACPI device object.
582 * Return a pointer to the ACPI device object associated with @handle, if
585 struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle) in acpi_fetch_acpi_dev() argument
587 return handle_to_device(handle, NULL); in acpi_fetch_acpi_dev()
597 * acpi_get_acpi_dev - Retrieve ACPI device object and reference count it.
598 * @handle: ACPI handle associated with the requested ACPI device object.
600 * Return a pointer to the ACPI device object associated with @handle and bump
604 * The ACPI device object reference acquired by this function needs to be
607 struct acpi_device *acpi_get_acpi_dev(acpi_handle handle) in acpi_get_acpi_dev() argument
609 return handle_to_device(handle, get_acpi_device); in acpi_get_acpi_dev()
619 if (!strcmp(acpi_device_bus_id->bus_id, dev_id)) in acpi_device_bus_id_match()
625 static int acpi_device_set_name(struct acpi_device *device, in acpi_device_set_name() argument
628 struct ida *instance_ida = &acpi_device_bus_id->instance_ida; in acpi_device_set_name()
635 device->pnp.instance_no = result; in acpi_device_set_name()
636 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, result); in acpi_device_set_name()
642 acpi_handle handle = adev->handle; in acpi_tie_acpi_dev() local
645 if (!handle) in acpi_tie_acpi_dev()
648 status = acpi_attach_data(handle, acpi_scan_drop_device, adev); in acpi_tie_acpi_dev()
650 acpi_handle_err(handle, "Unable to attach device data\n"); in acpi_tie_acpi_dev()
651 return -ENODEV; in acpi_tie_acpi_dev()
662 status = acpi_get_physical_device_location(adev->handle, &pld); in acpi_store_pld_crc()
666 adev->pld_crc = crc32(~0, pld, sizeof(*pld)); in acpi_store_pld_crc()
670 int acpi_device_add(struct acpi_device *device) in acpi_device_add() argument
677 * ------- in acpi_device_add()
678 * Link this device to its parent and siblings. in acpi_device_add()
680 INIT_LIST_HEAD(&device->wakeup_list); in acpi_device_add()
681 INIT_LIST_HEAD(&device->physical_node_list); in acpi_device_add()
682 INIT_LIST_HEAD(&device->del_list); in acpi_device_add()
683 mutex_init(&device->physical_node_lock); in acpi_device_add()
687 acpi_device_bus_id = acpi_device_bus_id_match(acpi_device_hid(device)); in acpi_device_add()
689 result = acpi_device_set_name(device, acpi_device_bus_id); in acpi_device_add()
696 result = -ENOMEM; in acpi_device_add()
699 acpi_device_bus_id->bus_id = in acpi_device_add()
700 kstrdup_const(acpi_device_hid(device), GFP_KERNEL); in acpi_device_add()
701 if (!acpi_device_bus_id->bus_id) { in acpi_device_add()
703 result = -ENOMEM; in acpi_device_add()
707 ida_init(&acpi_device_bus_id->instance_ida); in acpi_device_add()
709 result = acpi_device_set_name(device, acpi_device_bus_id); in acpi_device_add()
711 kfree_const(acpi_device_bus_id->bus_id); in acpi_device_add()
716 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list); in acpi_device_add()
719 if (device->wakeup.flags.valid) in acpi_device_add()
720 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list); in acpi_device_add()
722 acpi_store_pld_crc(device); in acpi_device_add()
726 result = device_add(&device->dev); in acpi_device_add()
728 dev_err(&device->dev, "Error registering device\n"); in acpi_device_add()
732 result = acpi_device_setup_files(device); in acpi_device_add()
734 pr_err("Error creating sysfs interface for device %s\n", in acpi_device_add()
735 dev_name(&device->dev)); in acpi_device_add()
742 list_del(&device->wakeup_list); in acpi_device_add()
747 acpi_detach_data(device->handle, acpi_scan_drop_device); in acpi_device_add()
752 /* --------------------------------------------------------------------------
753 Device Enumeration
754 -------------------------------------------------------------------------- */
761 if (!(info->valid & ACPI_VALID_HID)) in acpi_info_matches_ids()
764 index = match_string(ids, -1, info->hardware_id.string); in acpi_info_matches_ids()
768 if (info->valid & ACPI_VALID_CID) in acpi_info_matches_ids()
769 cid_list = &info->compatible_id_list; in acpi_info_matches_ids()
774 for (i = 0; i < cid_list->count; i++) { in acpi_info_matches_ids()
775 index = match_string(ids, -1, cid_list->ids[i].string); in acpi_info_matches_ids()
785 "PNP0D80", /* Windows-compatible System Power Management Controller */
786 "INT33BD", /* Intel Baytrail Mailbox Device */
800 static struct acpi_device *acpi_find_parent_acpi_dev(acpi_handle handle) in acpi_find_parent_acpi_dev() argument
809 if (!handle) in acpi_find_parent_acpi_dev()
815 status = acpi_get_parent(handle, &handle); in acpi_find_parent_acpi_dev()
822 adev = acpi_fetch_acpi_dev(handle); in acpi_find_parent_acpi_dev()
828 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd) in acpi_bus_get_ejd() argument
835 status = acpi_get_handle(handle, "_EJD", &tmp); in acpi_bus_get_ejd()
839 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer); in acpi_bus_get_ejd()
842 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer, in acpi_bus_get_ejd()
852 acpi_handle handle = dev->handle; in acpi_bus_extract_wakeup_device_power_package() local
853 struct acpi_device_wakeup *wakeup = &dev->wakeup; in acpi_bus_extract_wakeup_device_power_package()
858 int err = -ENODATA; in acpi_bus_extract_wakeup_device_power_package()
860 INIT_LIST_HEAD(&wakeup->resources); in acpi_bus_extract_wakeup_device_power_package()
863 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer); in acpi_bus_extract_wakeup_device_power_package()
865 acpi_handle_info(handle, "_PRW evaluation failed: %s\n", in acpi_bus_extract_wakeup_device_power_package()
872 if (!package || package->package.count < 2) in acpi_bus_extract_wakeup_device_power_package()
875 element = &(package->package.elements[0]); in acpi_bus_extract_wakeup_device_power_package()
879 if (element->type == ACPI_TYPE_PACKAGE) { in acpi_bus_extract_wakeup_device_power_package()
880 if ((element->package.count < 2) || in acpi_bus_extract_wakeup_device_power_package()
881 (element->package.elements[0].type != in acpi_bus_extract_wakeup_device_power_package()
883 || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) in acpi_bus_extract_wakeup_device_power_package()
886 wakeup->gpe_device = in acpi_bus_extract_wakeup_device_power_package()
887 element->package.elements[0].reference.handle; in acpi_bus_extract_wakeup_device_power_package()
888 wakeup->gpe_number = in acpi_bus_extract_wakeup_device_power_package()
889 (u32) element->package.elements[1].integer.value; in acpi_bus_extract_wakeup_device_power_package()
890 } else if (element->type == ACPI_TYPE_INTEGER) { in acpi_bus_extract_wakeup_device_power_package()
891 wakeup->gpe_device = NULL; in acpi_bus_extract_wakeup_device_power_package()
892 wakeup->gpe_number = element->integer.value; in acpi_bus_extract_wakeup_device_power_package()
897 element = &(package->package.elements[1]); in acpi_bus_extract_wakeup_device_power_package()
898 if (element->type != ACPI_TYPE_INTEGER) in acpi_bus_extract_wakeup_device_power_package()
901 wakeup->sleep_state = element->integer.value; in acpi_bus_extract_wakeup_device_power_package()
903 err = acpi_extract_power_resources(package, 2, &wakeup->resources); in acpi_bus_extract_wakeup_device_power_package()
907 if (!list_empty(&wakeup->resources)) { in acpi_bus_extract_wakeup_device_power_package()
910 err = acpi_power_wakeup_list_init(&wakeup->resources, in acpi_bus_extract_wakeup_device_power_package()
913 acpi_handle_warn(handle, "Retrieving current states " in acpi_bus_extract_wakeup_device_power_package()
915 acpi_power_resources_list_free(&wakeup->resources); in acpi_bus_extract_wakeup_device_power_package()
918 if (sleep_state < wakeup->sleep_state) { in acpi_bus_extract_wakeup_device_power_package()
919 acpi_handle_warn(handle, "Overriding _PRW sleep state " in acpi_bus_extract_wakeup_device_power_package()
921 (int)wakeup->sleep_state, sleep_state); in acpi_bus_extract_wakeup_device_power_package()
922 wakeup->sleep_state = sleep_state; in acpi_bus_extract_wakeup_device_power_package()
934 static bool acpi_wakeup_gpe_init(struct acpi_device *device) in acpi_wakeup_gpe_init() argument
942 struct acpi_device_wakeup *wakeup = &device->wakeup; in acpi_wakeup_gpe_init()
946 wakeup->flags.notifier_present = 0; in acpi_wakeup_gpe_init()
949 match = acpi_match_acpi_device(button_device_ids, device); in acpi_wakeup_gpe_init()
951 if ((match->driver_data & ACPI_AVOID_WAKE_FROM_S5) && in acpi_wakeup_gpe_init()
952 wakeup->sleep_state == ACPI_STATE_S5) in acpi_wakeup_gpe_init()
953 wakeup->sleep_state = ACPI_STATE_S4; in acpi_wakeup_gpe_init()
954 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number); in acpi_wakeup_gpe_init()
955 device_set_wakeup_capable(&device->dev, true); in acpi_wakeup_gpe_init()
959 status = acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device, in acpi_wakeup_gpe_init()
960 wakeup->gpe_number); in acpi_wakeup_gpe_init()
964 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device) in acpi_bus_get_wakeup_device_flags() argument
969 if (!acpi_has_method(device->handle, "_PRW")) in acpi_bus_get_wakeup_device_flags()
972 err = acpi_bus_extract_wakeup_device_power_package(device); in acpi_bus_get_wakeup_device_flags()
974 dev_err(&device->dev, "Unable to extract wakeup power resources"); in acpi_bus_get_wakeup_device_flags()
978 device->wakeup.flags.valid = acpi_wakeup_gpe_init(device); in acpi_bus_get_wakeup_device_flags()
979 device->wakeup.prepare_count = 0; in acpi_bus_get_wakeup_device_flags()
982 * system for the ACPI device with the _PRW object. in acpi_bus_get_wakeup_device_flags()
987 err = acpi_device_sleep_wake(device, 0, 0, 0); in acpi_bus_get_wakeup_device_flags()
992 static void acpi_bus_init_power_state(struct acpi_device *device, int state) in acpi_bus_init_power_state() argument
994 struct acpi_device_power_state *ps = &device->power.states[state]; in acpi_bus_init_power_state()
999 INIT_LIST_HEAD(&ps->resources); in acpi_bus_init_power_state()
1002 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer); in acpi_bus_init_power_state()
1007 && package->type == ACPI_TYPE_PACKAGE in acpi_bus_init_power_state()
1008 && package->package.count) in acpi_bus_init_power_state()
1009 acpi_extract_power_resources(package, 0, &ps->resources); in acpi_bus_init_power_state()
1016 if (acpi_has_method(device->handle, pathname)) in acpi_bus_init_power_state()
1017 ps->flags.explicit_set = 1; in acpi_bus_init_power_state()
1019 /* State is valid if there are means to put the device into it. */ in acpi_bus_init_power_state()
1020 if (!list_empty(&ps->resources) || ps->flags.explicit_set) in acpi_bus_init_power_state()
1021 ps->flags.valid = 1; in acpi_bus_init_power_state()
1023 ps->power = -1; /* Unknown - driver assigned */ in acpi_bus_init_power_state()
1024 ps->latency = -1; /* Unknown - driver assigned */ in acpi_bus_init_power_state()
1027 static void acpi_bus_get_power_flags(struct acpi_device *device) in acpi_bus_get_power_flags() argument
1033 if (!acpi_has_method(device->handle, "_PS0") && in acpi_bus_get_power_flags()
1034 !acpi_has_method(device->handle, "_PR0")) in acpi_bus_get_power_flags()
1037 device->flags.power_manageable = 1; in acpi_bus_get_power_flags()
1042 if (acpi_has_method(device->handle, "_PSC")) in acpi_bus_get_power_flags()
1043 device->power.flags.explicit_get = 1; in acpi_bus_get_power_flags()
1045 if (acpi_has_method(device->handle, "_IRC")) in acpi_bus_get_power_flags()
1046 device->power.flags.inrush_current = 1; in acpi_bus_get_power_flags()
1048 if (acpi_has_method(device->handle, "_DSW")) in acpi_bus_get_power_flags()
1049 device->power.flags.dsw_present = 1; in acpi_bus_get_power_flags()
1051 acpi_evaluate_integer(device->handle, "_DSC", NULL, &dsc); in acpi_bus_get_power_flags()
1052 device->power.state_for_enumeration = dsc; in acpi_bus_get_power_flags()
1058 acpi_bus_init_power_state(device, i); in acpi_bus_get_power_flags()
1060 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources); in acpi_bus_get_power_flags()
1063 device->power.states[ACPI_STATE_D0].flags.valid = 1; in acpi_bus_get_power_flags()
1064 device->power.states[ACPI_STATE_D0].power = 100; in acpi_bus_get_power_flags()
1065 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1; in acpi_bus_get_power_flags()
1072 if (!list_empty(&device->power.states[ACPI_STATE_D0].resources)) { in acpi_bus_get_power_flags()
1073 device->power.flags.power_resources = 1; in acpi_bus_get_power_flags()
1078 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources)) in acpi_bus_get_power_flags()
1079 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1; in acpi_bus_get_power_flags()
1082 if (acpi_bus_init_power(device)) in acpi_bus_get_power_flags()
1083 device->flags.power_manageable = 0; in acpi_bus_get_power_flags()
1086 static void acpi_bus_get_flags(struct acpi_device *device) in acpi_bus_get_flags() argument
1089 if (acpi_has_method(device->handle, "_STA")) in acpi_bus_get_flags()
1090 device->flags.dynamic_status = 1; in acpi_bus_get_flags()
1093 if (acpi_has_method(device->handle, "_RMV")) in acpi_bus_get_flags()
1094 device->flags.removable = 1; in acpi_bus_get_flags()
1097 if (acpi_has_method(device->handle, "_EJD") || in acpi_bus_get_flags()
1098 acpi_has_method(device->handle, "_EJ0")) in acpi_bus_get_flags()
1099 device->flags.ejectable = 1; in acpi_bus_get_flags()
1102 static void acpi_device_get_busid(struct acpi_device *device) in acpi_device_get_busid() argument
1110 * ------ in acpi_device_get_busid()
1111 * The device's Bus ID is simply the object name. in acpi_device_get_busid()
1114 if (!acpi_dev_parent(device)) { in acpi_device_get_busid()
1115 strcpy(device->pnp.bus_id, "ACPI"); in acpi_device_get_busid()
1119 switch (device->device_type) { in acpi_device_get_busid()
1121 strcpy(device->pnp.bus_id, "PWRF"); in acpi_device_get_busid()
1124 strcpy(device->pnp.bus_id, "SLPF"); in acpi_device_get_busid()
1127 strcpy(device->pnp.bus_id, "ECDT"); in acpi_device_get_busid()
1130 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer); in acpi_device_get_busid()
1132 for (i = 3; i > 1; i--) { in acpi_device_get_busid()
1138 strcpy(device->pnp.bus_id, bus_id); in acpi_device_get_busid()
1144 * acpi_ata_match - see if an acpi object is an ATA device
1147 * then we can safely call it an ATA device.
1149 bool acpi_ata_match(acpi_handle handle) in acpi_ata_match() argument
1151 return acpi_has_method(handle, "_GTF") || in acpi_ata_match()
1152 acpi_has_method(handle, "_GTM") || in acpi_ata_match()
1153 acpi_has_method(handle, "_STM") || in acpi_ata_match()
1154 acpi_has_method(handle, "_SDD"); in acpi_ata_match()
1158 * acpi_bay_match - see if an acpi object is an ejectable driver bay
1163 bool acpi_bay_match(acpi_handle handle) in acpi_bay_match() argument
1167 if (!acpi_has_method(handle, "_EJ0")) in acpi_bay_match()
1169 if (acpi_ata_match(handle)) in acpi_bay_match()
1171 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle))) in acpi_bay_match()
1181 list_for_each_entry(hwid, &adev->pnp.ids, list) in acpi_device_is_battery()
1182 if (!strcmp("PNP0C0A", hwid->id)) in acpi_device_is_battery()
1190 acpi_handle handle = adev->handle; in is_ejectable_bay() local
1192 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev)) in is_ejectable_bay()
1195 return acpi_bay_match(handle); in is_ejectable_bay()
1199 * acpi_dock_match - see if an acpi object has a _DCK method
1201 bool acpi_dock_match(acpi_handle handle) in acpi_dock_match() argument
1203 return acpi_has_method(handle, "_DCK"); in acpi_dock_match()
1207 acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, in acpi_backlight_cap_match() argument
1212 if (acpi_has_method(handle, "_BCM") && in acpi_backlight_cap_match()
1213 acpi_has_method(handle, "_BCL")) { in acpi_backlight_cap_match()
1214 acpi_handle_debug(handle, "Found generic backlight support\n"); in acpi_backlight_cap_match()
1222 /* Returns true if the ACPI object is a video device which can be
1224 * The device will get a Linux specific CID added in scan.c to
1225 * identify the device as an ACPI graphics device
1226 * Be aware that the graphics device may not be physically present
1230 long acpi_is_video_device(acpi_handle handle) in acpi_is_video_device() argument
1234 /* Is this device able to support video switching ? */ in acpi_is_video_device()
1235 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS")) in acpi_is_video_device()
1238 /* Is this device able to retrieve a video ROM ? */ in acpi_is_video_device()
1239 if (acpi_has_method(handle, "_ROM")) in acpi_is_video_device()
1242 /* Is this device able to configure which video head to be POSTed ? */ in acpi_is_video_device()
1243 if (acpi_has_method(handle, "_VPO") && in acpi_is_video_device()
1244 acpi_has_method(handle, "_GPD") && in acpi_is_video_device()
1245 acpi_has_method(handle, "_SPD")) in acpi_is_video_device()
1250 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, in acpi_is_video_device()
1258 const char *acpi_device_hid(struct acpi_device *device) in acpi_device_hid() argument
1262 if (list_empty(&device->pnp.ids)) in acpi_device_hid()
1265 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list); in acpi_device_hid()
1266 return hid->id; in acpi_device_hid()
1278 id->id = kstrdup_const(dev_id, GFP_KERNEL); in acpi_add_id()
1279 if (!id->id) { in acpi_add_id()
1284 list_add_tail(&id->list, &pnp->ids); in acpi_add_id()
1285 pnp->type.hardware_id = 1; in acpi_add_id()
1293 static bool acpi_ibm_smbus_match(acpi_handle handle) in acpi_ibm_smbus_match() argument
1302 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) || in acpi_ibm_smbus_match()
1307 if (acpi_has_method(handle, "SBI") && in acpi_ibm_smbus_match()
1308 acpi_has_method(handle, "SBR") && in acpi_ibm_smbus_match()
1309 acpi_has_method(handle, "SBW")) in acpi_ibm_smbus_match()
1315 static bool acpi_object_is_system_bus(acpi_handle handle) in acpi_object_is_system_bus() argument
1320 tmp == handle) in acpi_object_is_system_bus()
1323 tmp == handle) in acpi_object_is_system_bus()
1329 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp, in acpi_set_pnp_ids() argument
1338 if (handle == ACPI_ROOT_OBJECT) { in acpi_set_pnp_ids()
1343 acpi_get_object_info(handle, &info); in acpi_set_pnp_ids()
1345 pr_err("%s: Error reading device info\n", __func__); in acpi_set_pnp_ids()
1349 if (info->valid & ACPI_VALID_HID) { in acpi_set_pnp_ids()
1350 acpi_add_id(pnp, info->hardware_id.string); in acpi_set_pnp_ids()
1351 pnp->type.platform_id = 1; in acpi_set_pnp_ids()
1353 if (info->valid & ACPI_VALID_CID) { in acpi_set_pnp_ids()
1354 cid_list = &info->compatible_id_list; in acpi_set_pnp_ids()
1355 for (i = 0; i < cid_list->count; i++) in acpi_set_pnp_ids()
1356 acpi_add_id(pnp, cid_list->ids[i].string); in acpi_set_pnp_ids()
1358 if (info->valid & ACPI_VALID_ADR) { in acpi_set_pnp_ids()
1359 pnp->bus_address = info->address; in acpi_set_pnp_ids()
1360 pnp->type.bus_address = 1; in acpi_set_pnp_ids()
1362 if (info->valid & ACPI_VALID_UID) in acpi_set_pnp_ids()
1363 pnp->unique_id = kstrdup(info->unique_id.string, in acpi_set_pnp_ids()
1365 if (info->valid & ACPI_VALID_CLS) in acpi_set_pnp_ids()
1366 acpi_add_id(pnp, info->class_code.string); in acpi_set_pnp_ids()
1374 if (acpi_is_video_device(handle)) { in acpi_set_pnp_ids()
1376 pnp->type.backlight = 1; in acpi_set_pnp_ids()
1379 if (acpi_bay_match(handle)) in acpi_set_pnp_ids()
1381 else if (acpi_dock_match(handle)) in acpi_set_pnp_ids()
1383 else if (acpi_ibm_smbus_match(handle)) in acpi_set_pnp_ids()
1385 else if (list_empty(&pnp->ids) && in acpi_set_pnp_ids()
1386 acpi_object_is_system_bus(handle)) { in acpi_set_pnp_ids()
1389 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME); in acpi_set_pnp_ids()
1390 strcpy(pnp->device_class, ACPI_BUS_CLASS); in acpi_set_pnp_ids()
1419 list_for_each_entry_safe(id, tmp, &pnp->ids, list) { in acpi_free_pnp_ids()
1420 kfree_const(id->id); in acpi_free_pnp_ids()
1423 kfree(pnp->unique_id); in acpi_free_pnp_ids()
1427 * acpi_dma_supported - Check DMA support for the specified device.
1428 * @adev: The pointer to acpi device
1437 if (adev->flags.cca_seen) in acpi_dma_supported()
1441 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent in acpi_dma_supported()
1452 * acpi_get_dma_attr - Check the supported DMA attr for the specified device.
1453 * @adev: The pointer to acpi device
1462 if (adev->flags.coherent_dma) in acpi_get_dma_attr()
1469 * acpi_dma_get_range() - Get device DMA parameters.
1471 * @dev: device to configure
1479 int acpi_dma_get_range(struct device *dev, const struct bus_dma_region **map) in acpi_dma_get_range()
1485 struct device *dma_dev = dev; in acpi_dma_get_range()
1489 * Walk the device tree chasing an ACPI companion with a _DMA in acpi_dma_get_range()
1490 * object while we go. Stop if we find a device with an ACPI in acpi_dma_get_range()
1495 if (adev && acpi_has_method(adev->handle, METHOD_NAME__DMA)) in acpi_dma_get_range()
1498 dma_dev = dma_dev->parent; in acpi_dma_get_range()
1502 return -ENODEV; in acpi_dma_get_range()
1504 if (!acpi_has_method(adev->handle, METHOD_NAME__CRS)) { in acpi_dma_get_range()
1505 acpi_handle_warn(adev->handle, "_DMA is valid only if _CRS is present\n"); in acpi_dma_get_range()
1506 return -EINVAL; in acpi_dma_get_range()
1513 ret = -ENOMEM; in acpi_dma_get_range()
1520 if (rentry->res->start >= rentry->res->end) { in acpi_dma_get_range()
1523 ret = -EINVAL; in acpi_dma_get_range()
1528 r->cpu_start = rentry->res->start; in acpi_dma_get_range()
1529 r->dma_start = rentry->res->start - rentry->offset; in acpi_dma_get_range()
1530 r->size = resource_size(rentry->res); in acpi_dma_get_range()
1531 r->offset = rentry->offset; in acpi_dma_get_range()
1542 int acpi_iommu_fwspec_init(struct device *dev, u32 id, in acpi_iommu_fwspec_init()
1554 static inline const struct iommu_ops *acpi_iommu_fwspec_ops(struct device *dev) in acpi_iommu_fwspec_ops()
1558 return fwspec ? fwspec->ops : NULL; in acpi_iommu_fwspec_ops()
1561 static const struct iommu_ops *acpi_iommu_configure_id(struct device *dev, in acpi_iommu_configure_id()
1567 /* Serialise to make dev->iommu stable under our potential fwspec */ in acpi_iommu_configure_id()
1580 if (err && err != -EPROBE_DEFER) in acpi_iommu_configure_id()
1588 if (!err && dev->bus) in acpi_iommu_configure_id()
1592 if (err == -EPROBE_DEFER) { in acpi_iommu_configure_id()
1603 int acpi_iommu_fwspec_init(struct device *dev, u32 id, in acpi_iommu_fwspec_init()
1607 return -ENODEV; in acpi_iommu_fwspec_init()
1610 static const struct iommu_ops *acpi_iommu_configure_id(struct device *dev, in acpi_iommu_configure_id()
1619 * acpi_dma_configure_id - Set-up DMA configuration for the device.
1620 * @dev: The pointer to the device
1621 * @attr: device dma attributes
1622 * @input_id: input device id const value pointer
1624 int acpi_dma_configure_id(struct device *dev, enum dev_dma_attr attr, in acpi_dma_configure_id()
1637 if (PTR_ERR(iommu) == -EPROBE_DEFER) in acpi_dma_configure_id()
1638 return -EPROBE_DEFER; in acpi_dma_configure_id()
1653 if (parent && parent->flags.cca_seen) { in acpi_init_coherency()
1658 adev->flags.cca_seen = 1; in acpi_init_coherency()
1659 cca = parent->flags.coherent_dma; in acpi_init_coherency()
1661 status = acpi_evaluate_integer(adev->handle, "_CCA", in acpi_init_coherency()
1664 adev->flags.cca_seen = 1; in acpi_init_coherency()
1668 * required for DMA-able devices (e.g. x86), in acpi_init_coherency()
1673 acpi_handle_debug(adev->handle, in acpi_init_coherency()
1674 "ACPI device is missing _CCA.\n"); in acpi_init_coherency()
1677 adev->flags.coherent_dma = cca; in acpi_init_coherency()
1684 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) in acpi_check_serial_bus_slave()
1690 return -1; in acpi_check_serial_bus_slave()
1693 static bool acpi_is_indirect_io_slave(struct acpi_device *device) in acpi_is_indirect_io_slave() argument
1695 struct acpi_device *parent = acpi_dev_parent(device); in acpi_is_indirect_io_slave()
1704 static bool acpi_device_enumeration_by_parent(struct acpi_device *device) in acpi_device_enumeration_by_parent() argument
1711 * device must be instantiated for each of them, each with in acpi_device_enumeration_by_parent()
1712 * its own device id. in acpi_device_enumeration_by_parent()
1713 * Normally we only instantiate one client device for the first in acpi_device_enumeration_by_parent()
1715 * by the drivers/platform/x86/serial-multi-instantiate.c driver, which in acpi_device_enumeration_by_parent()
1716 * knows which client device id to use for each resource. in acpi_device_enumeration_by_parent()
1724 /* Non-conforming _HID for Cirrus Logic already released */ in acpi_device_enumeration_by_parent()
1733 * HIDs of device with an UartSerialBusV2 resource for which userspace in acpi_device_enumeration_by_parent()
1736 * such as the rfkill-gpio driver. in acpi_device_enumeration_by_parent()
1743 if (acpi_is_indirect_io_slave(device)) in acpi_device_enumeration_by_parent()
1746 /* Macs use device properties in lieu of _CRS resources */ in acpi_device_enumeration_by_parent()
1748 (fwnode_property_present(&device->fwnode, "spiSclkPeriod") || in acpi_device_enumeration_by_parent()
1749 fwnode_property_present(&device->fwnode, "i2cAddress") || in acpi_device_enumeration_by_parent()
1750 fwnode_property_present(&device->fwnode, "baud"))) in acpi_device_enumeration_by_parent()
1753 if (!acpi_match_device_ids(device, ignore_serial_bus_ids)) in acpi_device_enumeration_by_parent()
1757 acpi_dev_get_resources(device, &resource_list, in acpi_device_enumeration_by_parent()
1765 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle, in acpi_init_device_object() argument
1766 int type, void (*release)(struct device *)) in acpi_init_device_object() argument
1768 struct acpi_device *parent = acpi_find_parent_acpi_dev(handle); in acpi_init_device_object()
1770 INIT_LIST_HEAD(&device->pnp.ids); in acpi_init_device_object()
1771 device->device_type = type; in acpi_init_device_object()
1772 device->handle = handle; in acpi_init_device_object()
1773 device->dev.parent = parent ? &parent->dev : NULL; in acpi_init_device_object()
1774 device->dev.release = release; in acpi_init_device_object()
1775 device->dev.bus = &acpi_bus_type; in acpi_init_device_object()
1776 fwnode_init(&device->fwnode, &acpi_device_fwnode_ops); in acpi_init_device_object()
1777 acpi_set_device_status(device, ACPI_STA_DEFAULT); in acpi_init_device_object()
1778 acpi_device_get_busid(device); in acpi_init_device_object()
1779 acpi_set_pnp_ids(handle, &device->pnp, type); in acpi_init_device_object()
1780 acpi_init_properties(device); in acpi_init_device_object()
1781 acpi_bus_get_flags(device); in acpi_init_device_object()
1782 device->flags.match_driver = false; in acpi_init_device_object()
1783 device->flags.initialized = true; in acpi_init_device_object()
1784 device->flags.enumeration_by_parent = in acpi_init_device_object()
1785 acpi_device_enumeration_by_parent(device); in acpi_init_device_object()
1786 acpi_device_clear_enumerated(device); in acpi_init_device_object()
1787 device_initialize(&device->dev); in acpi_init_device_object()
1788 dev_set_uevent_suppress(&device->dev, true); in acpi_init_device_object()
1789 acpi_init_coherency(device); in acpi_init_device_object()
1797 if (dep->consumer == adev->handle) { in acpi_scan_dep_init()
1798 if (dep->honor_dep) in acpi_scan_dep_init()
1799 adev->flags.honor_deps = 1; in acpi_scan_dep_init()
1801 if (!dep->met) in acpi_scan_dep_init()
1802 adev->dep_unmet++; in acpi_scan_dep_init()
1807 void acpi_device_add_finalize(struct acpi_device *device) in acpi_device_add_finalize() argument
1809 dev_set_uevent_suppress(&device->dev, false); in acpi_device_add_finalize()
1810 kobject_uevent(&device->dev.kobj, KOBJ_ADD); in acpi_device_add_finalize()
1820 acpi_handle handle, int type, bool dep_init) in acpi_add_single_object() argument
1822 struct acpi_device *device; in acpi_add_single_object() local
1826 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL); in acpi_add_single_object()
1827 if (!device) in acpi_add_single_object()
1828 return -ENOMEM; in acpi_add_single_object()
1830 acpi_init_device_object(device, handle, type, acpi_device_release); in acpi_add_single_object()
1834 * this must be done before the get power-/wakeup_dev-flags calls. in acpi_add_single_object()
1843 * updating dep_unmet for the device. in acpi_add_single_object()
1846 acpi_scan_dep_init(device); in acpi_add_single_object()
1848 acpi_scan_init_status(device); in acpi_add_single_object()
1851 acpi_bus_get_power_flags(device); in acpi_add_single_object()
1852 acpi_bus_get_wakeup_device_flags(device); in acpi_add_single_object()
1854 result = acpi_tie_acpi_dev(device); in acpi_add_single_object()
1860 result = acpi_device_add(device); in acpi_add_single_object()
1863 acpi_device_release(&device->dev); in acpi_add_single_object()
1867 acpi_power_add_remove_device(device, true); in acpi_add_single_object()
1868 acpi_device_add_finalize(device); in acpi_add_single_object()
1870 acpi_handle_debug(handle, "Added as %s, parent %s\n", in acpi_add_single_object()
1871 dev_name(&device->dev), device->dev.parent ? in acpi_add_single_object()
1872 dev_name(device->dev.parent) : "(null)"); in acpi_add_single_object()
1874 *child = device; in acpi_add_single_object()
1889 static bool acpi_device_should_be_hidden(acpi_handle handle) in acpi_device_should_be_hidden() argument
1894 /* Check if it should ignore the UART device */ in acpi_device_should_be_hidden()
1895 if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS))) in acpi_device_should_be_hidden()
1899 * The UART device described in SPCR table is assumed to have only one in acpi_device_should_be_hidden()
1902 status = acpi_walk_resources(handle, METHOD_NAME__CRS, in acpi_device_should_be_hidden()
1907 acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n", in acpi_device_should_be_hidden()
1915 return adev->status.present || adev->status.functional; in acpi_device_is_present()
1924 if (handler->match) in acpi_scan_handler_matching()
1925 return handler->match(idstr, matchid); in acpi_scan_handler_matching()
1927 for (devid = handler->ids; devid->id[0]; devid++) in acpi_scan_handler_matching()
1928 if (!strcmp((char *)devid->id, idstr)) { in acpi_scan_handler_matching()
1952 if (!!hotplug->enabled == !!val) in acpi_scan_hotplug_enabled()
1957 hotplug->enabled = val; in acpi_scan_hotplug_enabled()
1966 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) { in acpi_scan_init_hotplug()
1970 list_for_each_entry(hwid, &adev->pnp.ids, list) { in acpi_scan_init_hotplug()
1973 handler = acpi_scan_match_handler(hwid->id, NULL); in acpi_scan_init_hotplug()
1975 adev->flags.hotplug_notify = true; in acpi_scan_init_hotplug()
1981 static u32 acpi_scan_check_dep(acpi_handle handle, bool check_dep) in acpi_scan_check_dep() argument
1994 if (!check_dep || !acpi_has_method(handle, "_DEP") || in acpi_scan_check_dep()
1995 !acpi_has_method(handle, "_HID")) in acpi_scan_check_dep()
1998 status = acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices); in acpi_scan_check_dep()
2000 acpi_handle_debug(handle, "Failed to evaluate _DEP.\n"); in acpi_scan_check_dep()
2011 acpi_handle_debug(handle, "Error reading _DEP device info\n"); in acpi_scan_check_dep()
2028 dep->supplier = dep_devices.handles[i]; in acpi_scan_check_dep()
2029 dep->consumer = handle; in acpi_scan_check_dep()
2030 dep->honor_dep = honor_dep; in acpi_scan_check_dep()
2033 list_add_tail(&dep->node , &acpi_dep_list); in acpi_scan_check_dep()
2040 static acpi_status acpi_bus_check_add(acpi_handle handle, bool check_dep, in acpi_bus_check_add() argument
2043 struct acpi_device *device = acpi_fetch_acpi_dev(handle); in acpi_bus_check_add() local
2047 if (device) in acpi_bus_check_add()
2050 if (ACPI_FAILURE(acpi_get_type(handle, &acpi_type))) in acpi_bus_check_add()
2055 if (acpi_device_should_be_hidden(handle)) in acpi_bus_check_add()
2059 if (acpi_scan_check_dep(handle, check_dep) > 0) in acpi_bus_check_add()
2076 acpi_add_power_resource(handle); in acpi_bus_check_add()
2083 * If check_dep is true at this point, the device has no dependencies, in acpi_bus_check_add()
2084 * or the creation of the device object would have been postponed above. in acpi_bus_check_add()
2086 acpi_add_single_object(&device, handle, type, !check_dep); in acpi_bus_check_add()
2087 if (!device) in acpi_bus_check_add()
2090 acpi_scan_init_hotplug(device); in acpi_bus_check_add()
2094 *adev_p = device; in acpi_bus_check_add()
2099 static acpi_status acpi_bus_check_add_1(acpi_handle handle, u32 lvl_not_used, in acpi_bus_check_add_1() argument
2102 return acpi_bus_check_add(handle, true, (struct acpi_device **)ret_p); in acpi_bus_check_add_1()
2105 static acpi_status acpi_bus_check_add_2(acpi_handle handle, u32 lvl_not_used, in acpi_bus_check_add_2() argument
2108 return acpi_bus_check_add(handle, false, (struct acpi_device **)ret_p); in acpi_bus_check_add_2()
2111 static void acpi_default_enumeration(struct acpi_device *device) in acpi_default_enumeration() argument
2117 if (!device->flags.enumeration_by_parent) { in acpi_default_enumeration()
2118 acpi_create_platform_device(device, NULL); in acpi_default_enumeration()
2119 acpi_device_set_enumerated(device); in acpi_default_enumeration()
2122 ACPI_RECONFIG_DEVICE_ADD, device); in acpi_default_enumeration()
2138 if (adev->data.of_compatible) in acpi_generic_device_attach()
2149 static int acpi_scan_attach_handler(struct acpi_device *device) in acpi_scan_attach_handler() argument
2154 list_for_each_entry(hwid, &device->pnp.ids, list) { in acpi_scan_attach_handler()
2158 handler = acpi_scan_match_handler(hwid->id, &devid); in acpi_scan_attach_handler()
2160 if (!handler->attach) { in acpi_scan_attach_handler()
2161 device->pnp.type.platform_id = 0; in acpi_scan_attach_handler()
2164 device->handler = handler; in acpi_scan_attach_handler()
2165 ret = handler->attach(device, devid); in acpi_scan_attach_handler()
2169 device->handler = NULL; in acpi_scan_attach_handler()
2178 static int acpi_bus_attach(struct acpi_device *device, void *first_pass) in acpi_bus_attach() argument
2180 bool skip = !first_pass && device->flags.visited; in acpi_bus_attach()
2187 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd))) in acpi_bus_attach()
2188 register_dock_dependent_device(device, ejd); in acpi_bus_attach()
2190 acpi_bus_get_status(device); in acpi_bus_attach()
2192 if (!acpi_dev_ready_for_enumeration(device)) { in acpi_bus_attach()
2193 device->flags.initialized = false; in acpi_bus_attach()
2194 acpi_device_clear_enumerated(device); in acpi_bus_attach()
2195 device->flags.power_manageable = 0; in acpi_bus_attach()
2198 if (device->handler) in acpi_bus_attach()
2201 acpi_ec_register_opregions(device); in acpi_bus_attach()
2203 if (!device->flags.initialized) { in acpi_bus_attach()
2204 device->flags.power_manageable = in acpi_bus_attach()
2205 device->power.states[ACPI_STATE_D0].flags.valid; in acpi_bus_attach()
2206 if (acpi_bus_init_power(device)) in acpi_bus_attach()
2207 device->flags.power_manageable = 0; in acpi_bus_attach()
2209 device->flags.initialized = true; in acpi_bus_attach()
2210 } else if (device->flags.visited) { in acpi_bus_attach()
2214 ret = acpi_scan_attach_handler(device); in acpi_bus_attach()
2218 device->flags.match_driver = true; in acpi_bus_attach()
2219 if (ret > 0 && !device->flags.enumeration_by_parent) { in acpi_bus_attach()
2220 acpi_device_set_enumerated(device); in acpi_bus_attach()
2224 ret = device_attach(&device->dev); in acpi_bus_attach()
2228 if (device->pnp.type.platform_id || device->flags.enumeration_by_parent) in acpi_bus_attach()
2229 acpi_default_enumeration(device); in acpi_bus_attach()
2231 acpi_device_set_enumerated(device); in acpi_bus_attach()
2234 acpi_dev_for_each_child(device, acpi_bus_attach, first_pass); in acpi_bus_attach()
2236 if (!skip && device->handler && device->handler->hotplug.notify_online) in acpi_bus_attach()
2237 device->handler->hotplug.notify_online(device); in acpi_bus_attach()
2248 * If we're passed a 'previous' consumer device then we need to skip in acpi_dev_get_next_consumer_dev_cb()
2253 if (dep->consumer == adev->handle) in acpi_dev_get_next_consumer_dev_cb()
2259 adev = acpi_get_acpi_dev(dep->consumer); in acpi_dev_get_next_consumer_dev_cb()
2264 /* Continue parsing if the device object is not present. */ in acpi_dev_get_next_consumer_dev_cb()
2280 acpi_bus_attach(cdw->adev, (void *)true); in acpi_scan_clear_dep_fn()
2283 acpi_dev_put(cdw->adev); in acpi_scan_clear_dep_fn()
2291 if (adev->dep_unmet) in acpi_scan_clear_dep_queue()
2298 cdw->adev = adev; in acpi_scan_clear_dep_queue()
2299 INIT_WORK(&cdw->work, acpi_scan_clear_dep_fn); in acpi_scan_clear_dep_queue()
2305 queue_work(system_unbound_wq, &cdw->work); in acpi_scan_clear_dep_queue()
2312 list_del(&dep->node); in acpi_scan_delete_dep_data()
2318 struct acpi_device *adev = acpi_get_acpi_dev(dep->consumer); in acpi_scan_clear_dep()
2321 adev->dep_unmet--; in acpi_scan_clear_dep()
2326 if (dep->free_when_met) in acpi_scan_clear_dep()
2329 dep->met = true; in acpi_scan_clear_dep()
2335 * acpi_walk_dep_device_list - Apply a callback to every entry in acpi_dep_list
2336 * @handle: The ACPI handle of the supplier device
2346 static int acpi_walk_dep_device_list(acpi_handle handle, in acpi_walk_dep_device_list() argument
2355 if (dep->supplier == handle) { in acpi_walk_dep_device_list()
2367 * acpi_dev_clear_dependencies - Inform consumers that the device is now active
2370 * Clear dependencies on the given device.
2374 acpi_walk_dep_device_list(supplier->handle, acpi_scan_clear_dep, NULL); in acpi_dev_clear_dependencies()
2379 * acpi_dev_ready_for_enumeration - Check if the ACPI device is ready for enumeration
2380 * @device: Pointer to the &struct acpi_device to check
2382 * Check if the device is present and has no unmet dependencies.
2384 * Return true if the device is ready for enumeratino. Otherwise, return false.
2386 bool acpi_dev_ready_for_enumeration(const struct acpi_device *device) in acpi_dev_ready_for_enumeration() argument
2388 if (device->flags.honor_deps && device->dep_unmet) in acpi_dev_ready_for_enumeration()
2391 return acpi_device_is_present(device); in acpi_dev_ready_for_enumeration()
2396 * acpi_dev_get_next_consumer_dev - Return the next adev dependent on @supplier
2397 * @supplier: Pointer to the dependee device
2398 * @start: Pointer to the current dependent device
2411 acpi_walk_dep_device_list(supplier->handle, in acpi_dev_get_next_consumer_dev()
2423 static void acpi_scan_postponed_branch(acpi_handle handle) in acpi_scan_postponed_branch() argument
2427 if (ACPI_FAILURE(acpi_bus_check_add(handle, false, &adev))) in acpi_scan_postponed_branch()
2430 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, in acpi_scan_postponed_branch()
2442 acpi_handle handle = dep->consumer; in acpi_scan_postponed() local
2446 * same consumer, skip the current entry if the consumer device in acpi_scan_postponed()
2449 if (!acpi_fetch_acpi_dev(handle)) { in acpi_scan_postponed()
2458 acpi_scan_postponed_branch(handle); in acpi_scan_postponed()
2463 if (dep->met) in acpi_scan_postponed()
2466 dep->free_when_met = true; in acpi_scan_postponed()
2473 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2474 * @handle: Root of the namespace scope to scan.
2476 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
2479 * If no devices were found, -ENODEV is returned, but it does not mean that
2481 * in the table trunk from which the kernel could create a device and add an
2486 int acpi_bus_scan(acpi_handle handle) in acpi_bus_scan() argument
2488 struct acpi_device *device = NULL; in acpi_bus_scan() local
2492 if (ACPI_SUCCESS(acpi_bus_check_add(handle, true, &device))) in acpi_bus_scan()
2493 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, in acpi_bus_scan()
2495 (void **)&device); in acpi_bus_scan()
2497 if (!device) in acpi_bus_scan()
2498 return -ENODEV; in acpi_bus_scan()
2500 acpi_bus_attach(device, (void *)true); in acpi_bus_scan()
2512 struct acpi_scan_handler *handler = adev->handler; in acpi_bus_trim_one()
2516 adev->flags.match_driver = false; in acpi_bus_trim_one()
2518 if (handler->detach) in acpi_bus_trim_one()
2519 handler->detach(adev); in acpi_bus_trim_one()
2521 adev->handler = NULL; in acpi_bus_trim_one()
2523 device_release_driver(&adev->dev); in acpi_bus_trim_one()
2526 * Most likely, the device is going away, so put it into D3cold before in acpi_bus_trim_one()
2530 adev->flags.initialized = false; in acpi_bus_trim_one()
2537 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
2550 struct acpi_device *device = NULL; in acpi_bus_register_early_device() local
2553 result = acpi_add_single_object(&device, NULL, type, false); in acpi_bus_register_early_device()
2557 device->flags.match_driver = true; in acpi_bus_register_early_device()
2558 return device_attach(&device->dev); in acpi_bus_register_early_device()
2570 adev->flags.match_driver = true; in acpi_bus_scan_fixed()
2571 if (device_attach(&adev->dev) >= 0) in acpi_bus_scan_fixed()
2572 device_init_wakeup(&adev->dev, true); in acpi_bus_scan_fixed()
2574 dev_dbg(&adev->dev, "No driver\n"); in acpi_bus_scan_fixed()
2584 adev->flags.match_driver = true; in acpi_bus_scan_fixed()
2585 if (device_attach(&adev->dev) < 0) in acpi_bus_scan_fixed()
2586 dev_dbg(&adev->dev, "No driver\n"); in acpi_bus_scan_fixed()
2603 spcr_uart_addr = spcr_ptr->serial_port.address; in acpi_get_spcr_uart_addr()
2632 * device in SPCR table. in acpi_scan_init()
2637 if (stao_ptr->header.length > sizeof(struct acpi_table_stao)) in acpi_scan_init()
2640 if (stao_ptr->ignore_uart) in acpi_scan_init()
2666 /* Fixed feature devices do not exist on HW-reduced platform */ in acpi_scan_init()
2685 if (!ape->subtable_valid || ape->subtable_valid(&header->common, ape)) in acpi_match_madt()
2686 if (!ape->probe_subtbl(header, end)) in acpi_match_madt()
2700 for (ape = ap_head; nr; ape++, nr--) { in __acpi_probe_device_table()
2701 if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT, ape->id)) { in __acpi_probe_device_table()
2703 acpi_table_parse_madt(ape->type, acpi_match_madt, 0); in __acpi_probe_device_table()
2707 res = acpi_table_parse(ape->id, ape->probe_table); in __acpi_probe_device_table()