xref: /openbmc/linux/drivers/acpi/glue.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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/init.h>
10 #include <linux/list.h>
11 #include <linux/device.h>
12 #include <linux/rwsem.h>
13 #include <linux/acpi.h>
14 
15 #define ACPI_GLUE_DEBUG	0
16 #if ACPI_GLUE_DEBUG
17 #define DBG(x...) printk(PREFIX x)
18 #else
19 #define DBG(x...)
20 #endif
21 static LIST_HEAD(bus_type_list);
22 static DECLARE_RWSEM(bus_type_sem);
23 
24 int register_acpi_bus_type(struct acpi_bus_type *type)
25 {
26 	if (acpi_disabled)
27 		return -ENODEV;
28 	if (type && type->bus && type->find_device) {
29 		down_write(&bus_type_sem);
30 		list_add_tail(&type->list, &bus_type_list);
31 		up_write(&bus_type_sem);
32 		printk(KERN_INFO PREFIX "bus type %s registered\n",
33 		       type->bus->name);
34 		return 0;
35 	}
36 	return -ENODEV;
37 }
38 
39 EXPORT_SYMBOL(register_acpi_bus_type);
40 
41 int unregister_acpi_bus_type(struct acpi_bus_type *type)
42 {
43 	if (acpi_disabled)
44 		return 0;
45 	if (type) {
46 		down_write(&bus_type_sem);
47 		list_del_init(&type->list);
48 		up_write(&bus_type_sem);
49 		printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
50 		       type->bus->name);
51 		return 0;
52 	}
53 	return -ENODEV;
54 }
55 
56 EXPORT_SYMBOL(unregister_acpi_bus_type);
57 
58 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
59 {
60 	struct acpi_bus_type *tmp, *ret = NULL;
61 
62 	down_read(&bus_type_sem);
63 	list_for_each_entry(tmp, &bus_type_list, list) {
64 		if (tmp->bus == type) {
65 			ret = tmp;
66 			break;
67 		}
68 	}
69 	up_read(&bus_type_sem);
70 	return ret;
71 }
72 
73 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
74 {
75 	struct acpi_bus_type *tmp;
76 	int ret = -ENODEV;
77 
78 	down_read(&bus_type_sem);
79 	list_for_each_entry(tmp, &bus_type_list, list) {
80 		if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
81 			ret = 0;
82 			break;
83 		}
84 	}
85 	up_read(&bus_type_sem);
86 	return ret;
87 }
88 
89 /* Get PCI root bridge's handle from its segment and bus number */
90 struct acpi_find_pci_root {
91 	unsigned int seg;
92 	unsigned int bus;
93 	acpi_handle handle;
94 };
95 
96 static acpi_status
97 do_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
98 {
99 	unsigned long *busnr = (unsigned long *)data;
100 	struct acpi_resource_address64 address;
101 
102 	if (resource->id != ACPI_RSTYPE_ADDRESS16 &&
103 	    resource->id != ACPI_RSTYPE_ADDRESS32 &&
104 	    resource->id != ACPI_RSTYPE_ADDRESS64)
105 		return AE_OK;
106 
107 	acpi_resource_to_address64(resource, &address);
108 	if ((address.address_length > 0) &&
109 	    (address.resource_type == ACPI_BUS_NUMBER_RANGE))
110 		*busnr = address.min_address_range;
111 
112 	return AE_OK;
113 }
114 
115 static int get_root_bridge_busnr(acpi_handle handle)
116 {
117 	acpi_status status;
118 	unsigned long bus, bbn;
119 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
120 
121 	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
122 
123 	status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL,
124 				       &bbn);
125 	if (status == AE_NOT_FOUND) {
126 		/* Assume bus = 0 */
127 		printk(KERN_INFO PREFIX
128 		       "Assume root bridge [%s] bus is 0\n",
129 		       (char *)buffer.pointer);
130 		status = AE_OK;
131 		bbn = 0;
132 	}
133 	if (ACPI_FAILURE(status)) {
134 		bbn = -ENODEV;
135 		goto exit;
136 	}
137 	if (bbn > 0)
138 		goto exit;
139 
140 	/* _BBN in some systems return 0 for all root bridges */
141 	bus = -1;
142 	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
143 				     do_root_bridge_busnr_callback, &bus);
144 	/* If _CRS failed, we just use _BBN */
145 	if (ACPI_FAILURE(status) || (bus == -1))
146 		goto exit;
147 	/* We select _CRS */
148 	if (bbn != bus) {
149 		printk(KERN_INFO PREFIX
150 		       "_BBN and _CRS returns different value for %s. Select _CRS\n",
151 		       (char *)buffer.pointer);
152 		bbn = bus;
153 	}
154       exit:
155 	acpi_os_free(buffer.pointer);
156 	return (int)bbn;
157 }
158 
159 static acpi_status
160 find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv)
161 {
162 	struct acpi_find_pci_root *find = (struct acpi_find_pci_root *)context;
163 	unsigned long seg, bus;
164 	acpi_status status;
165 	int tmp;
166 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
167 
168 	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
169 
170 	status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &seg);
171 	if (status == AE_NOT_FOUND) {
172 		/* Assume seg = 0 */
173 		status = AE_OK;
174 		seg = 0;
175 	}
176 	if (ACPI_FAILURE(status)) {
177 		status = AE_CTRL_DEPTH;
178 		goto exit;
179 	}
180 
181 	tmp = get_root_bridge_busnr(handle);
182 	if (tmp < 0) {
183 		printk(KERN_ERR PREFIX
184 		       "Find root bridge failed for %s\n",
185 		       (char *)buffer.pointer);
186 		status = AE_CTRL_DEPTH;
187 		goto exit;
188 	}
189 	bus = tmp;
190 
191 	if (seg == find->seg && bus == find->bus)
192 		find->handle = handle;
193 	status = AE_OK;
194       exit:
195 	acpi_os_free(buffer.pointer);
196 	return status;
197 }
198 
199 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
200 {
201 	struct acpi_find_pci_root find = { seg, bus, NULL };
202 
203 	acpi_get_devices(PCI_ROOT_HID_STRING, find_pci_rootbridge, &find, NULL);
204 	return find.handle;
205 }
206 
207 /* Get device's handler per its address under its parent */
208 struct acpi_find_child {
209 	acpi_handle handle;
210 	acpi_integer address;
211 };
212 
213 static acpi_status
214 do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
215 {
216 	acpi_status status;
217 	struct acpi_device_info *info;
218 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
219 	struct acpi_find_child *find = (struct acpi_find_child *)context;
220 
221 	status = acpi_get_object_info(handle, &buffer);
222 	if (ACPI_SUCCESS(status)) {
223 		info = buffer.pointer;
224 		if (info->address == find->address)
225 			find->handle = handle;
226 		acpi_os_free(buffer.pointer);
227 	}
228 	return AE_OK;
229 }
230 
231 acpi_handle acpi_get_child(acpi_handle parent, acpi_integer address)
232 {
233 	struct acpi_find_child find = { NULL, address };
234 
235 	if (!parent)
236 		return NULL;
237 	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
238 			    1, do_acpi_find_child, &find, NULL);
239 	return find.handle;
240 }
241 
242 EXPORT_SYMBOL(acpi_get_child);
243 
244 /* Link ACPI devices with physical devices */
245 static void acpi_glue_data_handler(acpi_handle handle,
246 				   u32 function, void *context)
247 {
248 	/* we provide an empty handler */
249 }
250 
251 /* Note: a success call will increase reference count by one */
252 struct device *acpi_get_physical_device(acpi_handle handle)
253 {
254 	acpi_status status;
255 	struct device *dev;
256 
257 	status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
258 	if (ACPI_SUCCESS(status))
259 		return get_device(dev);
260 	return NULL;
261 }
262 
263 EXPORT_SYMBOL(acpi_get_physical_device);
264 
265 static int acpi_bind_one(struct device *dev, acpi_handle handle)
266 {
267 	acpi_status status;
268 
269 	if (dev->firmware_data) {
270 		printk(KERN_WARNING PREFIX
271 		       "Drivers changed 'firmware_data' for %s\n", dev->bus_id);
272 		return -EINVAL;
273 	}
274 	get_device(dev);
275 	status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
276 	if (ACPI_FAILURE(status)) {
277 		put_device(dev);
278 		return -EINVAL;
279 	}
280 	dev->firmware_data = handle;
281 
282 	return 0;
283 }
284 
285 static int acpi_unbind_one(struct device *dev)
286 {
287 	if (!dev->firmware_data)
288 		return 0;
289 	if (dev == acpi_get_physical_device(dev->firmware_data)) {
290 		/* acpi_get_physical_device increase refcnt by one */
291 		put_device(dev);
292 		acpi_detach_data(dev->firmware_data, acpi_glue_data_handler);
293 		dev->firmware_data = NULL;
294 		/* acpi_bind_one increase refcnt by one */
295 		put_device(dev);
296 	} else {
297 		printk(KERN_ERR PREFIX
298 		       "Oops, 'firmware_data' corrupt for %s\n", dev->bus_id);
299 	}
300 	return 0;
301 }
302 
303 static int acpi_platform_notify(struct device *dev)
304 {
305 	struct acpi_bus_type *type;
306 	acpi_handle handle;
307 	int ret = -EINVAL;
308 
309 	if (!dev->bus || !dev->parent) {
310 		/* bridge devices genernally haven't bus or parent */
311 		ret = acpi_find_bridge_device(dev, &handle);
312 		goto end;
313 	}
314 	type = acpi_get_bus_type(dev->bus);
315 	if (!type) {
316 		DBG("No ACPI bus support for %s\n", dev->bus_id);
317 		ret = -EINVAL;
318 		goto end;
319 	}
320 	if ((ret = type->find_device(dev, &handle)) != 0)
321 		DBG("Can't get handler for %s\n", dev->bus_id);
322       end:
323 	if (!ret)
324 		acpi_bind_one(dev, handle);
325 
326 #if ACPI_GLUE_DEBUG
327 	if (!ret) {
328 		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
329 
330 		acpi_get_name(dev->firmware_data, ACPI_FULL_PATHNAME, &buffer);
331 		DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer);
332 		acpi_os_free(buffer.pointer);
333 	} else
334 		DBG("Device %s -> No ACPI support\n", dev->bus_id);
335 #endif
336 
337 	return ret;
338 }
339 
340 static int acpi_platform_notify_remove(struct device *dev)
341 {
342 	acpi_unbind_one(dev);
343 	return 0;
344 }
345 
346 static int __init init_acpi_device_notify(void)
347 {
348 	if (acpi_disabled)
349 		return 0;
350 	if (platform_notify || platform_notify_remove) {
351 		printk(KERN_ERR PREFIX "Can't use platform_notify\n");
352 		return 0;
353 	}
354 	platform_notify = acpi_platform_notify;
355 	platform_notify_remove = acpi_platform_notify_remove;
356 	return 0;
357 }
358 
359 arch_initcall(init_acpi_device_notify);
360