Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: evrgnini- ACPI address_space (op_region) init | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
75a44ce0 | 8 | * Copyright (C) 2000 - 2008, Intel Corp. |
1da177e4 LT |
9 | * All rights reserved. |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or without | |
12 | * modification, are permitted provided that the following conditions | |
13 | * are met: | |
14 | * 1. Redistributions of source code must retain the above copyright | |
15 | * notice, this list of conditions, and the following disclaimer, | |
16 | * without modification. | |
17 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | |
18 | * substantially similar to the "NO WARRANTY" disclaimer below | |
19 | * ("Disclaimer") and any redistribution must be conditioned upon | |
20 | * including a substantially similar Disclaimer requirement for further | |
21 | * binary redistribution. | |
22 | * 3. Neither the names of the above-listed copyright holders nor the names | |
23 | * of any contributors may be used to endorse or promote products derived | |
24 | * from this software without specific prior written permission. | |
25 | * | |
26 | * Alternatively, this software may be distributed under the terms of the | |
27 | * GNU General Public License ("GPL") version 2 as published by the Free | |
28 | * Software Foundation. | |
29 | * | |
30 | * NO WARRANTY | |
31 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
32 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
33 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | |
34 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
35 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
36 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
37 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
38 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
39 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
40 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
41 | * POSSIBILITY OF SUCH DAMAGES. | |
42 | */ | |
43 | ||
1da177e4 | 44 | #include <acpi/acpi.h> |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "acevents.h" | |
47 | #include "acnamesp.h" | |
1da177e4 LT |
48 | |
49 | #define _COMPONENT ACPI_EVENTS | |
4be44fcd | 50 | ACPI_MODULE_NAME("evrgnini") |
1da177e4 | 51 | |
b7a69806 BM |
52 | /* Local prototypes */ |
53 | static u8 acpi_ev_match_pci_root_bridge(char *id); | |
54 | ||
55 | static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node); | |
56 | ||
1da177e4 LT |
57 | /******************************************************************************* |
58 | * | |
59 | * FUNCTION: acpi_ev_system_memory_region_setup | |
60 | * | |
61 | * PARAMETERS: Handle - Region we are interested in | |
62 | * Function - Start or stop | |
63 | * handler_context - Address space handler context | |
64 | * region_context - Region specific context | |
65 | * | |
66 | * RETURN: Status | |
67 | * | |
44f6c012 | 68 | * DESCRIPTION: Setup a system_memory operation region |
1da177e4 LT |
69 | * |
70 | ******************************************************************************/ | |
b7a69806 | 71 | |
1da177e4 | 72 | acpi_status |
4be44fcd LB |
73 | acpi_ev_system_memory_region_setup(acpi_handle handle, |
74 | u32 function, | |
75 | void *handler_context, void **region_context) | |
1da177e4 | 76 | { |
4be44fcd LB |
77 | union acpi_operand_object *region_desc = |
78 | (union acpi_operand_object *)handle; | |
79 | struct acpi_mem_space_context *local_region_context; | |
1da177e4 | 80 | |
b229cf92 | 81 | ACPI_FUNCTION_TRACE(ev_system_memory_region_setup); |
1da177e4 LT |
82 | |
83 | if (function == ACPI_REGION_DEACTIVATE) { | |
84 | if (*region_context) { | |
793c2388 BM |
85 | local_region_context = |
86 | (struct acpi_mem_space_context *)*region_context; | |
87 | ||
88 | /* Delete a cached mapping if present */ | |
89 | ||
90 | if (local_region_context->mapped_length) { | |
91 | acpi_os_unmap_memory(local_region_context-> | |
92 | mapped_logical_address, | |
93 | local_region_context-> | |
94 | mapped_length); | |
95 | } | |
96 | ACPI_FREE(local_region_context); | |
1da177e4 LT |
97 | *region_context = NULL; |
98 | } | |
4be44fcd | 99 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
100 | } |
101 | ||
102 | /* Create a new context */ | |
103 | ||
4be44fcd | 104 | local_region_context = |
8313524a | 105 | ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context)); |
1da177e4 | 106 | if (!(local_region_context)) { |
4be44fcd | 107 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
108 | } |
109 | ||
110 | /* Save the region length and address for use in the handler */ | |
111 | ||
112 | local_region_context->length = region_desc->region.length; | |
113 | local_region_context->address = region_desc->region.address; | |
114 | ||
115 | *region_context = local_region_context; | |
4be44fcd | 116 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
117 | } |
118 | ||
1da177e4 LT |
119 | /******************************************************************************* |
120 | * | |
121 | * FUNCTION: acpi_ev_io_space_region_setup | |
122 | * | |
123 | * PARAMETERS: Handle - Region we are interested in | |
124 | * Function - Start or stop | |
125 | * handler_context - Address space handler context | |
126 | * region_context - Region specific context | |
127 | * | |
128 | * RETURN: Status | |
129 | * | |
44f6c012 | 130 | * DESCRIPTION: Setup a IO operation region |
1da177e4 LT |
131 | * |
132 | ******************************************************************************/ | |
133 | ||
134 | acpi_status | |
4be44fcd LB |
135 | acpi_ev_io_space_region_setup(acpi_handle handle, |
136 | u32 function, | |
137 | void *handler_context, void **region_context) | |
1da177e4 | 138 | { |
b229cf92 | 139 | ACPI_FUNCTION_TRACE(ev_io_space_region_setup); |
1da177e4 LT |
140 | |
141 | if (function == ACPI_REGION_DEACTIVATE) { | |
142 | *region_context = NULL; | |
4be44fcd | 143 | } else { |
1da177e4 LT |
144 | *region_context = handler_context; |
145 | } | |
146 | ||
4be44fcd | 147 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
148 | } |
149 | ||
1da177e4 LT |
150 | /******************************************************************************* |
151 | * | |
152 | * FUNCTION: acpi_ev_pci_config_region_setup | |
153 | * | |
44f6c012 | 154 | * PARAMETERS: Handle - Region we are interested in |
1da177e4 LT |
155 | * Function - Start or stop |
156 | * handler_context - Address space handler context | |
157 | * region_context - Region specific context | |
158 | * | |
159 | * RETURN: Status | |
160 | * | |
44f6c012 | 161 | * DESCRIPTION: Setup a PCI_Config operation region |
1da177e4 LT |
162 | * |
163 | * MUTEX: Assumes namespace is not locked | |
164 | * | |
165 | ******************************************************************************/ | |
166 | ||
167 | acpi_status | |
4be44fcd LB |
168 | acpi_ev_pci_config_region_setup(acpi_handle handle, |
169 | u32 function, | |
170 | void *handler_context, void **region_context) | |
1da177e4 | 171 | { |
4be44fcd LB |
172 | acpi_status status = AE_OK; |
173 | acpi_integer pci_value; | |
174 | struct acpi_pci_id *pci_id = *region_context; | |
175 | union acpi_operand_object *handler_obj; | |
176 | struct acpi_namespace_node *parent_node; | |
177 | struct acpi_namespace_node *pci_root_node; | |
b7a69806 | 178 | struct acpi_namespace_node *pci_device_node; |
4be44fcd LB |
179 | union acpi_operand_object *region_obj = |
180 | (union acpi_operand_object *)handle; | |
4be44fcd | 181 | |
b229cf92 | 182 | ACPI_FUNCTION_TRACE(ev_pci_config_region_setup); |
1da177e4 LT |
183 | |
184 | handler_obj = region_obj->region.handler; | |
185 | if (!handler_obj) { | |
186 | /* | |
187 | * No installed handler. This shouldn't happen because the dispatch | |
188 | * routine checks before we get here, but we check again just in case. | |
189 | */ | |
4be44fcd LB |
190 | ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, |
191 | "Attempting to init a region %p, with no handler\n", | |
192 | region_obj)); | |
193 | return_ACPI_STATUS(AE_NOT_EXIST); | |
1da177e4 LT |
194 | } |
195 | ||
196 | *region_context = NULL; | |
197 | if (function == ACPI_REGION_DEACTIVATE) { | |
198 | if (pci_id) { | |
8313524a | 199 | ACPI_FREE(pci_id); |
1da177e4 | 200 | } |
4be44fcd | 201 | return_ACPI_STATUS(status); |
1da177e4 LT |
202 | } |
203 | ||
4be44fcd | 204 | parent_node = acpi_ns_get_parent_node(region_obj->region.node); |
1da177e4 LT |
205 | |
206 | /* | |
207 | * Get the _SEG and _BBN values from the device upon which the handler | |
208 | * is installed. | |
209 | * | |
210 | * We need to get the _SEG and _BBN objects relative to the PCI BUS device. | |
211 | * This is the device the handler has been registered to handle. | |
212 | */ | |
213 | ||
214 | /* | |
215 | * If the address_space.Node is still pointing to the root, we need | |
216 | * to scan upward for a PCI Root bridge and re-associate the op_region | |
217 | * handlers with that device. | |
218 | */ | |
219 | if (handler_obj->address_space.node == acpi_gbl_root_node) { | |
52fc0b02 | 220 | |
1da177e4 LT |
221 | /* Start search from the parent object */ |
222 | ||
223 | pci_root_node = parent_node; | |
224 | while (pci_root_node != acpi_gbl_root_node) { | |
b7a69806 BM |
225 | |
226 | /* Get the _HID/_CID in order to detect a root_bridge */ | |
227 | ||
228 | if (acpi_ev_is_pci_root_bridge(pci_root_node)) { | |
229 | ||
230 | /* Install a handler for this PCI root bridge */ | |
231 | ||
fd350943 LB |
232 | status = |
233 | acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); | |
b7a69806 BM |
234 | if (ACPI_FAILURE(status)) { |
235 | if (status == AE_SAME_HANDLER) { | |
236 | /* | |
9f15fc66 BM |
237 | * It is OK if the handler is already installed on the |
238 | * root bridge. Still need to return a context object | |
239 | * for the new PCI_Config operation region, however. | |
b7a69806 BM |
240 | */ |
241 | status = AE_OK; | |
242 | } else { | |
243 | ACPI_EXCEPTION((AE_INFO, status, | |
244 | "Could not install PciConfig handler for Root Bridge %4.4s", | |
245 | acpi_ut_get_node_name | |
246 | (pci_root_node))); | |
1da177e4 | 247 | } |
1da177e4 | 248 | } |
b7a69806 | 249 | break; |
1da177e4 LT |
250 | } |
251 | ||
4be44fcd | 252 | pci_root_node = acpi_ns_get_parent_node(pci_root_node); |
1da177e4 LT |
253 | } |
254 | ||
255 | /* PCI root bridge not found, use namespace root node */ | |
4be44fcd | 256 | } else { |
1da177e4 LT |
257 | pci_root_node = handler_obj->address_space.node; |
258 | } | |
259 | ||
260 | /* | |
261 | * If this region is now initialized, we are done. | |
262 | * (install_address_space_handler could have initialized it) | |
263 | */ | |
264 | if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) { | |
4be44fcd | 265 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
266 | } |
267 | ||
268 | /* Region is still not initialized. Create a new context */ | |
269 | ||
8313524a | 270 | pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id)); |
1da177e4 | 271 | if (!pci_id) { |
4be44fcd | 272 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
273 | } |
274 | ||
275 | /* | |
9f15fc66 BM |
276 | * For PCI_Config space access, we need the segment, bus, device and |
277 | * function numbers. Acquire them here. | |
b7a69806 BM |
278 | * |
279 | * Find the parent device object. (This allows the operation region to be | |
280 | * within a subscope under the device, such as a control method.) | |
1da177e4 | 281 | */ |
b7a69806 BM |
282 | pci_device_node = region_obj->region.node; |
283 | while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) { | |
284 | pci_device_node = acpi_ns_get_parent_node(pci_device_node); | |
285 | } | |
286 | ||
287 | if (!pci_device_node) { | |
e6917317 | 288 | ACPI_FREE(pci_id); |
b7a69806 BM |
289 | return_ACPI_STATUS(AE_AML_OPERAND_TYPE); |
290 | } | |
1da177e4 LT |
291 | |
292 | /* | |
9f15fc66 BM |
293 | * Get the PCI device and function numbers from the _ADR object contained |
294 | * in the parent's scope. | |
1da177e4 | 295 | */ |
4be44fcd | 296 | status = |
b7a69806 | 297 | acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, pci_device_node, |
4be44fcd | 298 | &pci_value); |
1da177e4 LT |
299 | |
300 | /* | |
9f15fc66 BM |
301 | * The default is zero, and since the allocation above zeroed the data, |
302 | * just do nothing on failure. | |
1da177e4 | 303 | */ |
4be44fcd LB |
304 | if (ACPI_SUCCESS(status)) { |
305 | pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value)); | |
306 | pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value)); | |
1da177e4 LT |
307 | } |
308 | ||
309 | /* The PCI segment number comes from the _SEG method */ | |
310 | ||
4be44fcd LB |
311 | status = |
312 | acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, pci_root_node, | |
313 | &pci_value); | |
314 | if (ACPI_SUCCESS(status)) { | |
315 | pci_id->segment = ACPI_LOWORD(pci_value); | |
1da177e4 LT |
316 | } |
317 | ||
318 | /* The PCI bus number comes from the _BBN method */ | |
319 | ||
4be44fcd LB |
320 | status = |
321 | acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, pci_root_node, | |
322 | &pci_value); | |
323 | if (ACPI_SUCCESS(status)) { | |
324 | pci_id->bus = ACPI_LOWORD(pci_value); | |
1da177e4 LT |
325 | } |
326 | ||
327 | /* Complete this device's pci_id */ | |
328 | ||
4be44fcd | 329 | acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id); |
1da177e4 LT |
330 | |
331 | *region_context = pci_id; | |
4be44fcd | 332 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
333 | } |
334 | ||
b7a69806 BM |
335 | /******************************************************************************* |
336 | * | |
337 | * FUNCTION: acpi_ev_match_pci_root_bridge | |
338 | * | |
339 | * PARAMETERS: Id - The HID/CID in string format | |
340 | * | |
341 | * RETURN: TRUE if the Id is a match for a PCI/PCI-Express Root Bridge | |
342 | * | |
343 | * DESCRIPTION: Determine if the input ID is a PCI Root Bridge ID. | |
344 | * | |
345 | ******************************************************************************/ | |
346 | ||
347 | static u8 acpi_ev_match_pci_root_bridge(char *id) | |
348 | { | |
349 | ||
350 | /* | |
351 | * Check if this is a PCI root. | |
352 | * ACPI 3.0+: check for a PCI Express root also. | |
353 | */ | |
354 | if (!(ACPI_STRNCMP(id, | |
355 | PCI_ROOT_HID_STRING, | |
356 | sizeof(PCI_ROOT_HID_STRING))) || | |
357 | !(ACPI_STRNCMP(id, | |
358 | PCI_EXPRESS_ROOT_HID_STRING, | |
359 | sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) { | |
360 | return (TRUE); | |
361 | } | |
362 | ||
363 | return (FALSE); | |
364 | } | |
365 | ||
366 | /******************************************************************************* | |
367 | * | |
368 | * FUNCTION: acpi_ev_is_pci_root_bridge | |
369 | * | |
370 | * PARAMETERS: Node - Device node being examined | |
371 | * | |
372 | * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge | |
373 | * | |
374 | * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by | |
375 | * examining the _HID and _CID for the device. | |
376 | * | |
377 | ******************************************************************************/ | |
378 | ||
379 | static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) | |
380 | { | |
381 | acpi_status status; | |
8c8eb78f | 382 | struct acpica_device_id hid; |
b7a69806 | 383 | struct acpi_compatible_id_list *cid; |
67a119f9 | 384 | u32 i; |
b7a69806 | 385 | |
9f15fc66 BM |
386 | /* Get the _HID and check for a PCI Root Bridge */ |
387 | ||
b7a69806 BM |
388 | status = acpi_ut_execute_HID(node, &hid); |
389 | if (ACPI_FAILURE(status)) { | |
390 | return (FALSE); | |
391 | } | |
392 | ||
393 | if (acpi_ev_match_pci_root_bridge(hid.value)) { | |
394 | return (TRUE); | |
395 | } | |
396 | ||
9f15fc66 BM |
397 | /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ |
398 | ||
b7a69806 BM |
399 | status = acpi_ut_execute_CID(node, &cid); |
400 | if (ACPI_FAILURE(status)) { | |
401 | return (FALSE); | |
402 | } | |
403 | ||
404 | /* Check all _CIDs in the returned list */ | |
405 | ||
406 | for (i = 0; i < cid->count; i++) { | |
407 | if (acpi_ev_match_pci_root_bridge(cid->id[i].value)) { | |
408 | ACPI_FREE(cid); | |
409 | return (TRUE); | |
410 | } | |
411 | } | |
412 | ||
413 | ACPI_FREE(cid); | |
414 | return (FALSE); | |
415 | } | |
416 | ||
1da177e4 LT |
417 | /******************************************************************************* |
418 | * | |
419 | * FUNCTION: acpi_ev_pci_bar_region_setup | |
420 | * | |
421 | * PARAMETERS: Handle - Region we are interested in | |
422 | * Function - Start or stop | |
423 | * handler_context - Address space handler context | |
424 | * region_context - Region specific context | |
425 | * | |
426 | * RETURN: Status | |
427 | * | |
44f6c012 | 428 | * DESCRIPTION: Setup a pci_bAR operation region |
1da177e4 LT |
429 | * |
430 | * MUTEX: Assumes namespace is not locked | |
431 | * | |
432 | ******************************************************************************/ | |
433 | ||
434 | acpi_status | |
4be44fcd LB |
435 | acpi_ev_pci_bar_region_setup(acpi_handle handle, |
436 | u32 function, | |
437 | void *handler_context, void **region_context) | |
1da177e4 | 438 | { |
b229cf92 | 439 | ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); |
1da177e4 | 440 | |
4be44fcd | 441 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
442 | } |
443 | ||
1da177e4 LT |
444 | /******************************************************************************* |
445 | * | |
446 | * FUNCTION: acpi_ev_cmos_region_setup | |
447 | * | |
448 | * PARAMETERS: Handle - Region we are interested in | |
449 | * Function - Start or stop | |
450 | * handler_context - Address space handler context | |
451 | * region_context - Region specific context | |
452 | * | |
453 | * RETURN: Status | |
454 | * | |
44f6c012 | 455 | * DESCRIPTION: Setup a CMOS operation region |
1da177e4 LT |
456 | * |
457 | * MUTEX: Assumes namespace is not locked | |
458 | * | |
459 | ******************************************************************************/ | |
460 | ||
461 | acpi_status | |
4be44fcd LB |
462 | acpi_ev_cmos_region_setup(acpi_handle handle, |
463 | u32 function, | |
464 | void *handler_context, void **region_context) | |
1da177e4 | 465 | { |
b229cf92 | 466 | ACPI_FUNCTION_TRACE(ev_cmos_region_setup); |
1da177e4 | 467 | |
4be44fcd | 468 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
469 | } |
470 | ||
1da177e4 LT |
471 | /******************************************************************************* |
472 | * | |
473 | * FUNCTION: acpi_ev_default_region_setup | |
474 | * | |
475 | * PARAMETERS: Handle - Region we are interested in | |
476 | * Function - Start or stop | |
477 | * handler_context - Address space handler context | |
478 | * region_context - Region specific context | |
479 | * | |
480 | * RETURN: Status | |
481 | * | |
44f6c012 | 482 | * DESCRIPTION: Default region initialization |
1da177e4 LT |
483 | * |
484 | ******************************************************************************/ | |
485 | ||
486 | acpi_status | |
4be44fcd LB |
487 | acpi_ev_default_region_setup(acpi_handle handle, |
488 | u32 function, | |
489 | void *handler_context, void **region_context) | |
1da177e4 | 490 | { |
b229cf92 | 491 | ACPI_FUNCTION_TRACE(ev_default_region_setup); |
1da177e4 LT |
492 | |
493 | if (function == ACPI_REGION_DEACTIVATE) { | |
494 | *region_context = NULL; | |
4be44fcd | 495 | } else { |
1da177e4 LT |
496 | *region_context = handler_context; |
497 | } | |
498 | ||
4be44fcd | 499 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
500 | } |
501 | ||
1da177e4 LT |
502 | /******************************************************************************* |
503 | * | |
504 | * FUNCTION: acpi_ev_initialize_region | |
505 | * | |
506 | * PARAMETERS: region_obj - Region we are initializing | |
507 | * acpi_ns_locked - Is namespace locked? | |
508 | * | |
509 | * RETURN: Status | |
510 | * | |
511 | * DESCRIPTION: Initializes the region, finds any _REG methods and saves them | |
512 | * for execution at a later time | |
513 | * | |
514 | * Get the appropriate address space handler for a newly | |
515 | * created region. | |
516 | * | |
9f15fc66 | 517 | * This also performs address space specific initialization. For |
1da177e4 | 518 | * example, PCI regions must have an _ADR object that contains |
9f15fc66 | 519 | * a PCI address in the scope of the definition. This address is |
1da177e4 LT |
520 | * required to perform an access to PCI config space. |
521 | * | |
c9e3ba2c BM |
522 | * MUTEX: Interpreter should be unlocked, because we may run the _REG |
523 | * method for this region. | |
524 | * | |
1da177e4 LT |
525 | ******************************************************************************/ |
526 | ||
527 | acpi_status | |
4be44fcd LB |
528 | acpi_ev_initialize_region(union acpi_operand_object *region_obj, |
529 | u8 acpi_ns_locked) | |
1da177e4 | 530 | { |
4be44fcd LB |
531 | union acpi_operand_object *handler_obj; |
532 | union acpi_operand_object *obj_desc; | |
533 | acpi_adr_space_type space_id; | |
534 | struct acpi_namespace_node *node; | |
535 | acpi_status status; | |
536 | struct acpi_namespace_node *method_node; | |
537 | acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG; | |
538 | union acpi_operand_object *region_obj2; | |
1da177e4 | 539 | |
b229cf92 | 540 | ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked); |
1da177e4 LT |
541 | |
542 | if (!region_obj) { | |
4be44fcd | 543 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
544 | } |
545 | ||
546 | if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { | |
4be44fcd | 547 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
548 | } |
549 | ||
4be44fcd | 550 | region_obj2 = acpi_ns_get_secondary_object(region_obj); |
1da177e4 | 551 | if (!region_obj2) { |
4be44fcd | 552 | return_ACPI_STATUS(AE_NOT_EXIST); |
1da177e4 LT |
553 | } |
554 | ||
4be44fcd | 555 | node = acpi_ns_get_parent_node(region_obj->region.node); |
1da177e4 LT |
556 | space_id = region_obj->region.space_id; |
557 | ||
558 | /* Setup defaults */ | |
559 | ||
560 | region_obj->region.handler = NULL; | |
561 | region_obj2->extra.method_REG = NULL; | |
562 | region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE); | |
563 | region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; | |
564 | ||
565 | /* Find any "_REG" method associated with this region definition */ | |
566 | ||
4119532c BM |
567 | status = |
568 | acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD, | |
569 | &method_node); | |
4be44fcd | 570 | if (ACPI_SUCCESS(status)) { |
1da177e4 LT |
571 | /* |
572 | * The _REG method is optional and there can be only one per region | |
9f15fc66 | 573 | * definition. This will be executed when the handler is attached |
1da177e4 LT |
574 | * or removed |
575 | */ | |
576 | region_obj2->extra.method_REG = method_node; | |
577 | } | |
578 | ||
579 | /* | |
580 | * The following loop depends upon the root Node having no parent | |
581 | * ie: acpi_gbl_root_node->parent_entry being set to NULL | |
582 | */ | |
583 | while (node) { | |
52fc0b02 | 584 | |
1da177e4 LT |
585 | /* Check to see if a handler exists */ |
586 | ||
587 | handler_obj = NULL; | |
4be44fcd | 588 | obj_desc = acpi_ns_get_attached_object(node); |
1da177e4 | 589 | if (obj_desc) { |
52fc0b02 | 590 | |
1da177e4 LT |
591 | /* Can only be a handler if the object exists */ |
592 | ||
593 | switch (node->type) { | |
594 | case ACPI_TYPE_DEVICE: | |
595 | ||
596 | handler_obj = obj_desc->device.handler; | |
597 | break; | |
598 | ||
599 | case ACPI_TYPE_PROCESSOR: | |
600 | ||
601 | handler_obj = obj_desc->processor.handler; | |
602 | break; | |
603 | ||
604 | case ACPI_TYPE_THERMAL: | |
605 | ||
606 | handler_obj = obj_desc->thermal_zone.handler; | |
607 | break; | |
608 | ||
609 | default: | |
610 | /* Ignore other objects */ | |
611 | break; | |
612 | } | |
613 | ||
614 | while (handler_obj) { | |
52fc0b02 | 615 | |
1da177e4 LT |
616 | /* Is this handler of the correct type? */ |
617 | ||
4be44fcd LB |
618 | if (handler_obj->address_space.space_id == |
619 | space_id) { | |
52fc0b02 | 620 | |
1da177e4 LT |
621 | /* Found correct handler */ |
622 | ||
4be44fcd LB |
623 | ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, |
624 | "Found handler %p for region %p in obj %p\n", | |
625 | handler_obj, | |
626 | region_obj, | |
627 | obj_desc)); | |
1da177e4 | 628 | |
4be44fcd LB |
629 | status = |
630 | acpi_ev_attach_region(handler_obj, | |
631 | region_obj, | |
632 | acpi_ns_locked); | |
1da177e4 LT |
633 | |
634 | /* | |
635 | * Tell all users that this region is usable by running the _REG | |
636 | * method | |
637 | */ | |
638 | if (acpi_ns_locked) { | |
4be44fcd LB |
639 | status = |
640 | acpi_ut_release_mutex | |
641 | (ACPI_MTX_NAMESPACE); | |
642 | if (ACPI_FAILURE(status)) { | |
643 | return_ACPI_STATUS | |
644 | (status); | |
1da177e4 LT |
645 | } |
646 | } | |
647 | ||
4be44fcd LB |
648 | status = |
649 | acpi_ev_execute_reg_method | |
650 | (region_obj, 1); | |
1da177e4 LT |
651 | |
652 | if (acpi_ns_locked) { | |
4be44fcd LB |
653 | status = |
654 | acpi_ut_acquire_mutex | |
655 | (ACPI_MTX_NAMESPACE); | |
656 | if (ACPI_FAILURE(status)) { | |
657 | return_ACPI_STATUS | |
658 | (status); | |
1da177e4 LT |
659 | } |
660 | } | |
661 | ||
4be44fcd | 662 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
663 | } |
664 | ||
665 | /* Try next handler in the list */ | |
666 | ||
667 | handler_obj = handler_obj->address_space.next; | |
668 | } | |
669 | } | |
670 | ||
9f15fc66 BM |
671 | /* This node does not have the handler we need; Pop up one level */ |
672 | ||
4be44fcd | 673 | node = acpi_ns_get_parent_node(node); |
1da177e4 LT |
674 | } |
675 | ||
676 | /* If we get here, there is no handler for this region */ | |
677 | ||
4be44fcd | 678 | ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, |
b229cf92 | 679 | "No handler for RegionType %s(%X) (RegionObj %p)\n", |
4be44fcd LB |
680 | acpi_ut_get_region_name(space_id), space_id, |
681 | region_obj)); | |
1da177e4 | 682 | |
4be44fcd | 683 | return_ACPI_STATUS(AE_NOT_EXIST); |
1da177e4 | 684 | } |