xref: /openbmc/linux/drivers/acpi/glue.c (revision b34081f1)
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 #define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10)
35 
36 int register_acpi_bus_type(struct acpi_bus_type *type)
37 {
38 	if (acpi_disabled)
39 		return -ENODEV;
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);
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 "bus type %s unregistered\n",
60 		       type->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 device *dev)
68 {
69 	struct acpi_bus_type *tmp, *ret = NULL;
70 
71 	down_read(&bus_type_sem);
72 	list_for_each_entry(tmp, &bus_type_list, list) {
73 		if (tmp->match(dev)) {
74 			ret = tmp;
75 			break;
76 		}
77 	}
78 	up_read(&bus_type_sem);
79 	return ret;
80 }
81 
82 static acpi_status acpi_dev_present(acpi_handle handle, u32 lvl_not_used,
83 				  void *not_used, void **ret_p)
84 {
85 	struct acpi_device *adev = NULL;
86 
87 	acpi_bus_get_device(handle, &adev);
88 	if (adev) {
89 		*ret_p = handle;
90 		return AE_CTRL_TERMINATE;
91 	}
92 	return AE_OK;
93 }
94 
95 static bool acpi_extra_checks_passed(acpi_handle handle, bool is_bridge)
96 {
97 	unsigned long long sta;
98 	acpi_status status;
99 
100 	status = acpi_bus_get_status_handle(handle, &sta);
101 	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED))
102 		return false;
103 
104 	if (is_bridge) {
105 		void *test = NULL;
106 
107 		/* Check if this object has at least one child device. */
108 		acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
109 				    acpi_dev_present, NULL, NULL, &test);
110 		return !!test;
111 	}
112 	return true;
113 }
114 
115 struct find_child_context {
116 	u64 addr;
117 	bool is_bridge;
118 	acpi_handle ret;
119 	bool ret_checked;
120 };
121 
122 static acpi_status do_find_child(acpi_handle handle, u32 lvl_not_used,
123 				 void *data, void **not_used)
124 {
125 	struct find_child_context *context = data;
126 	unsigned long long addr;
127 	acpi_status status;
128 
129 	status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr);
130 	if (ACPI_FAILURE(status) || addr != context->addr)
131 		return AE_OK;
132 
133 	if (!context->ret) {
134 		/* This is the first matching object.  Save its handle. */
135 		context->ret = handle;
136 		return AE_OK;
137 	}
138 	/*
139 	 * There is more than one matching object with the same _ADR value.
140 	 * That really is unexpected, so we are kind of beyond the scope of the
141 	 * spec here.  We have to choose which one to return, though.
142 	 *
143 	 * First, check if the previously found object is good enough and return
144 	 * its handle if so.  Second, check the same for the object that we've
145 	 * just found.
146 	 */
147 	if (!context->ret_checked) {
148 		if (acpi_extra_checks_passed(context->ret, context->is_bridge))
149 			return AE_CTRL_TERMINATE;
150 		else
151 			context->ret_checked = true;
152 	}
153 	if (acpi_extra_checks_passed(handle, context->is_bridge)) {
154 		context->ret = handle;
155 		return AE_CTRL_TERMINATE;
156 	}
157 	return AE_OK;
158 }
159 
160 acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge)
161 {
162 	if (parent) {
163 		struct find_child_context context = {
164 			.addr = addr,
165 			.is_bridge = is_bridge,
166 		};
167 
168 		acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, do_find_child,
169 				    NULL, &context, NULL);
170 		return context.ret;
171 	}
172 	return NULL;
173 }
174 EXPORT_SYMBOL_GPL(acpi_find_child);
175 
176 static void acpi_physnode_link_name(char *buf, unsigned int node_id)
177 {
178 	if (node_id > 0)
179 		snprintf(buf, PHYSICAL_NODE_NAME_SIZE,
180 			 PHYSICAL_NODE_STRING "%u", node_id);
181 	else
182 		strcpy(buf, PHYSICAL_NODE_STRING);
183 }
184 
185 int acpi_bind_one(struct device *dev, acpi_handle handle)
186 {
187 	struct acpi_device *acpi_dev;
188 	acpi_status status;
189 	struct acpi_device_physical_node *physical_node, *pn;
190 	char physical_node_name[PHYSICAL_NODE_NAME_SIZE];
191 	struct list_head *physnode_list;
192 	unsigned int node_id;
193 	int retval = -EINVAL;
194 
195 	if (ACPI_HANDLE(dev)) {
196 		if (handle) {
197 			dev_warn(dev, "ACPI handle is already set\n");
198 			return -EINVAL;
199 		} else {
200 			handle = ACPI_HANDLE(dev);
201 		}
202 	}
203 	if (!handle)
204 		return -EINVAL;
205 
206 	get_device(dev);
207 	status = acpi_bus_get_device(handle, &acpi_dev);
208 	if (ACPI_FAILURE(status))
209 		goto err;
210 
211 	physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
212 	if (!physical_node) {
213 		retval = -ENOMEM;
214 		goto err;
215 	}
216 
217 	mutex_lock(&acpi_dev->physical_node_lock);
218 
219 	/*
220 	 * Keep the list sorted by node_id so that the IDs of removed nodes can
221 	 * be recycled easily.
222 	 */
223 	physnode_list = &acpi_dev->physical_node_list;
224 	node_id = 0;
225 	list_for_each_entry(pn, &acpi_dev->physical_node_list, node) {
226 		/* Sanity check. */
227 		if (pn->dev == dev) {
228 			mutex_unlock(&acpi_dev->physical_node_lock);
229 
230 			dev_warn(dev, "Already associated with ACPI node\n");
231 			kfree(physical_node);
232 			if (ACPI_HANDLE(dev) != handle)
233 				goto err;
234 
235 			put_device(dev);
236 			return 0;
237 		}
238 		if (pn->node_id == node_id) {
239 			physnode_list = &pn->node;
240 			node_id++;
241 		}
242 	}
243 
244 	physical_node->node_id = node_id;
245 	physical_node->dev = dev;
246 	list_add(&physical_node->node, physnode_list);
247 	acpi_dev->physical_node_count++;
248 
249 	if (!ACPI_HANDLE(dev))
250 		ACPI_HANDLE_SET(dev, acpi_dev->handle);
251 
252 	acpi_physnode_link_name(physical_node_name, node_id);
253 	retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
254 				   physical_node_name);
255 	if (retval)
256 		dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n",
257 			physical_node_name, retval);
258 
259 	retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
260 				   "firmware_node");
261 	if (retval)
262 		dev_err(dev, "Failed to create link firmware_node (%d)\n",
263 			retval);
264 
265 	mutex_unlock(&acpi_dev->physical_node_lock);
266 
267 	if (acpi_dev->wakeup.flags.valid)
268 		device_set_wakeup_capable(dev, true);
269 
270 	return 0;
271 
272  err:
273 	ACPI_HANDLE_SET(dev, NULL);
274 	put_device(dev);
275 	return retval;
276 }
277 EXPORT_SYMBOL_GPL(acpi_bind_one);
278 
279 int acpi_unbind_one(struct device *dev)
280 {
281 	struct acpi_device_physical_node *entry;
282 	struct acpi_device *acpi_dev;
283 	acpi_status status;
284 
285 	if (!ACPI_HANDLE(dev))
286 		return 0;
287 
288 	status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev);
289 	if (ACPI_FAILURE(status)) {
290 		dev_err(dev, "Oops, ACPI handle corrupt in %s()\n", __func__);
291 		return -EINVAL;
292 	}
293 
294 	mutex_lock(&acpi_dev->physical_node_lock);
295 
296 	list_for_each_entry(entry, &acpi_dev->physical_node_list, node)
297 		if (entry->dev == dev) {
298 			char physnode_name[PHYSICAL_NODE_NAME_SIZE];
299 
300 			list_del(&entry->node);
301 			acpi_dev->physical_node_count--;
302 
303 			acpi_physnode_link_name(physnode_name, entry->node_id);
304 			sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name);
305 			sysfs_remove_link(&dev->kobj, "firmware_node");
306 			ACPI_HANDLE_SET(dev, NULL);
307 			/* acpi_bind_one() increase refcnt by one. */
308 			put_device(dev);
309 			kfree(entry);
310 			break;
311 		}
312 
313 	mutex_unlock(&acpi_dev->physical_node_lock);
314 	return 0;
315 }
316 EXPORT_SYMBOL_GPL(acpi_unbind_one);
317 
318 static int acpi_platform_notify(struct device *dev)
319 {
320 	struct acpi_bus_type *type = acpi_get_bus_type(dev);
321 	acpi_handle handle;
322 	int ret;
323 
324 	ret = acpi_bind_one(dev, NULL);
325 	if (ret && type) {
326 		ret = type->find_device(dev, &handle);
327 		if (ret) {
328 			DBG("Unable to get handle for %s\n", dev_name(dev));
329 			goto out;
330 		}
331 		ret = acpi_bind_one(dev, handle);
332 		if (ret)
333 			goto out;
334 	}
335 
336 	if (type && type->setup)
337 		type->setup(dev);
338 
339  out:
340 #if ACPI_GLUE_DEBUG
341 	if (!ret) {
342 		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
343 
344 		acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer);
345 		DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
346 		kfree(buffer.pointer);
347 	} else
348 		DBG("Device %s -> No ACPI support\n", dev_name(dev));
349 #endif
350 
351 	return ret;
352 }
353 
354 static int acpi_platform_notify_remove(struct device *dev)
355 {
356 	struct acpi_bus_type *type;
357 
358 	type = acpi_get_bus_type(dev);
359 	if (type && type->cleanup)
360 		type->cleanup(dev);
361 
362 	acpi_unbind_one(dev);
363 	return 0;
364 }
365 
366 int __init init_acpi_device_notify(void)
367 {
368 	if (platform_notify || platform_notify_remove) {
369 		printk(KERN_ERR PREFIX "Can't use platform_notify\n");
370 		return 0;
371 	}
372 	platform_notify = acpi_platform_notify;
373 	platform_notify_remove = acpi_platform_notify_remove;
374 	return 0;
375 }
376