Merge branch 'acpi-assorted'
[~shefty/rdma-dev.git] / drivers / acpi / glue.c
1 /*
2  * Link physical devices with ACPI devices support
3  *
4  * Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
5  * Copyright (c) 2005 Intel Corp.
6  *
7  * This file is released under the GPLv2.
8  */
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>
16
17 #include "internal.h"
18
19 #define ACPI_GLUE_DEBUG 0
20 #if ACPI_GLUE_DEBUG
21 #define DBG(fmt, ...)                                           \
22         printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__)
23 #else
24 #define DBG(fmt, ...)                                           \
25 do {                                                            \
26         if (0)                                                  \
27                 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__);   \
28 } while (0)
29 #endif
30 static LIST_HEAD(bus_type_list);
31 static DECLARE_RWSEM(bus_type_sem);
32
33 #define PHYSICAL_NODE_STRING "physical_node"
34
35 int register_acpi_bus_type(struct acpi_bus_type *type)
36 {
37         if (acpi_disabled)
38                 return -ENODEV;
39         if (type && type->bus && type->find_device) {
40                 down_write(&bus_type_sem);
41                 list_add_tail(&type->list, &bus_type_list);
42                 up_write(&bus_type_sem);
43                 printk(KERN_INFO PREFIX "bus type %s registered\n",
44                        type->bus->name);
45                 return 0;
46         }
47         return -ENODEV;
48 }
49 EXPORT_SYMBOL_GPL(register_acpi_bus_type);
50
51 int unregister_acpi_bus_type(struct acpi_bus_type *type)
52 {
53         if (acpi_disabled)
54                 return 0;
55         if (type) {
56                 down_write(&bus_type_sem);
57                 list_del_init(&type->list);
58                 up_write(&bus_type_sem);
59                 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
60                        type->bus->name);
61                 return 0;
62         }
63         return -ENODEV;
64 }
65 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
66
67 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
68 {
69         struct acpi_bus_type *tmp, *ret = NULL;
70
71         if (!type)
72                 return NULL;
73
74         down_read(&bus_type_sem);
75         list_for_each_entry(tmp, &bus_type_list, list) {
76                 if (tmp->bus == type) {
77                         ret = tmp;
78                         break;
79                 }
80         }
81         up_read(&bus_type_sem);
82         return ret;
83 }
84
85 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
86 {
87         struct acpi_bus_type *tmp;
88         int ret = -ENODEV;
89
90         down_read(&bus_type_sem);
91         list_for_each_entry(tmp, &bus_type_list, list) {
92                 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
93                         ret = 0;
94                         break;
95                 }
96         }
97         up_read(&bus_type_sem);
98         return ret;
99 }
100
101 static acpi_status do_acpi_find_child(acpi_handle handle, u32 lvl_not_used,
102                                       void *addr_p, void **ret_p)
103 {
104         unsigned long long addr;
105         acpi_status status;
106
107         status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr);
108         if (ACPI_SUCCESS(status) && addr == *((u64 *)addr_p)) {
109                 *ret_p = handle;
110                 return AE_CTRL_TERMINATE;
111         }
112         return AE_OK;
113 }
114
115 acpi_handle acpi_get_child(acpi_handle parent, u64 address)
116 {
117         void *ret = NULL;
118
119         if (!parent)
120                 return NULL;
121
122         acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, NULL,
123                             do_acpi_find_child, &address, &ret);
124         return (acpi_handle)ret;
125 }
126 EXPORT_SYMBOL(acpi_get_child);
127
128 static int acpi_bind_one(struct device *dev, acpi_handle handle)
129 {
130         struct acpi_device *acpi_dev;
131         acpi_status status;
132         struct acpi_device_physical_node *physical_node, *pn;
133         char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
134         int retval = -EINVAL;
135
136         if (ACPI_HANDLE(dev)) {
137                 if (handle) {
138                         dev_warn(dev, "ACPI handle is already set\n");
139                         return -EINVAL;
140                 } else {
141                         handle = ACPI_HANDLE(dev);
142                 }
143         }
144         if (!handle)
145                 return -EINVAL;
146
147         get_device(dev);
148         status = acpi_bus_get_device(handle, &acpi_dev);
149         if (ACPI_FAILURE(status))
150                 goto err;
151
152         physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
153         if (!physical_node) {
154                 retval = -ENOMEM;
155                 goto err;
156         }
157
158         mutex_lock(&acpi_dev->physical_node_lock);
159
160         /* Sanity check. */
161         list_for_each_entry(pn, &acpi_dev->physical_node_list, node)
162                 if (pn->dev == dev) {
163                         dev_warn(dev, "Already associated with ACPI node\n");
164                         goto err_free;
165                 }
166
167         /* allocate physical node id according to physical_node_id_bitmap */
168         physical_node->node_id =
169                 find_first_zero_bit(acpi_dev->physical_node_id_bitmap,
170                 ACPI_MAX_PHYSICAL_NODE);
171         if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) {
172                 retval = -ENOSPC;
173                 goto err_free;
174         }
175
176         set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap);
177         physical_node->dev = dev;
178         list_add_tail(&physical_node->node, &acpi_dev->physical_node_list);
179         acpi_dev->physical_node_count++;
180
181         mutex_unlock(&acpi_dev->physical_node_lock);
182
183         if (!ACPI_HANDLE(dev))
184                 ACPI_HANDLE_SET(dev, acpi_dev->handle);
185
186         if (!physical_node->node_id)
187                 strcpy(physical_node_name, PHYSICAL_NODE_STRING);
188         else
189                 sprintf(physical_node_name,
190                         "physical_node%d", physical_node->node_id);
191         retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
192                         physical_node_name);
193         retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
194                 "firmware_node");
195
196         if (acpi_dev->wakeup.flags.valid)
197                 device_set_wakeup_capable(dev, true);
198
199         return 0;
200
201  err:
202         ACPI_HANDLE_SET(dev, NULL);
203         put_device(dev);
204         return retval;
205
206  err_free:
207         mutex_unlock(&acpi_dev->physical_node_lock);
208         kfree(physical_node);
209         goto err;
210 }
211
212 static int acpi_unbind_one(struct device *dev)
213 {
214         struct acpi_device_physical_node *entry;
215         struct acpi_device *acpi_dev;
216         acpi_status status;
217         struct list_head *node, *next;
218
219         if (!ACPI_HANDLE(dev))
220                 return 0;
221
222         status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev);
223         if (ACPI_FAILURE(status))
224                 goto err;
225
226         mutex_lock(&acpi_dev->physical_node_lock);
227         list_for_each_safe(node, next, &acpi_dev->physical_node_list) {
228                 char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
229
230                 entry = list_entry(node, struct acpi_device_physical_node,
231                         node);
232                 if (entry->dev != dev)
233                         continue;
234
235                 list_del(node);
236                 clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap);
237
238                 acpi_dev->physical_node_count--;
239
240                 if (!entry->node_id)
241                         strcpy(physical_node_name, PHYSICAL_NODE_STRING);
242                 else
243                         sprintf(physical_node_name,
244                                 "physical_node%d", entry->node_id);
245
246                 sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name);
247                 sysfs_remove_link(&dev->kobj, "firmware_node");
248                 ACPI_HANDLE_SET(dev, NULL);
249                 /* acpi_bind_one increase refcnt by one */
250                 put_device(dev);
251                 kfree(entry);
252         }
253         mutex_unlock(&acpi_dev->physical_node_lock);
254
255         return 0;
256
257 err:
258         dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
259         return -EINVAL;
260 }
261
262 static int acpi_platform_notify(struct device *dev)
263 {
264         struct acpi_bus_type *type;
265         acpi_handle handle;
266         int ret;
267
268         ret = acpi_bind_one(dev, NULL);
269         if (ret && (!dev->bus || !dev->parent)) {
270                 /* bridge devices genernally haven't bus or parent */
271                 ret = acpi_find_bridge_device(dev, &handle);
272                 if (!ret) {
273                         ret = acpi_bind_one(dev, handle);
274                         if (ret)
275                                 goto out;
276                 }
277         }
278
279         type = acpi_get_bus_type(dev->bus);
280         if (ret) {
281                 if (!type || !type->find_device) {
282                         DBG("No ACPI bus support for %s\n", dev_name(dev));
283                         ret = -EINVAL;
284                         goto out;
285                 }
286
287                 ret = type->find_device(dev, &handle);
288                 if (ret) {
289                         DBG("Unable to get handle for %s\n", dev_name(dev));
290                         goto out;
291                 }
292                 ret = acpi_bind_one(dev, handle);
293                 if (ret)
294                         goto out;
295         }
296
297         if (type && type->setup)
298                 type->setup(dev);
299
300  out:
301 #if ACPI_GLUE_DEBUG
302         if (!ret) {
303                 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
304
305                 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer);
306                 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
307                 kfree(buffer.pointer);
308         } else
309                 DBG("Device %s -> No ACPI support\n", dev_name(dev));
310 #endif
311
312         return ret;
313 }
314
315 static int acpi_platform_notify_remove(struct device *dev)
316 {
317         struct acpi_bus_type *type;
318
319         type = acpi_get_bus_type(dev->bus);
320         if (type && type->cleanup)
321                 type->cleanup(dev);
322
323         acpi_unbind_one(dev);
324         return 0;
325 }
326
327 int __init init_acpi_device_notify(void)
328 {
329         if (platform_notify || platform_notify_remove) {
330                 printk(KERN_ERR PREFIX "Can't use platform_notify\n");
331                 return 0;
332         }
333         platform_notify = acpi_platform_notify;
334         platform_notify_remove = acpi_platform_notify_remove;
335         return 0;
336 }