2 * scan.c - support for transforming the ACPI namespace into individual objects
5 #include <linux/module.h>
6 #include <linux/init.h>
7 #include <linux/slab.h>
8 #include <linux/kernel.h>
9 #include <linux/acpi.h>
10 #include <linux/signal.h>
11 #include <linux/kthread.h>
12 #include <linux/dmi.h>
13 #include <linux/nls.h>
15 #include <asm/pgtable.h>
19 #define _COMPONENT ACPI_BUS_COMPONENT
20 ACPI_MODULE_NAME("scan");
21 extern struct acpi_device *acpi_root;
23 #define ACPI_BUS_CLASS "system_bus"
24 #define ACPI_BUS_HID "LNXSYBUS"
25 #define ACPI_BUS_DEVICE_NAME "System Bus"
27 #define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent)
29 #define INVALID_ACPI_HANDLE ((acpi_handle)empty_zero_page)
32 * If set, devices will be hot-removed even if they cannot be put offline
33 * gracefully (from the kernel's standpoint).
35 bool acpi_force_hot_remove;
37 static const char *dummy_hid = "device";
39 static LIST_HEAD(acpi_dep_list);
40 static DEFINE_MUTEX(acpi_dep_list_lock);
41 static LIST_HEAD(acpi_bus_id_list);
42 static DEFINE_MUTEX(acpi_scan_lock);
43 static LIST_HEAD(acpi_scan_handlers_list);
44 DEFINE_MUTEX(acpi_device_lock);
45 LIST_HEAD(acpi_wakeup_device_list);
46 static DEFINE_MUTEX(acpi_hp_context_lock);
48 struct acpi_dep_data {
49 struct list_head node;
54 struct acpi_device_bus_id{
56 unsigned int instance_no;
57 struct list_head node;
60 void acpi_scan_lock_acquire(void)
62 mutex_lock(&acpi_scan_lock);
64 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
66 void acpi_scan_lock_release(void)
68 mutex_unlock(&acpi_scan_lock);
70 EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
72 void acpi_lock_hp_context(void)
74 mutex_lock(&acpi_hp_context_lock);
77 void acpi_unlock_hp_context(void)
79 mutex_unlock(&acpi_hp_context_lock);
82 void acpi_initialize_hp_context(struct acpi_device *adev,
83 struct acpi_hotplug_context *hp,
84 int (*notify)(struct acpi_device *, u32),
85 void (*uevent)(struct acpi_device *, u32))
87 acpi_lock_hp_context();
90 acpi_set_hp_context(adev, hp);
91 acpi_unlock_hp_context();
93 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
95 int acpi_scan_add_handler(struct acpi_scan_handler *handler)
100 list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
104 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
105 const char *hotplug_profile_name)
109 error = acpi_scan_add_handler(handler);
113 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
118 * Creates hid/cid(s) string needed for modalias and uevent
119 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
120 * char *modalias: "acpi:IBM0001:ACPI0001"
121 * Return: 0: no _HID and no _CID
122 * -EINVAL: output error
123 * -ENOMEM: output is truncated
125 static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
130 struct acpi_hardware_id *id;
132 if (list_empty(&acpi_dev->pnp.ids))
135 len = snprintf(modalias, size, "acpi:");
138 list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
139 count = snprintf(&modalias[len], size, "%s:", id->id);
148 modalias[len] = '\0';
153 * acpi_companion_match() - Can we match via ACPI companion device
154 * @dev: Device in question
156 * Check if the given device has an ACPI companion and if that companion has
157 * a valid list of PNP IDs, and if the device is the first (primary) physical
158 * device associated with it.
160 * If multiple physical devices are attached to a single ACPI companion, we need
161 * to be careful. The usage scenario for this kind of relationship is that all
162 * of the physical devices in question use resources provided by the ACPI
163 * companion. A typical case is an MFD device where all the sub-devices share
164 * the parent's ACPI companion. In such cases we can only allow the primary
165 * (first) physical device to be matched with the help of the companion's PNP
168 * Additional physical devices sharing the ACPI companion can still use
169 * resources available from it but they will be matched normally using functions
170 * provided by their bus types (and analogously for their modalias).
172 static bool acpi_companion_match(const struct device *dev)
174 struct acpi_device *adev;
177 adev = ACPI_COMPANION(dev);
181 if (list_empty(&adev->pnp.ids))
184 mutex_lock(&adev->physical_node_lock);
185 if (list_empty(&adev->physical_node_list)) {
188 const struct acpi_device_physical_node *node;
190 node = list_first_entry(&adev->physical_node_list,
191 struct acpi_device_physical_node, node);
192 ret = node->dev == dev;
194 mutex_unlock(&adev->physical_node_lock);
200 * Creates uevent modalias field for ACPI enumerated devices.
201 * Because the other buses does not support ACPI HIDs & CIDs.
202 * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
203 * "acpi:IBM0001:ACPI0001"
205 int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
209 if (!acpi_companion_match(dev))
212 if (add_uevent_var(env, "MODALIAS="))
214 len = create_modalias(ACPI_COMPANION(dev), &env->buf[env->buflen - 1],
215 sizeof(env->buf) - env->buflen);
221 EXPORT_SYMBOL_GPL(acpi_device_uevent_modalias);
224 * Creates modalias sysfs attribute for ACPI enumerated devices.
225 * Because the other buses does not support ACPI HIDs & CIDs.
226 * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
227 * "acpi:IBM0001:ACPI0001"
229 int acpi_device_modalias(struct device *dev, char *buf, int size)
233 if (!acpi_companion_match(dev))
236 len = create_modalias(ACPI_COMPANION(dev), buf, size -1);
242 EXPORT_SYMBOL_GPL(acpi_device_modalias);
245 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
246 struct acpi_device *acpi_dev = to_acpi_device(dev);
249 len = create_modalias(acpi_dev, buf, 1024);
255 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
257 bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
259 struct acpi_device_physical_node *pn;
262 mutex_lock(&adev->physical_node_lock);
264 list_for_each_entry(pn, &adev->physical_node_list, node)
265 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
267 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);
273 mutex_unlock(&adev->physical_node_lock);
277 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
280 struct acpi_device *device = NULL;
281 struct acpi_device_physical_node *pn;
282 bool second_pass = (bool)data;
283 acpi_status status = AE_OK;
285 if (acpi_bus_get_device(handle, &device))
288 if (device->handler && !device->handler->hotplug.enabled) {
289 *ret_p = &device->dev;
293 mutex_lock(&device->physical_node_lock);
295 list_for_each_entry(pn, &device->physical_node_list, node) {
299 /* Skip devices offlined by the first pass. */
303 pn->put_online = false;
305 ret = device_offline(pn->dev);
306 if (acpi_force_hot_remove)
310 pn->put_online = !ret;
320 mutex_unlock(&device->physical_node_lock);
325 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
328 struct acpi_device *device = NULL;
329 struct acpi_device_physical_node *pn;
331 if (acpi_bus_get_device(handle, &device))
334 mutex_lock(&device->physical_node_lock);
336 list_for_each_entry(pn, &device->physical_node_list, node)
337 if (pn->put_online) {
338 device_online(pn->dev);
339 pn->put_online = false;
342 mutex_unlock(&device->physical_node_lock);
347 static int acpi_scan_try_to_offline(struct acpi_device *device)
349 acpi_handle handle = device->handle;
350 struct device *errdev = NULL;
354 * Carry out two passes here and ignore errors in the first pass,
355 * because if the devices in question are memory blocks and
356 * CONFIG_MEMCG is set, one of the blocks may hold data structures
357 * that the other blocks depend on, but it is not known in advance which
360 * If the first pass is successful, the second one isn't needed, though.
362 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
363 NULL, acpi_bus_offline, (void *)false,
365 if (status == AE_SUPPORT) {
366 dev_warn(errdev, "Offline disabled.\n");
367 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
368 acpi_bus_online, NULL, NULL, NULL);
371 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
374 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
375 NULL, acpi_bus_offline, (void *)true,
377 if (!errdev || acpi_force_hot_remove)
378 acpi_bus_offline(handle, 0, (void *)true,
381 if (errdev && !acpi_force_hot_remove) {
382 dev_warn(errdev, "Offline failed.\n");
383 acpi_bus_online(handle, 0, NULL, NULL);
384 acpi_walk_namespace(ACPI_TYPE_ANY, handle,
385 ACPI_UINT32_MAX, acpi_bus_online,
393 static int acpi_scan_hot_remove(struct acpi_device *device)
395 acpi_handle handle = device->handle;
396 unsigned long long sta;
399 if (device->handler && device->handler->hotplug.demand_offline
400 && !acpi_force_hot_remove) {
401 if (!acpi_scan_is_offline(device, true))
404 int error = acpi_scan_try_to_offline(device);
409 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
410 "Hot-removing device %s...\n", dev_name(&device->dev)));
412 acpi_bus_trim(device);
414 acpi_evaluate_lck(handle, 0);
418 status = acpi_evaluate_ej0(handle);
419 if (status == AE_NOT_FOUND)
421 else if (ACPI_FAILURE(status))
425 * Verify if eject was indeed successful. If not, log an error
426 * message. No need to call _OST since _EJ0 call was made OK.
428 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
429 if (ACPI_FAILURE(status)) {
430 acpi_handle_warn(handle,
431 "Status check after eject failed (0x%x)\n", status);
432 } else if (sta & ACPI_STA_DEVICE_ENABLED) {
433 acpi_handle_warn(handle,
434 "Eject incomplete - status 0x%llx\n", sta);
440 static int acpi_scan_device_not_present(struct acpi_device *adev)
442 if (!acpi_device_enumerated(adev)) {
443 dev_warn(&adev->dev, "Still not present\n");
450 static int acpi_scan_device_check(struct acpi_device *adev)
454 acpi_bus_get_status(adev);
455 if (adev->status.present || adev->status.functional) {
457 * This function is only called for device objects for which
458 * matching scan handlers exist. The only situation in which
459 * the scan handler is not attached to this device object yet
460 * is when the device has just appeared (either it wasn't
461 * present at all before or it was removed and then added
465 dev_warn(&adev->dev, "Already enumerated\n");
468 error = acpi_bus_scan(adev->handle);
470 dev_warn(&adev->dev, "Namespace scan failure\n");
473 if (!adev->handler) {
474 dev_warn(&adev->dev, "Enumeration failure\n");
478 error = acpi_scan_device_not_present(adev);
483 static int acpi_scan_bus_check(struct acpi_device *adev)
485 struct acpi_scan_handler *handler = adev->handler;
486 struct acpi_device *child;
489 acpi_bus_get_status(adev);
490 if (!(adev->status.present || adev->status.functional)) {
491 acpi_scan_device_not_present(adev);
494 if (handler && handler->hotplug.scan_dependent)
495 return handler->hotplug.scan_dependent(adev);
497 error = acpi_bus_scan(adev->handle);
499 dev_warn(&adev->dev, "Namespace scan failure\n");
502 list_for_each_entry(child, &adev->children, node) {
503 error = acpi_scan_bus_check(child);
510 static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
513 case ACPI_NOTIFY_BUS_CHECK:
514 return acpi_scan_bus_check(adev);
515 case ACPI_NOTIFY_DEVICE_CHECK:
516 return acpi_scan_device_check(adev);
517 case ACPI_NOTIFY_EJECT_REQUEST:
518 case ACPI_OST_EC_OSPM_EJECT:
519 if (adev->handler && !adev->handler->hotplug.enabled) {
520 dev_info(&adev->dev, "Eject disabled\n");
523 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
524 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
525 return acpi_scan_hot_remove(adev);
530 void acpi_device_hotplug(struct acpi_device *adev, u32 src)
532 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
535 lock_device_hotplug();
536 mutex_lock(&acpi_scan_lock);
539 * The device object's ACPI handle cannot become invalid as long as we
540 * are holding acpi_scan_lock, but it might have become invalid before
541 * that lock was acquired.
543 if (adev->handle == INVALID_ACPI_HANDLE)
546 if (adev->flags.is_dock_station) {
547 error = dock_notify(adev, src);
548 } else if (adev->flags.hotplug_notify) {
549 error = acpi_generic_hotplug_event(adev, src);
550 if (error == -EPERM) {
551 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
555 int (*notify)(struct acpi_device *, u32);
557 acpi_lock_hp_context();
558 notify = adev->hp ? adev->hp->notify : NULL;
559 acpi_unlock_hp_context();
561 * There may be additional notify handlers for device objects
562 * without the .event() callback, so ignore them here.
565 error = notify(adev, src);
570 ost_code = ACPI_OST_SC_SUCCESS;
573 acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
576 acpi_bus_put_acpi_device(adev);
577 mutex_unlock(&acpi_scan_lock);
578 unlock_device_hotplug();
581 static ssize_t real_power_state_show(struct device *dev,
582 struct device_attribute *attr, char *buf)
584 struct acpi_device *adev = to_acpi_device(dev);
588 ret = acpi_device_get_power(adev, &state);
592 return sprintf(buf, "%s\n", acpi_power_state_string(state));
595 static DEVICE_ATTR(real_power_state, 0444, real_power_state_show, NULL);
597 static ssize_t power_state_show(struct device *dev,
598 struct device_attribute *attr, char *buf)
600 struct acpi_device *adev = to_acpi_device(dev);
602 return sprintf(buf, "%s\n", acpi_power_state_string(adev->power.state));
605 static DEVICE_ATTR(power_state, 0444, power_state_show, NULL);
608 acpi_eject_store(struct device *d, struct device_attribute *attr,
609 const char *buf, size_t count)
611 struct acpi_device *acpi_device = to_acpi_device(d);
612 acpi_object_type not_used;
615 if (!count || buf[0] != '1')
618 if ((!acpi_device->handler || !acpi_device->handler->hotplug.enabled)
619 && !acpi_device->driver)
622 status = acpi_get_type(acpi_device->handle, ¬_used);
623 if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
626 get_device(&acpi_device->dev);
627 status = acpi_hotplug_schedule(acpi_device, ACPI_OST_EC_OSPM_EJECT);
628 if (ACPI_SUCCESS(status))
631 put_device(&acpi_device->dev);
632 acpi_evaluate_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
633 ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
634 return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
637 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
640 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
641 struct acpi_device *acpi_dev = to_acpi_device(dev);
643 return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
645 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
647 static ssize_t acpi_device_uid_show(struct device *dev,
648 struct device_attribute *attr, char *buf)
650 struct acpi_device *acpi_dev = to_acpi_device(dev);
652 return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
654 static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
656 static ssize_t acpi_device_adr_show(struct device *dev,
657 struct device_attribute *attr, char *buf)
659 struct acpi_device *acpi_dev = to_acpi_device(dev);
661 return sprintf(buf, "0x%08x\n",
662 (unsigned int)(acpi_dev->pnp.bus_address));
664 static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
667 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
668 struct acpi_device *acpi_dev = to_acpi_device(dev);
669 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
672 result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
676 result = sprintf(buf, "%s\n", (char*)path.pointer);
681 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
683 /* sysfs file that shows description text from the ACPI _STR method */
684 static ssize_t description_show(struct device *dev,
685 struct device_attribute *attr,
687 struct acpi_device *acpi_dev = to_acpi_device(dev);
690 if (acpi_dev->pnp.str_obj == NULL)
694 * The _STR object contains a Unicode identifier for a device.
695 * We need to convert to utf-8 so it can be displayed.
697 result = utf16s_to_utf8s(
698 (wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
699 acpi_dev->pnp.str_obj->buffer.length,
700 UTF16_LITTLE_ENDIAN, buf,
703 buf[result++] = '\n';
707 static DEVICE_ATTR(description, 0444, description_show, NULL);
710 acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
712 struct acpi_device *acpi_dev = to_acpi_device(dev);
714 unsigned long long sun;
716 status = acpi_evaluate_integer(acpi_dev->handle, "_SUN", NULL, &sun);
717 if (ACPI_FAILURE(status))
720 return sprintf(buf, "%llu\n", sun);
722 static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
724 static ssize_t status_show(struct device *dev, struct device_attribute *attr,
726 struct acpi_device *acpi_dev = to_acpi_device(dev);
728 unsigned long long sta;
730 status = acpi_evaluate_integer(acpi_dev->handle, "_STA", NULL, &sta);
731 if (ACPI_FAILURE(status))
734 return sprintf(buf, "%llu\n", sta);
736 static DEVICE_ATTR_RO(status);
738 static int acpi_device_setup_files(struct acpi_device *dev)
740 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
745 * Devices gotten from FADT don't have a "path" attribute
748 result = device_create_file(&dev->dev, &dev_attr_path);
753 if (!list_empty(&dev->pnp.ids)) {
754 result = device_create_file(&dev->dev, &dev_attr_hid);
758 result = device_create_file(&dev->dev, &dev_attr_modalias);
764 * If device has _STR, 'description' file is created
766 if (acpi_has_method(dev->handle, "_STR")) {
767 status = acpi_evaluate_object(dev->handle, "_STR",
769 if (ACPI_FAILURE(status))
770 buffer.pointer = NULL;
771 dev->pnp.str_obj = buffer.pointer;
772 result = device_create_file(&dev->dev, &dev_attr_description);
777 if (dev->pnp.type.bus_address)
778 result = device_create_file(&dev->dev, &dev_attr_adr);
779 if (dev->pnp.unique_id)
780 result = device_create_file(&dev->dev, &dev_attr_uid);
782 if (acpi_has_method(dev->handle, "_SUN")) {
783 result = device_create_file(&dev->dev, &dev_attr_sun);
788 if (acpi_has_method(dev->handle, "_STA")) {
789 result = device_create_file(&dev->dev, &dev_attr_status);
795 * If device has _EJ0, 'eject' file is created that is used to trigger
796 * hot-removal function from userland.
798 if (acpi_has_method(dev->handle, "_EJ0")) {
799 result = device_create_file(&dev->dev, &dev_attr_eject);
804 if (dev->flags.power_manageable) {
805 result = device_create_file(&dev->dev, &dev_attr_power_state);
809 if (dev->power.flags.power_resources)
810 result = device_create_file(&dev->dev,
811 &dev_attr_real_power_state);
818 static void acpi_device_remove_files(struct acpi_device *dev)
820 if (dev->flags.power_manageable) {
821 device_remove_file(&dev->dev, &dev_attr_power_state);
822 if (dev->power.flags.power_resources)
823 device_remove_file(&dev->dev,
824 &dev_attr_real_power_state);
828 * If device has _STR, remove 'description' file
830 if (acpi_has_method(dev->handle, "_STR")) {
831 kfree(dev->pnp.str_obj);
832 device_remove_file(&dev->dev, &dev_attr_description);
835 * If device has _EJ0, remove 'eject' file.
837 if (acpi_has_method(dev->handle, "_EJ0"))
838 device_remove_file(&dev->dev, &dev_attr_eject);
840 if (acpi_has_method(dev->handle, "_SUN"))
841 device_remove_file(&dev->dev, &dev_attr_sun);
843 if (dev->pnp.unique_id)
844 device_remove_file(&dev->dev, &dev_attr_uid);
845 if (dev->pnp.type.bus_address)
846 device_remove_file(&dev->dev, &dev_attr_adr);
847 device_remove_file(&dev->dev, &dev_attr_modalias);
848 device_remove_file(&dev->dev, &dev_attr_hid);
849 if (acpi_has_method(dev->handle, "_STA"))
850 device_remove_file(&dev->dev, &dev_attr_status);
852 device_remove_file(&dev->dev, &dev_attr_path);
854 /* --------------------------------------------------------------------------
856 -------------------------------------------------------------------------- */
858 static const struct acpi_device_id *__acpi_match_device(
859 struct acpi_device *device, const struct acpi_device_id *ids)
861 const struct acpi_device_id *id;
862 struct acpi_hardware_id *hwid;
865 * If the device is not present, it is unnecessary to load device
868 if (!device->status.present)
871 for (id = ids; id->id[0]; id++)
872 list_for_each_entry(hwid, &device->pnp.ids, list)
873 if (!strcmp((char *) id->id, hwid->id))
880 * acpi_match_device - Match a struct device against a given list of ACPI IDs
881 * @ids: Array of struct acpi_device_id object to match against.
882 * @dev: The device structure to match.
884 * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
885 * object for that handle and use that object to match against a given list of
888 * Return a pointer to the first matching ID on success or %NULL on failure.
890 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
891 const struct device *dev)
893 struct acpi_device *adev;
894 acpi_handle handle = ACPI_HANDLE(dev);
896 if (!ids || !handle || acpi_bus_get_device(handle, &adev))
899 if (!acpi_companion_match(dev))
902 return __acpi_match_device(adev, ids);
904 EXPORT_SYMBOL_GPL(acpi_match_device);
906 int acpi_match_device_ids(struct acpi_device *device,
907 const struct acpi_device_id *ids)
909 return __acpi_match_device(device, ids) ? 0 : -ENOENT;
911 EXPORT_SYMBOL(acpi_match_device_ids);
913 static void acpi_free_power_resources_lists(struct acpi_device *device)
917 if (device->wakeup.flags.valid)
918 acpi_power_resources_list_free(&device->wakeup.resources);
920 if (!device->flags.power_manageable)
923 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
924 struct acpi_device_power_state *ps = &device->power.states[i];
925 acpi_power_resources_list_free(&ps->resources);
929 static void acpi_device_release(struct device *dev)
931 struct acpi_device *acpi_dev = to_acpi_device(dev);
933 acpi_free_pnp_ids(&acpi_dev->pnp);
934 acpi_free_power_resources_lists(acpi_dev);
938 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
940 struct acpi_device *acpi_dev = to_acpi_device(dev);
941 struct acpi_driver *acpi_drv = to_acpi_driver(drv);
943 return acpi_dev->flags.match_driver
944 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
947 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
949 struct acpi_device *acpi_dev = to_acpi_device(dev);
952 if (list_empty(&acpi_dev->pnp.ids))
955 if (add_uevent_var(env, "MODALIAS="))
957 len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
958 sizeof(env->buf) - env->buflen);
965 static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
967 struct acpi_device *device = data;
969 device->driver->ops.notify(device, event);
972 static void acpi_device_notify_fixed(void *data)
974 struct acpi_device *device = data;
976 /* Fixed hardware devices have no handles */
977 acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
980 static acpi_status acpi_device_fixed_event(void *data)
982 acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
986 static int acpi_device_install_notify_handler(struct acpi_device *device)
990 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
992 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
993 acpi_device_fixed_event,
995 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
997 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
998 acpi_device_fixed_event,
1001 status = acpi_install_notify_handler(device->handle,
1006 if (ACPI_FAILURE(status))
1011 static void acpi_device_remove_notify_handler(struct acpi_device *device)
1013 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
1014 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
1015 acpi_device_fixed_event);
1016 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
1017 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
1018 acpi_device_fixed_event);
1020 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
1021 acpi_device_notify);
1024 static int acpi_device_probe(struct device *dev)
1026 struct acpi_device *acpi_dev = to_acpi_device(dev);
1027 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
1030 if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
1033 if (!acpi_drv->ops.add)
1036 ret = acpi_drv->ops.add(acpi_dev);
1040 acpi_dev->driver = acpi_drv;
1041 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1042 "Driver [%s] successfully bound to device [%s]\n",
1043 acpi_drv->name, acpi_dev->pnp.bus_id));
1045 if (acpi_drv->ops.notify) {
1046 ret = acpi_device_install_notify_handler(acpi_dev);
1048 if (acpi_drv->ops.remove)
1049 acpi_drv->ops.remove(acpi_dev);
1051 acpi_dev->driver = NULL;
1052 acpi_dev->driver_data = NULL;
1057 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
1058 acpi_drv->name, acpi_dev->pnp.bus_id));
1063 static int acpi_device_remove(struct device * dev)
1065 struct acpi_device *acpi_dev = to_acpi_device(dev);
1066 struct acpi_driver *acpi_drv = acpi_dev->driver;
1069 if (acpi_drv->ops.notify)
1070 acpi_device_remove_notify_handler(acpi_dev);
1071 if (acpi_drv->ops.remove)
1072 acpi_drv->ops.remove(acpi_dev);
1074 acpi_dev->driver = NULL;
1075 acpi_dev->driver_data = NULL;
1081 struct bus_type acpi_bus_type = {
1083 .match = acpi_bus_match,
1084 .probe = acpi_device_probe,
1085 .remove = acpi_device_remove,
1086 .uevent = acpi_device_uevent,
1089 static void acpi_device_del(struct acpi_device *device)
1091 mutex_lock(&acpi_device_lock);
1093 list_del(&device->node);
1095 list_del(&device->wakeup_list);
1096 mutex_unlock(&acpi_device_lock);
1098 acpi_power_add_remove_device(device, false);
1099 acpi_device_remove_files(device);
1101 device->remove(device);
1103 device_del(&device->dev);
1106 static LIST_HEAD(acpi_device_del_list);
1107 static DEFINE_MUTEX(acpi_device_del_lock);
1109 static void acpi_device_del_work_fn(struct work_struct *work_not_used)
1112 struct acpi_device *adev;
1114 mutex_lock(&acpi_device_del_lock);
1116 if (list_empty(&acpi_device_del_list)) {
1117 mutex_unlock(&acpi_device_del_lock);
1120 adev = list_first_entry(&acpi_device_del_list,
1121 struct acpi_device, del_list);
1122 list_del(&adev->del_list);
1124 mutex_unlock(&acpi_device_del_lock);
1126 acpi_device_del(adev);
1128 * Drop references to all power resources that might have been
1129 * used by the device.
1131 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
1132 put_device(&adev->dev);
1137 * acpi_scan_drop_device - Drop an ACPI device object.
1138 * @handle: Handle of an ACPI namespace node, not used.
1139 * @context: Address of the ACPI device object to drop.
1141 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
1142 * namespace node the device object pointed to by @context is attached to.
1144 * The unregistration is carried out asynchronously to avoid running
1145 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
1146 * ensure the correct ordering (the device objects must be unregistered in the
1147 * same order in which the corresponding namespace nodes are deleted).
1149 static void acpi_scan_drop_device(acpi_handle handle, void *context)
1151 static DECLARE_WORK(work, acpi_device_del_work_fn);
1152 struct acpi_device *adev = context;
1154 mutex_lock(&acpi_device_del_lock);
1157 * Use the ACPI hotplug workqueue which is ordered, so this work item
1158 * won't run after any hotplug work items submitted subsequently. That
1159 * prevents attempts to register device objects identical to those being
1160 * deleted from happening concurrently (such attempts result from
1161 * hotplug events handled via the ACPI hotplug workqueue). It also will
1162 * run after all of the work items submitted previosuly, which helps
1163 * those work items to ensure that they are not accessing stale device
1166 if (list_empty(&acpi_device_del_list))
1167 acpi_queue_hotplug_work(&work);
1169 list_add_tail(&adev->del_list, &acpi_device_del_list);
1170 /* Make acpi_ns_validate_handle() return NULL for this handle. */
1171 adev->handle = INVALID_ACPI_HANDLE;
1173 mutex_unlock(&acpi_device_del_lock);
1176 static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
1177 void (*callback)(void *))
1184 status = acpi_get_data_full(handle, acpi_scan_drop_device,
1185 (void **)device, callback);
1186 if (ACPI_FAILURE(status) || !*device) {
1187 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
1194 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
1196 return acpi_get_device_data(handle, device, NULL);
1198 EXPORT_SYMBOL(acpi_bus_get_device);
1200 static void get_acpi_device(void *dev)
1203 get_device(&((struct acpi_device *)dev)->dev);
1206 struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
1208 struct acpi_device *adev = NULL;
1210 acpi_get_device_data(handle, &adev, get_acpi_device);
1214 void acpi_bus_put_acpi_device(struct acpi_device *adev)
1216 put_device(&adev->dev);
1219 int acpi_device_add(struct acpi_device *device,
1220 void (*release)(struct device *))
1223 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
1226 if (device->handle) {
1229 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
1231 if (ACPI_FAILURE(status)) {
1232 acpi_handle_err(device->handle,
1233 "Unable to attach device data\n");
1241 * Link this device to its parent and siblings.
1243 INIT_LIST_HEAD(&device->children);
1244 INIT_LIST_HEAD(&device->node);
1245 INIT_LIST_HEAD(&device->wakeup_list);
1246 INIT_LIST_HEAD(&device->physical_node_list);
1247 INIT_LIST_HEAD(&device->del_list);
1248 mutex_init(&device->physical_node_lock);
1250 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
1252 pr_err(PREFIX "Memory allocation error\n");
1257 mutex_lock(&acpi_device_lock);
1259 * Find suitable bus_id and instance number in acpi_bus_id_list
1260 * If failed, create one and link it into acpi_bus_id_list
1262 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
1263 if (!strcmp(acpi_device_bus_id->bus_id,
1264 acpi_device_hid(device))) {
1265 acpi_device_bus_id->instance_no++;
1272 acpi_device_bus_id = new_bus_id;
1273 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
1274 acpi_device_bus_id->instance_no = 0;
1275 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
1277 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
1280 list_add_tail(&device->node, &device->parent->children);
1282 if (device->wakeup.flags.valid)
1283 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
1284 mutex_unlock(&acpi_device_lock);
1287 device->dev.parent = &device->parent->dev;
1288 device->dev.bus = &acpi_bus_type;
1289 device->dev.release = release;
1290 result = device_add(&device->dev);
1292 dev_err(&device->dev, "Error registering device\n");
1296 result = acpi_device_setup_files(device);
1298 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
1299 dev_name(&device->dev));
1304 mutex_lock(&acpi_device_lock);
1306 list_del(&device->node);
1307 list_del(&device->wakeup_list);
1308 mutex_unlock(&acpi_device_lock);
1311 acpi_detach_data(device->handle, acpi_scan_drop_device);
1315 /* --------------------------------------------------------------------------
1317 -------------------------------------------------------------------------- */
1319 * acpi_bus_register_driver - register a driver with the ACPI bus
1320 * @driver: driver being registered
1322 * Registers a driver with the ACPI bus. Searches the namespace for all
1323 * devices that match the driver's criteria and binds. Returns zero for
1324 * success or a negative error status for failure.
1326 int acpi_bus_register_driver(struct acpi_driver *driver)
1332 driver->drv.name = driver->name;
1333 driver->drv.bus = &acpi_bus_type;
1334 driver->drv.owner = driver->owner;
1336 ret = driver_register(&driver->drv);
1340 EXPORT_SYMBOL(acpi_bus_register_driver);
1343 * acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
1344 * @driver: driver to unregister
1346 * Unregisters a driver with the ACPI bus. Searches the namespace for all
1347 * devices that match the driver's criteria and unbinds.
1349 void acpi_bus_unregister_driver(struct acpi_driver *driver)
1351 driver_unregister(&driver->drv);
1354 EXPORT_SYMBOL(acpi_bus_unregister_driver);
1356 /* --------------------------------------------------------------------------
1358 -------------------------------------------------------------------------- */
1359 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
1361 struct acpi_device *device = NULL;
1365 * Fixed hardware devices do not appear in the namespace and do not
1366 * have handles, but we fabricate acpi_devices for them, so we have
1367 * to deal with them specially.
1373 status = acpi_get_parent(handle, &handle);
1374 if (ACPI_FAILURE(status))
1375 return status == AE_NULL_ENTRY ? NULL : acpi_root;
1376 } while (acpi_bus_get_device(handle, &device));
1381 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
1385 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1386 union acpi_object *obj;
1388 status = acpi_get_handle(handle, "_EJD", &tmp);
1389 if (ACPI_FAILURE(status))
1392 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
1393 if (ACPI_SUCCESS(status)) {
1394 obj = buffer.pointer;
1395 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
1397 kfree(buffer.pointer);
1401 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
1403 static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
1404 struct acpi_device_wakeup *wakeup)
1406 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1407 union acpi_object *package = NULL;
1408 union acpi_object *element = NULL;
1415 INIT_LIST_HEAD(&wakeup->resources);
1418 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
1419 if (ACPI_FAILURE(status)) {
1420 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
1424 package = (union acpi_object *)buffer.pointer;
1426 if (!package || package->package.count < 2)
1429 element = &(package->package.elements[0]);
1433 if (element->type == ACPI_TYPE_PACKAGE) {
1434 if ((element->package.count < 2) ||
1435 (element->package.elements[0].type !=
1436 ACPI_TYPE_LOCAL_REFERENCE)
1437 || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
1440 wakeup->gpe_device =
1441 element->package.elements[0].reference.handle;
1442 wakeup->gpe_number =
1443 (u32) element->package.elements[1].integer.value;
1444 } else if (element->type == ACPI_TYPE_INTEGER) {
1445 wakeup->gpe_device = NULL;
1446 wakeup->gpe_number = element->integer.value;
1451 element = &(package->package.elements[1]);
1452 if (element->type != ACPI_TYPE_INTEGER)
1455 wakeup->sleep_state = element->integer.value;
1457 err = acpi_extract_power_resources(package, 2, &wakeup->resources);
1461 if (!list_empty(&wakeup->resources)) {
1464 err = acpi_power_wakeup_list_init(&wakeup->resources,
1467 acpi_handle_warn(handle, "Retrieving current states "
1468 "of wakeup power resources failed\n");
1469 acpi_power_resources_list_free(&wakeup->resources);
1472 if (sleep_state < wakeup->sleep_state) {
1473 acpi_handle_warn(handle, "Overriding _PRW sleep state "
1474 "(S%d) by S%d from power resources\n",
1475 (int)wakeup->sleep_state, sleep_state);
1476 wakeup->sleep_state = sleep_state;
1481 kfree(buffer.pointer);
1485 static void acpi_wakeup_gpe_init(struct acpi_device *device)
1487 struct acpi_device_id button_device_ids[] = {
1493 struct acpi_device_wakeup *wakeup = &device->wakeup;
1495 acpi_event_status event_status;
1497 wakeup->flags.notifier_present = 0;
1499 /* Power button, Lid switch always enable wakeup */
1500 if (!acpi_match_device_ids(device, button_device_ids)) {
1501 wakeup->flags.run_wake = 1;
1502 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
1503 /* Do not use Lid/sleep button for S5 wakeup */
1504 if (wakeup->sleep_state == ACPI_STATE_S5)
1505 wakeup->sleep_state = ACPI_STATE_S4;
1507 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
1508 device_set_wakeup_capable(&device->dev, true);
1512 acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
1513 wakeup->gpe_number);
1514 status = acpi_get_gpe_status(wakeup->gpe_device, wakeup->gpe_number,
1516 if (ACPI_FAILURE(status))
1519 wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER);
1522 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
1526 /* Presence of _PRW indicates wake capable */
1527 if (!acpi_has_method(device->handle, "_PRW"))
1530 err = acpi_bus_extract_wakeup_device_power_package(device->handle,
1533 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
1537 device->wakeup.flags.valid = 1;
1538 device->wakeup.prepare_count = 0;
1539 acpi_wakeup_gpe_init(device);
1540 /* Call _PSW/_DSW object to disable its ability to wake the sleeping
1541 * system for the ACPI device with the _PRW object.
1542 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
1543 * So it is necessary to call _DSW object first. Only when it is not
1544 * present will the _PSW object used.
1546 err = acpi_device_sleep_wake(device, 0, 0, 0);
1548 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1549 "error in _DSW or _PSW evaluation\n"));
1552 static void acpi_bus_init_power_state(struct acpi_device *device, int state)
1554 struct acpi_device_power_state *ps = &device->power.states[state];
1555 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
1556 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1559 INIT_LIST_HEAD(&ps->resources);
1561 /* Evaluate "_PRx" to get referenced power resources */
1562 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
1563 if (ACPI_SUCCESS(status)) {
1564 union acpi_object *package = buffer.pointer;
1566 if (buffer.length && package
1567 && package->type == ACPI_TYPE_PACKAGE
1568 && package->package.count) {
1569 int err = acpi_extract_power_resources(package, 0,
1572 device->power.flags.power_resources = 1;
1574 ACPI_FREE(buffer.pointer);
1577 /* Evaluate "_PSx" to see if we can do explicit sets */
1579 if (acpi_has_method(device->handle, pathname))
1580 ps->flags.explicit_set = 1;
1583 * State is valid if there are means to put the device into it.
1584 * D3hot is only valid if _PR3 present.
1586 if (!list_empty(&ps->resources)
1587 || (ps->flags.explicit_set && state < ACPI_STATE_D3_HOT)) {
1588 ps->flags.valid = 1;
1589 ps->flags.os_accessible = 1;
1592 ps->power = -1; /* Unknown - driver assigned */
1593 ps->latency = -1; /* Unknown - driver assigned */
1596 static void acpi_bus_get_power_flags(struct acpi_device *device)
1600 /* Presence of _PS0|_PR0 indicates 'power manageable' */
1601 if (!acpi_has_method(device->handle, "_PS0") &&
1602 !acpi_has_method(device->handle, "_PR0"))
1605 device->flags.power_manageable = 1;
1608 * Power Management Flags
1610 if (acpi_has_method(device->handle, "_PSC"))
1611 device->power.flags.explicit_get = 1;
1613 if (acpi_has_method(device->handle, "_IRC"))
1614 device->power.flags.inrush_current = 1;
1616 if (acpi_has_method(device->handle, "_DSW"))
1617 device->power.flags.dsw_present = 1;
1620 * Enumerate supported power management states
1622 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
1623 acpi_bus_init_power_state(device, i);
1625 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
1627 /* Set defaults for D0 and D3 states (always valid) */
1628 device->power.states[ACPI_STATE_D0].flags.valid = 1;
1629 device->power.states[ACPI_STATE_D0].power = 100;
1630 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
1631 device->power.states[ACPI_STATE_D3_COLD].power = 0;
1633 /* Set D3cold's explicit_set flag if _PS3 exists. */
1634 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
1635 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
1637 /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
1638 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
1639 device->power.flags.power_resources)
1640 device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
1642 if (acpi_bus_init_power(device)) {
1643 acpi_free_power_resources_lists(device);
1644 device->flags.power_manageable = 0;
1648 static void acpi_bus_get_flags(struct acpi_device *device)
1650 /* Presence of _STA indicates 'dynamic_status' */
1651 if (acpi_has_method(device->handle, "_STA"))
1652 device->flags.dynamic_status = 1;
1654 /* Presence of _RMV indicates 'removable' */
1655 if (acpi_has_method(device->handle, "_RMV"))
1656 device->flags.removable = 1;
1658 /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1659 if (acpi_has_method(device->handle, "_EJD") ||
1660 acpi_has_method(device->handle, "_EJ0"))
1661 device->flags.ejectable = 1;
1664 static void acpi_device_get_busid(struct acpi_device *device)
1666 char bus_id[5] = { '?', 0 };
1667 struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1673 * The device's Bus ID is simply the object name.
1674 * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1676 if (ACPI_IS_ROOT_DEVICE(device)) {
1677 strcpy(device->pnp.bus_id, "ACPI");
1681 switch (device->device_type) {
1682 case ACPI_BUS_TYPE_POWER_BUTTON:
1683 strcpy(device->pnp.bus_id, "PWRF");
1685 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1686 strcpy(device->pnp.bus_id, "SLPF");
1689 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
1690 /* Clean up trailing underscores (if any) */
1691 for (i = 3; i > 1; i--) {
1692 if (bus_id[i] == '_')
1697 strcpy(device->pnp.bus_id, bus_id);
1703 * acpi_ata_match - see if an acpi object is an ATA device
1705 * If an acpi object has one of the ACPI ATA methods defined,
1706 * then we can safely call it an ATA device.
1708 bool acpi_ata_match(acpi_handle handle)
1710 return acpi_has_method(handle, "_GTF") ||
1711 acpi_has_method(handle, "_GTM") ||
1712 acpi_has_method(handle, "_STM") ||
1713 acpi_has_method(handle, "_SDD");
1717 * acpi_bay_match - see if an acpi object is an ejectable driver bay
1719 * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1720 * then we can safely call it an ejectable drive bay
1722 bool acpi_bay_match(acpi_handle handle)
1724 acpi_handle phandle;
1726 if (!acpi_has_method(handle, "_EJ0"))
1728 if (acpi_ata_match(handle))
1730 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1733 return acpi_ata_match(phandle);
1736 bool acpi_device_is_battery(struct acpi_device *adev)
1738 struct acpi_hardware_id *hwid;
1740 list_for_each_entry(hwid, &adev->pnp.ids, list)
1741 if (!strcmp("PNP0C0A", hwid->id))
1747 static bool is_ejectable_bay(struct acpi_device *adev)
1749 acpi_handle handle = adev->handle;
1751 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
1754 return acpi_bay_match(handle);
1758 * acpi_dock_match - see if an acpi object has a _DCK method
1760 bool acpi_dock_match(acpi_handle handle)
1762 return acpi_has_method(handle, "_DCK");
1765 const char *acpi_device_hid(struct acpi_device *device)
1767 struct acpi_hardware_id *hid;
1769 if (list_empty(&device->pnp.ids))
1772 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1775 EXPORT_SYMBOL(acpi_device_hid);
1777 static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1779 struct acpi_hardware_id *id;
1781 id = kmalloc(sizeof(*id), GFP_KERNEL);
1785 id->id = kstrdup(dev_id, GFP_KERNEL);
1791 list_add_tail(&id->list, &pnp->ids);
1792 pnp->type.hardware_id = 1;
1796 * Old IBM workstations have a DSDT bug wherein the SMBus object
1797 * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1798 * prefix. Work around this.
1800 static bool acpi_ibm_smbus_match(acpi_handle handle)
1802 char node_name[ACPI_PATH_SEGMENT_LENGTH];
1803 struct acpi_buffer path = { sizeof(node_name), node_name };
1805 if (!dmi_name_in_vendors("IBM"))
1808 /* Look for SMBS object */
1809 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1810 strcmp("SMBS", path.pointer))
1813 /* Does it have the necessary (but misnamed) methods? */
1814 if (acpi_has_method(handle, "SBI") &&
1815 acpi_has_method(handle, "SBR") &&
1816 acpi_has_method(handle, "SBW"))
1822 static bool acpi_object_is_system_bus(acpi_handle handle)
1826 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
1829 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
1836 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1840 struct acpi_device_info *info;
1841 struct acpi_pnp_device_id_list *cid_list;
1844 switch (device_type) {
1845 case ACPI_BUS_TYPE_DEVICE:
1846 if (handle == ACPI_ROOT_OBJECT) {
1847 acpi_add_id(pnp, ACPI_SYSTEM_HID);
1851 status = acpi_get_object_info(handle, &info);
1852 if (ACPI_FAILURE(status)) {
1853 pr_err(PREFIX "%s: Error reading device info\n",
1858 if (info->valid & ACPI_VALID_HID) {
1859 acpi_add_id(pnp, info->hardware_id.string);
1860 pnp->type.platform_id = 1;
1862 if (info->valid & ACPI_VALID_CID) {
1863 cid_list = &info->compatible_id_list;
1864 for (i = 0; i < cid_list->count; i++)
1865 acpi_add_id(pnp, cid_list->ids[i].string);
1867 if (info->valid & ACPI_VALID_ADR) {
1868 pnp->bus_address = info->address;
1869 pnp->type.bus_address = 1;
1871 if (info->valid & ACPI_VALID_UID)
1872 pnp->unique_id = kstrdup(info->unique_id.string,
1878 * Some devices don't reliably have _HIDs & _CIDs, so add
1879 * synthetic HIDs to make sure drivers can find them.
1881 if (acpi_is_video_device(handle))
1882 acpi_add_id(pnp, ACPI_VIDEO_HID);
1883 else if (acpi_bay_match(handle))
1884 acpi_add_id(pnp, ACPI_BAY_HID);
1885 else if (acpi_dock_match(handle))
1886 acpi_add_id(pnp, ACPI_DOCK_HID);
1887 else if (acpi_ibm_smbus_match(handle))
1888 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
1889 else if (list_empty(&pnp->ids) &&
1890 acpi_object_is_system_bus(handle)) {
1891 /* \_SB, \_TZ, LNXSYBUS */
1892 acpi_add_id(pnp, ACPI_BUS_HID);
1893 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
1894 strcpy(pnp->device_class, ACPI_BUS_CLASS);
1898 case ACPI_BUS_TYPE_POWER:
1899 acpi_add_id(pnp, ACPI_POWER_HID);
1901 case ACPI_BUS_TYPE_PROCESSOR:
1902 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
1904 case ACPI_BUS_TYPE_THERMAL:
1905 acpi_add_id(pnp, ACPI_THERMAL_HID);
1907 case ACPI_BUS_TYPE_POWER_BUTTON:
1908 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
1910 case ACPI_BUS_TYPE_SLEEP_BUTTON:
1911 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
1916 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1918 struct acpi_hardware_id *id, *tmp;
1920 list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
1924 kfree(pnp->unique_id);
1927 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1928 int type, unsigned long long sta)
1930 INIT_LIST_HEAD(&device->pnp.ids);
1931 device->device_type = type;
1932 device->handle = handle;
1933 device->parent = acpi_bus_get_parent(handle);
1934 acpi_set_device_status(device, sta);
1935 acpi_device_get_busid(device);
1936 acpi_set_pnp_ids(handle, &device->pnp, type);
1937 acpi_bus_get_flags(device);
1938 device->flags.match_driver = false;
1939 device->flags.initialized = true;
1940 device->flags.visited = false;
1941 device_initialize(&device->dev);
1942 dev_set_uevent_suppress(&device->dev, true);
1945 void acpi_device_add_finalize(struct acpi_device *device)
1947 dev_set_uevent_suppress(&device->dev, false);
1948 kobject_uevent(&device->dev.kobj, KOBJ_ADD);
1951 static int acpi_add_single_object(struct acpi_device **child,
1952 acpi_handle handle, int type,
1953 unsigned long long sta)
1956 struct acpi_device *device;
1957 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1959 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1961 printk(KERN_ERR PREFIX "Memory allocation error\n");
1965 acpi_init_device_object(device, handle, type, sta);
1966 acpi_bus_get_power_flags(device);
1967 acpi_bus_get_wakeup_device_flags(device);
1969 result = acpi_device_add(device, acpi_device_release);
1971 acpi_device_release(&device->dev);
1975 acpi_power_add_remove_device(device, true);
1976 acpi_device_add_finalize(device);
1977 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1978 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1979 dev_name(&device->dev), (char *) buffer.pointer,
1980 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1981 kfree(buffer.pointer);
1986 static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1987 unsigned long long *sta)
1990 acpi_object_type acpi_type;
1992 status = acpi_get_type(handle, &acpi_type);
1993 if (ACPI_FAILURE(status))
1996 switch (acpi_type) {
1997 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
1998 case ACPI_TYPE_DEVICE:
1999 *type = ACPI_BUS_TYPE_DEVICE;
2000 status = acpi_bus_get_status_handle(handle, sta);
2001 if (ACPI_FAILURE(status))
2004 case ACPI_TYPE_PROCESSOR:
2005 *type = ACPI_BUS_TYPE_PROCESSOR;
2006 status = acpi_bus_get_status_handle(handle, sta);
2007 if (ACPI_FAILURE(status))
2010 case ACPI_TYPE_THERMAL:
2011 *type = ACPI_BUS_TYPE_THERMAL;
2012 *sta = ACPI_STA_DEFAULT;
2014 case ACPI_TYPE_POWER:
2015 *type = ACPI_BUS_TYPE_POWER;
2016 *sta = ACPI_STA_DEFAULT;
2025 bool acpi_device_is_present(struct acpi_device *adev)
2027 if (adev->status.present || adev->status.functional)
2030 adev->flags.initialized = false;
2034 static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
2036 const struct acpi_device_id **matchid)
2038 const struct acpi_device_id *devid;
2041 return handler->match(idstr, matchid);
2043 for (devid = handler->ids; devid->id[0]; devid++)
2044 if (!strcmp((char *)devid->id, idstr)) {
2054 static struct acpi_scan_handler *acpi_scan_match_handler(char *idstr,
2055 const struct acpi_device_id **matchid)
2057 struct acpi_scan_handler *handler;
2059 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
2060 if (acpi_scan_handler_matching(handler, idstr, matchid))
2066 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
2068 if (!!hotplug->enabled == !!val)
2071 mutex_lock(&acpi_scan_lock);
2073 hotplug->enabled = val;
2075 mutex_unlock(&acpi_scan_lock);
2078 static void acpi_scan_init_hotplug(struct acpi_device *adev)
2080 struct acpi_hardware_id *hwid;
2082 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
2083 acpi_dock_add(adev);
2086 list_for_each_entry(hwid, &adev->pnp.ids, list) {
2087 struct acpi_scan_handler *handler;
2089 handler = acpi_scan_match_handler(hwid->id, NULL);
2091 adev->flags.hotplug_notify = true;
2097 static void acpi_device_dep_initialize(struct acpi_device *adev)
2099 struct acpi_dep_data *dep;
2100 struct acpi_handle_list dep_devices;
2104 if (!acpi_has_method(adev->handle, "_DEP"))
2107 status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
2109 if (ACPI_FAILURE(status)) {
2110 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
2114 for (i = 0; i < dep_devices.count; i++) {
2115 struct acpi_device_info *info;
2118 status = acpi_get_object_info(dep_devices.handles[i], &info);
2119 if (ACPI_FAILURE(status)) {
2120 dev_dbg(&adev->dev, "Error reading _DEP device info\n");
2125 * Skip the dependency of Windows System Power
2126 * Management Controller
2128 skip = info->valid & ACPI_VALID_HID &&
2129 !strcmp(info->hardware_id.string, "INT3396");
2136 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
2140 dep->master = dep_devices.handles[i];
2141 dep->slave = adev->handle;
2144 mutex_lock(&acpi_dep_list_lock);
2145 list_add_tail(&dep->node , &acpi_dep_list);
2146 mutex_unlock(&acpi_dep_list_lock);
2150 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
2151 void *not_used, void **return_value)
2153 struct acpi_device *device = NULL;
2155 unsigned long long sta;
2158 acpi_bus_get_device(handle, &device);
2162 result = acpi_bus_type_and_status(handle, &type, &sta);
2166 if (type == ACPI_BUS_TYPE_POWER) {
2167 acpi_add_power_resource(handle);
2171 acpi_add_single_object(&device, handle, type, sta);
2173 return AE_CTRL_DEPTH;
2175 acpi_scan_init_hotplug(device);
2176 acpi_device_dep_initialize(device);
2180 *return_value = device;
2185 static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
2187 bool *is_spi_i2c_slave_p = data;
2189 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
2193 * devices that are connected to UART still need to be enumerated to
2196 if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
2197 *is_spi_i2c_slave_p = true;
2199 /* no need to do more checking */
2203 static void acpi_default_enumeration(struct acpi_device *device)
2205 struct list_head resource_list;
2206 bool is_spi_i2c_slave = false;
2208 if (!device->pnp.type.platform_id || device->handler)
2212 * Do not enemerate SPI/I2C slaves as they will be enuerated by their
2213 * respective parents.
2215 INIT_LIST_HEAD(&resource_list);
2216 acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
2218 acpi_dev_free_resource_list(&resource_list);
2219 if (!is_spi_i2c_slave)
2220 acpi_create_platform_device(device);
2223 static int acpi_scan_attach_handler(struct acpi_device *device)
2225 struct acpi_hardware_id *hwid;
2228 list_for_each_entry(hwid, &device->pnp.ids, list) {
2229 const struct acpi_device_id *devid;
2230 struct acpi_scan_handler *handler;
2232 handler = acpi_scan_match_handler(hwid->id, &devid);
2234 if (!handler->attach) {
2235 device->pnp.type.platform_id = 0;
2238 device->handler = handler;
2239 ret = handler->attach(device, devid);
2243 device->handler = NULL;
2249 acpi_default_enumeration(device);
2254 static void acpi_bus_attach(struct acpi_device *device)
2256 struct acpi_device *child;
2260 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
2261 register_dock_dependent_device(device, ejd);
2263 acpi_bus_get_status(device);
2264 /* Skip devices that are not present. */
2265 if (!acpi_device_is_present(device)) {
2266 device->flags.visited = false;
2269 if (device->handler)
2272 if (!device->flags.initialized) {
2273 acpi_bus_update_power(device, NULL);
2274 device->flags.initialized = true;
2276 device->flags.visited = false;
2277 ret = acpi_scan_attach_handler(device);
2281 device->flags.match_driver = true;
2283 ret = device_attach(&device->dev);
2287 device->flags.visited = true;
2290 list_for_each_entry(child, &device->children, node)
2291 acpi_bus_attach(child);
2293 if (device->handler && device->handler->hotplug.notify_online)
2294 device->handler->hotplug.notify_online(device);
2297 void acpi_walk_dep_device_list(acpi_handle handle)
2299 struct acpi_dep_data *dep, *tmp;
2300 struct acpi_device *adev;
2302 mutex_lock(&acpi_dep_list_lock);
2303 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
2304 if (dep->master == handle) {
2305 acpi_bus_get_device(dep->slave, &adev);
2310 if (!adev->dep_unmet)
2311 acpi_bus_attach(adev);
2312 list_del(&dep->node);
2316 mutex_unlock(&acpi_dep_list_lock);
2318 EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
2321 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2322 * @handle: Root of the namespace scope to scan.
2324 * Scan a given ACPI tree (probably recently hot-plugged) and create and add
2327 * If no devices were found, -ENODEV is returned, but it does not mean that
2328 * there has been a real error. There just have been no suitable ACPI objects
2329 * in the table trunk from which the kernel could create a device and add an
2330 * appropriate driver.
2332 * Must be called under acpi_scan_lock.
2334 int acpi_bus_scan(acpi_handle handle)
2336 void *device = NULL;
2338 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
2339 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
2340 acpi_bus_check_add, NULL, NULL, &device);
2343 acpi_bus_attach(device);
2348 EXPORT_SYMBOL(acpi_bus_scan);
2351 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
2352 * @adev: Root of the ACPI namespace scope to walk.
2354 * Must be called under acpi_scan_lock.
2356 void acpi_bus_trim(struct acpi_device *adev)
2358 struct acpi_scan_handler *handler = adev->handler;
2359 struct acpi_device *child;
2361 list_for_each_entry_reverse(child, &adev->children, node)
2362 acpi_bus_trim(child);
2364 adev->flags.match_driver = false;
2366 if (handler->detach)
2367 handler->detach(adev);
2369 adev->handler = NULL;
2371 device_release_driver(&adev->dev);
2374 * Most likely, the device is going away, so put it into D3cold before
2377 acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
2378 adev->flags.initialized = false;
2379 adev->flags.visited = false;
2381 EXPORT_SYMBOL_GPL(acpi_bus_trim);
2383 static int acpi_bus_scan_fixed(void)
2388 * Enumerate all fixed-feature devices.
2390 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
2391 struct acpi_device *device = NULL;
2393 result = acpi_add_single_object(&device, NULL,
2394 ACPI_BUS_TYPE_POWER_BUTTON,
2399 device->flags.match_driver = true;
2400 result = device_attach(&device->dev);
2404 device_init_wakeup(&device->dev, true);
2407 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
2408 struct acpi_device *device = NULL;
2410 result = acpi_add_single_object(&device, NULL,
2411 ACPI_BUS_TYPE_SLEEP_BUTTON,
2416 device->flags.match_driver = true;
2417 result = device_attach(&device->dev);
2420 return result < 0 ? result : 0;
2423 int __init acpi_scan_init(void)
2427 result = bus_register(&acpi_bus_type);
2429 /* We don't want to quit even if we failed to add suspend/resume */
2430 printk(KERN_ERR PREFIX "Could not register bus type\n");
2433 acpi_pci_root_init();
2434 acpi_pci_link_init();
2435 acpi_processor_init();
2437 acpi_cmos_rtc_init();
2438 acpi_container_init();
2439 acpi_memory_hotplug_init();
2441 acpi_int340x_thermal_init();
2443 mutex_lock(&acpi_scan_lock);
2445 * Enumerate devices in the ACPI namespace.
2447 result = acpi_bus_scan(ACPI_ROOT_OBJECT);
2451 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
2455 /* Fixed feature devices do not exist on HW-reduced platform */
2456 if (!acpi_gbl_reduced_hardware) {
2457 result = acpi_bus_scan_fixed();
2459 acpi_detach_data(acpi_root->handle,
2460 acpi_scan_drop_device);
2461 acpi_device_del(acpi_root);
2462 put_device(&acpi_root->dev);
2467 acpi_update_all_gpes();
2470 mutex_unlock(&acpi_scan_lock);