2 * Link physical devices with ACPI devices support
4 * Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
5 * Copyright (c) 2005 Intel Corp.
7 * This file is released under the GPLv2.
9 #include <linux/export.h>
10 #include <linux/init.h>
11 #include <linux/list.h>
12 #include <linux/device.h>
13 #include <linux/slab.h>
14 #include <linux/rwsem.h>
15 #include <linux/acpi.h>
19 #define ACPI_GLUE_DEBUG 0
21 #define DBG(fmt, ...) \
22 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__)
24 #define DBG(fmt, ...) \
27 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__); \
30 static LIST_HEAD(bus_type_list);
31 static DECLARE_RWSEM(bus_type_sem);
33 #define PHYSICAL_NODE_STRING "physical_node"
34 #define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10)
36 int register_acpi_bus_type(struct acpi_bus_type *type)
40 if (type && type->match && type->find_device) {
41 down_write(&bus_type_sem);
42 list_add_tail(&type->list, &bus_type_list);
43 up_write(&bus_type_sem);
44 printk(KERN_INFO PREFIX "bus type %s registered\n", type->name);
49 EXPORT_SYMBOL_GPL(register_acpi_bus_type);
51 int unregister_acpi_bus_type(struct acpi_bus_type *type)
56 down_write(&bus_type_sem);
57 list_del_init(&type->list);
58 up_write(&bus_type_sem);
59 printk(KERN_INFO PREFIX "bus type %s unregistered\n",
65 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
67 static struct acpi_bus_type *acpi_get_bus_type(struct device *dev)
69 struct acpi_bus_type *tmp, *ret = NULL;
71 down_read(&bus_type_sem);
72 list_for_each_entry(tmp, &bus_type_list, list) {
73 if (tmp->match(dev)) {
78 up_read(&bus_type_sem);
82 #define FIND_CHILD_MIN_SCORE 1
83 #define FIND_CHILD_MAX_SCORE 2
85 static acpi_status acpi_dev_present(acpi_handle handle, u32 lvl_not_used,
86 void *not_used, void **ret_p)
88 struct acpi_device *adev = NULL;
90 acpi_bus_get_device(handle, &adev);
93 return AE_CTRL_TERMINATE;
98 static int do_find_child_checks(acpi_handle handle, bool is_bridge)
100 bool sta_present = true;
101 unsigned long long sta;
104 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
105 if (status == AE_NOT_FOUND)
107 else if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED))
113 /* Check if this object has at least one child device. */
114 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
115 acpi_dev_present, NULL, NULL, &test);
119 return sta_present ? FIND_CHILD_MAX_SCORE : FIND_CHILD_MIN_SCORE;
122 struct find_child_context {
129 static acpi_status do_find_child(acpi_handle handle, u32 lvl_not_used,
130 void *data, void **not_used)
132 struct find_child_context *context = data;
133 unsigned long long addr;
137 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr);
138 if (ACPI_FAILURE(status) || addr != context->addr)
142 /* This is the first matching object. Save its handle. */
143 context->ret = handle;
147 * There is more than one matching object with the same _ADR value.
148 * That really is unexpected, so we are kind of beyond the scope of the
149 * spec here. We have to choose which one to return, though.
151 * First, check if the previously found object is good enough and return
152 * its handle if so. Second, check the same for the object that we've
155 if (!context->ret_score) {
156 score = do_find_child_checks(context->ret, context->is_bridge);
157 if (score == FIND_CHILD_MAX_SCORE)
158 return AE_CTRL_TERMINATE;
160 context->ret_score = score;
162 score = do_find_child_checks(handle, context->is_bridge);
163 if (score == FIND_CHILD_MAX_SCORE) {
164 context->ret = handle;
165 return AE_CTRL_TERMINATE;
166 } else if (score > context->ret_score) {
167 context->ret = handle;
168 context->ret_score = score;
173 acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge)
176 struct find_child_context context = {
178 .is_bridge = is_bridge,
181 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, do_find_child,
182 NULL, &context, NULL);
187 EXPORT_SYMBOL_GPL(acpi_find_child);
189 static void acpi_physnode_link_name(char *buf, unsigned int node_id)
192 snprintf(buf, PHYSICAL_NODE_NAME_SIZE,
193 PHYSICAL_NODE_STRING "%u", node_id);
195 strcpy(buf, PHYSICAL_NODE_STRING);
198 int acpi_bind_one(struct device *dev, acpi_handle handle)
200 struct acpi_device *acpi_dev = NULL;
201 struct acpi_device_physical_node *physical_node, *pn;
202 char physical_node_name[PHYSICAL_NODE_NAME_SIZE];
203 struct list_head *physnode_list;
204 unsigned int node_id;
205 int retval = -EINVAL;
207 if (ACPI_COMPANION(dev)) {
209 dev_warn(dev, "ACPI companion already set\n");
212 acpi_dev = ACPI_COMPANION(dev);
215 acpi_bus_get_device(handle, &acpi_dev);
221 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
222 if (!physical_node) {
227 mutex_lock(&acpi_dev->physical_node_lock);
230 * Keep the list sorted by node_id so that the IDs of removed nodes can
231 * be recycled easily.
233 physnode_list = &acpi_dev->physical_node_list;
235 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) {
237 if (pn->dev == dev) {
238 mutex_unlock(&acpi_dev->physical_node_lock);
240 dev_warn(dev, "Already associated with ACPI node\n");
241 kfree(physical_node);
242 if (ACPI_COMPANION(dev) != acpi_dev)
248 if (pn->node_id == node_id) {
249 physnode_list = &pn->node;
254 physical_node->node_id = node_id;
255 physical_node->dev = dev;
256 list_add(&physical_node->node, physnode_list);
257 acpi_dev->physical_node_count++;
259 if (!ACPI_COMPANION(dev))
260 ACPI_COMPANION_SET(dev, acpi_dev);
262 acpi_physnode_link_name(physical_node_name, node_id);
263 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
266 dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n",
267 physical_node_name, retval);
269 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
272 dev_err(dev, "Failed to create link firmware_node (%d)\n",
275 mutex_unlock(&acpi_dev->physical_node_lock);
277 if (acpi_dev->wakeup.flags.valid)
278 device_set_wakeup_capable(dev, true);
283 ACPI_COMPANION_SET(dev, NULL);
287 EXPORT_SYMBOL_GPL(acpi_bind_one);
289 int acpi_unbind_one(struct device *dev)
291 struct acpi_device *acpi_dev = ACPI_COMPANION(dev);
292 struct acpi_device_physical_node *entry;
297 mutex_lock(&acpi_dev->physical_node_lock);
299 list_for_each_entry(entry, &acpi_dev->physical_node_list, node)
300 if (entry->dev == dev) {
301 char physnode_name[PHYSICAL_NODE_NAME_SIZE];
303 list_del(&entry->node);
304 acpi_dev->physical_node_count--;
306 acpi_physnode_link_name(physnode_name, entry->node_id);
307 sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name);
308 sysfs_remove_link(&dev->kobj, "firmware_node");
309 ACPI_COMPANION_SET(dev, NULL);
310 /* acpi_bind_one() increase refcnt by one. */
316 mutex_unlock(&acpi_dev->physical_node_lock);
319 EXPORT_SYMBOL_GPL(acpi_unbind_one);
321 void acpi_preset_companion(struct device *dev, acpi_handle parent, u64 addr)
323 struct acpi_device *adev;
325 if (!acpi_bus_get_device(acpi_get_child(parent, addr), &adev))
326 ACPI_COMPANION_SET(dev, adev);
328 EXPORT_SYMBOL_GPL(acpi_preset_companion);
330 static int acpi_platform_notify(struct device *dev)
332 struct acpi_bus_type *type = acpi_get_bus_type(dev);
336 ret = acpi_bind_one(dev, NULL);
338 ret = type->find_device(dev, &handle);
340 DBG("Unable to get handle for %s\n", dev_name(dev));
343 ret = acpi_bind_one(dev, handle);
348 if (type && type->setup)
354 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
356 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer);
357 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
358 kfree(buffer.pointer);
360 DBG("Device %s -> No ACPI support\n", dev_name(dev));
366 static int acpi_platform_notify_remove(struct device *dev)
368 struct acpi_bus_type *type;
370 type = acpi_get_bus_type(dev);
371 if (type && type->cleanup)
374 acpi_unbind_one(dev);
378 int __init init_acpi_device_notify(void)
380 if (platform_notify || platform_notify_remove) {
381 printk(KERN_ERR PREFIX "Can't use platform_notify\n");
384 platform_notify = acpi_platform_notify;
385 platform_notify_remove = acpi_platform_notify_remove;