Commit | Line | Data |
---|---|---|
4e10d12a DSL |
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); | |
4be44fcd LB |
32 | printk(KERN_INFO PREFIX "bus type %s registered\n", |
33 | type->bus->name); | |
4e10d12a DSL |
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); | |
4be44fcd LB |
49 | printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n", |
50 | type->bus->name); | |
4e10d12a DSL |
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 | { | |
51b190b3 | 99 | unsigned long *busnr = (unsigned long *)data; |
4e10d12a DSL |
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; | |
51b190b3 | 118 | unsigned long bus, bbn; |
4e10d12a DSL |
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, | |
51b190b3 | 124 | &bbn); |
4e10d12a DSL |
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); | |
51b190b3 | 156 | return (int)bbn; |
4e10d12a DSL |
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 */ | |
4e10d12a DSL |
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) { | |
ef7b06cd | 316 | DBG("No ACPI bus support for %s\n", dev->bus_id); |
4e10d12a DSL |
317 | ret = -EINVAL; |
318 | goto end; | |
319 | } | |
320 | if ((ret = type->find_device(dev, &handle)) != 0) | |
ef7b06cd | 321 | DBG("Can't get handler for %s\n", dev->bus_id); |
4e10d12a DSL |
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); |