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
);
220 get_device(&acpi_dev
->dev
);
222 physical_node
= kzalloc(sizeof(*physical_node
), GFP_KERNEL
);
223 if (!physical_node
) {
228 mutex_lock(&acpi_dev
->physical_node_lock
);
231 * Keep the list sorted by node_id so that the IDs of removed nodes can
232 * be recycled easily.
234 physnode_list
= &acpi_dev
->physical_node_list
;
236 list_for_each_entry(pn
, &acpi_dev
->physical_node_list
, node
) {
238 if (pn
->dev
== dev
) {
239 mutex_unlock(&acpi_dev
->physical_node_lock
);
241 dev_warn(dev
, "Already associated with ACPI node\n");
242 kfree(physical_node
);
243 if (ACPI_COMPANION(dev
) != acpi_dev
)
247 put_device(&acpi_dev
->dev
);
250 if (pn
->node_id
== node_id
) {
251 physnode_list
= &pn
->node
;
256 physical_node
->node_id
= node_id
;
257 physical_node
->dev
= dev
;
258 list_add(&physical_node
->node
, physnode_list
);
259 acpi_dev
->physical_node_count
++;
261 if (!ACPI_COMPANION(dev
))
262 ACPI_COMPANION_SET(dev
, acpi_dev
);
264 acpi_physnode_link_name(physical_node_name
, node_id
);
265 retval
= sysfs_create_link(&acpi_dev
->dev
.kobj
, &dev
->kobj
,
268 dev_err(&acpi_dev
->dev
, "Failed to create link %s (%d)\n",
269 physical_node_name
, retval
);
271 retval
= sysfs_create_link(&dev
->kobj
, &acpi_dev
->dev
.kobj
,
274 dev_err(dev
, "Failed to create link firmware_node (%d)\n",
277 mutex_unlock(&acpi_dev
->physical_node_lock
);
279 if (acpi_dev
->wakeup
.flags
.valid
)
280 device_set_wakeup_capable(dev
, true);
285 ACPI_COMPANION_SET(dev
, NULL
);
287 put_device(&acpi_dev
->dev
);
290 EXPORT_SYMBOL_GPL(acpi_bind_one
);
292 int acpi_unbind_one(struct device
*dev
)
294 struct acpi_device
*acpi_dev
= ACPI_COMPANION(dev
);
295 struct acpi_device_physical_node
*entry
;
300 mutex_lock(&acpi_dev
->physical_node_lock
);
302 list_for_each_entry(entry
, &acpi_dev
->physical_node_list
, node
)
303 if (entry
->dev
== dev
) {
304 char physnode_name
[PHYSICAL_NODE_NAME_SIZE
];
306 list_del(&entry
->node
);
307 acpi_dev
->physical_node_count
--;
309 acpi_physnode_link_name(physnode_name
, entry
->node_id
);
310 sysfs_remove_link(&acpi_dev
->dev
.kobj
, physnode_name
);
311 sysfs_remove_link(&dev
->kobj
, "firmware_node");
312 ACPI_COMPANION_SET(dev
, NULL
);
313 /* Drop references taken by acpi_bind_one(). */
315 put_device(&acpi_dev
->dev
);
320 mutex_unlock(&acpi_dev
->physical_node_lock
);
323 EXPORT_SYMBOL_GPL(acpi_unbind_one
);
325 void acpi_preset_companion(struct device
*dev
, acpi_handle parent
, u64 addr
)
327 struct acpi_device
*adev
;
329 if (!acpi_bus_get_device(acpi_get_child(parent
, addr
), &adev
))
330 ACPI_COMPANION_SET(dev
, adev
);
332 EXPORT_SYMBOL_GPL(acpi_preset_companion
);
334 static int acpi_platform_notify(struct device
*dev
)
336 struct acpi_bus_type
*type
= acpi_get_bus_type(dev
);
340 ret
= acpi_bind_one(dev
, NULL
);
342 ret
= type
->find_device(dev
, &handle
);
344 DBG("Unable to get handle for %s\n", dev_name(dev
));
347 ret
= acpi_bind_one(dev
, handle
);
352 if (type
&& type
->setup
)
358 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
360 acpi_get_name(ACPI_HANDLE(dev
), ACPI_FULL_PATHNAME
, &buffer
);
361 DBG("Device %s -> %s\n", dev_name(dev
), (char *)buffer
.pointer
);
362 kfree(buffer
.pointer
);
364 DBG("Device %s -> No ACPI support\n", dev_name(dev
));
370 static int acpi_platform_notify_remove(struct device
*dev
)
372 struct acpi_bus_type
*type
;
374 type
= acpi_get_bus_type(dev
);
375 if (type
&& type
->cleanup
)
378 acpi_unbind_one(dev
);
382 int __init
init_acpi_device_notify(void)
384 if (platform_notify
|| platform_notify_remove
) {
385 printk(KERN_ERR PREFIX
"Can't use platform_notify\n");
388 platform_notify
= acpi_platform_notify
;
389 platform_notify_remove
= acpi_platform_notify_remove
;