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