diff options
author | Ingo Molnar <mingo@elte.hu> | 2009-01-10 22:45:50 -0500 |
---|---|---|
committer | Ingo Molnar <mingo@elte.hu> | 2009-01-10 22:45:50 -0500 |
commit | e8b722f487589a1f60ca27adc695494f188d404e (patch) | |
tree | be3897dceb9b7c0949a8917ab11eea2752375e3b /drivers/acpi/acpica/nsutils.c | |
parent | 01d07820a0df6b6134c1bb75b1e84c9d0cdab3be (diff) | |
parent | c59765042f53a79a7a65585042ff463b69cb248c (diff) |
Merge commit 'v2.6.29-rc1' into irq/urgent
Diffstat (limited to 'drivers/acpi/acpica/nsutils.c')
-rw-r--r-- | drivers/acpi/acpica/nsutils.c | 997 |
1 files changed, 997 insertions, 0 deletions
diff --git a/drivers/acpi/acpica/nsutils.c b/drivers/acpi/acpica/nsutils.c new file mode 100644 index 000000000000..3e1149bf4aa5 --- /dev/null +++ b/drivers/acpi/acpica/nsutils.c | |||
@@ -0,0 +1,997 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * Module Name: nsutils - Utilities for accessing ACPI namespace, accessing | ||
4 | * parents and siblings and Scope manipulation | ||
5 | * | ||
6 | *****************************************************************************/ | ||
7 | |||
8 | /* | ||
9 | * Copyright (C) 2000 - 2008, Intel Corp. | ||
10 | * All rights reserved. | ||
11 | * | ||
12 | * Redistribution and use in source and binary forms, with or without | ||
13 | * modification, are permitted provided that the following conditions | ||
14 | * are met: | ||
15 | * 1. Redistributions of source code must retain the above copyright | ||
16 | * notice, this list of conditions, and the following disclaimer, | ||
17 | * without modification. | ||
18 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | ||
19 | * substantially similar to the "NO WARRANTY" disclaimer below | ||
20 | * ("Disclaimer") and any redistribution must be conditioned upon | ||
21 | * including a substantially similar Disclaimer requirement for further | ||
22 | * binary redistribution. | ||
23 | * 3. Neither the names of the above-listed copyright holders nor the names | ||
24 | * of any contributors may be used to endorse or promote products derived | ||
25 | * from this software without specific prior written permission. | ||
26 | * | ||
27 | * Alternatively, this software may be distributed under the terms of the | ||
28 | * GNU General Public License ("GPL") version 2 as published by the Free | ||
29 | * Software Foundation. | ||
30 | * | ||
31 | * NO WARRANTY | ||
32 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
33 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
34 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | ||
35 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
36 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
37 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
38 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
39 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
40 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | ||
41 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | ||
42 | * POSSIBILITY OF SUCH DAMAGES. | ||
43 | */ | ||
44 | |||
45 | #include <acpi/acpi.h> | ||
46 | #include "accommon.h" | ||
47 | #include "acnamesp.h" | ||
48 | #include "amlcode.h" | ||
49 | #include "actables.h" | ||
50 | |||
51 | #define _COMPONENT ACPI_NAMESPACE | ||
52 | ACPI_MODULE_NAME("nsutils") | ||
53 | |||
54 | /* Local prototypes */ | ||
55 | static u8 acpi_ns_valid_path_separator(char sep); | ||
56 | |||
57 | #ifdef ACPI_OBSOLETE_FUNCTIONS | ||
58 | acpi_name acpi_ns_find_parent_name(struct acpi_namespace_node *node_to_search); | ||
59 | #endif | ||
60 | |||
61 | /******************************************************************************* | ||
62 | * | ||
63 | * FUNCTION: acpi_ns_report_error | ||
64 | * | ||
65 | * PARAMETERS: module_name - Caller's module name (for error output) | ||
66 | * line_number - Caller's line number (for error output) | ||
67 | * internal_name - Name or path of the namespace node | ||
68 | * lookup_status - Exception code from NS lookup | ||
69 | * | ||
70 | * RETURN: None | ||
71 | * | ||
72 | * DESCRIPTION: Print warning message with full pathname | ||
73 | * | ||
74 | ******************************************************************************/ | ||
75 | |||
76 | void | ||
77 | acpi_ns_report_error(const char *module_name, | ||
78 | u32 line_number, | ||
79 | const char *internal_name, acpi_status lookup_status) | ||
80 | { | ||
81 | acpi_status status; | ||
82 | u32 bad_name; | ||
83 | char *name = NULL; | ||
84 | |||
85 | acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number); | ||
86 | |||
87 | if (lookup_status == AE_BAD_CHARACTER) { | ||
88 | |||
89 | /* There is a non-ascii character in the name */ | ||
90 | |||
91 | ACPI_MOVE_32_TO_32(&bad_name, internal_name); | ||
92 | acpi_os_printf("[0x%4.4X] (NON-ASCII)", bad_name); | ||
93 | } else { | ||
94 | /* Convert path to external format */ | ||
95 | |||
96 | status = acpi_ns_externalize_name(ACPI_UINT32_MAX, | ||
97 | internal_name, NULL, &name); | ||
98 | |||
99 | /* Print target name */ | ||
100 | |||
101 | if (ACPI_SUCCESS(status)) { | ||
102 | acpi_os_printf("[%s]", name); | ||
103 | } else { | ||
104 | acpi_os_printf("[COULD NOT EXTERNALIZE NAME]"); | ||
105 | } | ||
106 | |||
107 | if (name) { | ||
108 | ACPI_FREE(name); | ||
109 | } | ||
110 | } | ||
111 | |||
112 | acpi_os_printf(" Namespace lookup failure, %s\n", | ||
113 | acpi_format_exception(lookup_status)); | ||
114 | } | ||
115 | |||
116 | /******************************************************************************* | ||
117 | * | ||
118 | * FUNCTION: acpi_ns_report_method_error | ||
119 | * | ||
120 | * PARAMETERS: module_name - Caller's module name (for error output) | ||
121 | * line_number - Caller's line number (for error output) | ||
122 | * Message - Error message to use on failure | ||
123 | * prefix_node - Prefix relative to the path | ||
124 | * Path - Path to the node (optional) | ||
125 | * method_status - Execution status | ||
126 | * | ||
127 | * RETURN: None | ||
128 | * | ||
129 | * DESCRIPTION: Print warning message with full pathname | ||
130 | * | ||
131 | ******************************************************************************/ | ||
132 | |||
133 | void | ||
134 | acpi_ns_report_method_error(const char *module_name, | ||
135 | u32 line_number, | ||
136 | const char *message, | ||
137 | struct acpi_namespace_node *prefix_node, | ||
138 | const char *path, acpi_status method_status) | ||
139 | { | ||
140 | acpi_status status; | ||
141 | struct acpi_namespace_node *node = prefix_node; | ||
142 | |||
143 | acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number); | ||
144 | |||
145 | if (path) { | ||
146 | status = | ||
147 | acpi_ns_get_node(prefix_node, path, ACPI_NS_NO_UPSEARCH, | ||
148 | &node); | ||
149 | if (ACPI_FAILURE(status)) { | ||
150 | acpi_os_printf("[Could not get node by pathname]"); | ||
151 | } | ||
152 | } | ||
153 | |||
154 | acpi_ns_print_node_pathname(node, message); | ||
155 | acpi_os_printf(", %s\n", acpi_format_exception(method_status)); | ||
156 | } | ||
157 | |||
158 | /******************************************************************************* | ||
159 | * | ||
160 | * FUNCTION: acpi_ns_print_node_pathname | ||
161 | * | ||
162 | * PARAMETERS: Node - Object | ||
163 | * Message - Prefix message | ||
164 | * | ||
165 | * DESCRIPTION: Print an object's full namespace pathname | ||
166 | * Manages allocation/freeing of a pathname buffer | ||
167 | * | ||
168 | ******************************************************************************/ | ||
169 | |||
170 | void | ||
171 | acpi_ns_print_node_pathname(struct acpi_namespace_node *node, | ||
172 | const char *message) | ||
173 | { | ||
174 | struct acpi_buffer buffer; | ||
175 | acpi_status status; | ||
176 | |||
177 | if (!node) { | ||
178 | acpi_os_printf("[NULL NAME]"); | ||
179 | return; | ||
180 | } | ||
181 | |||
182 | /* Convert handle to full pathname and print it (with supplied message) */ | ||
183 | |||
184 | buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; | ||
185 | |||
186 | status = acpi_ns_handle_to_pathname(node, &buffer); | ||
187 | if (ACPI_SUCCESS(status)) { | ||
188 | if (message) { | ||
189 | acpi_os_printf("%s ", message); | ||
190 | } | ||
191 | |||
192 | acpi_os_printf("[%s] (Node %p)", (char *)buffer.pointer, node); | ||
193 | ACPI_FREE(buffer.pointer); | ||
194 | } | ||
195 | } | ||
196 | |||
197 | /******************************************************************************* | ||
198 | * | ||
199 | * FUNCTION: acpi_ns_valid_root_prefix | ||
200 | * | ||
201 | * PARAMETERS: Prefix - Character to be checked | ||
202 | * | ||
203 | * RETURN: TRUE if a valid prefix | ||
204 | * | ||
205 | * DESCRIPTION: Check if a character is a valid ACPI Root prefix | ||
206 | * | ||
207 | ******************************************************************************/ | ||
208 | |||
209 | u8 acpi_ns_valid_root_prefix(char prefix) | ||
210 | { | ||
211 | |||
212 | return ((u8) (prefix == '\\')); | ||
213 | } | ||
214 | |||
215 | /******************************************************************************* | ||
216 | * | ||
217 | * FUNCTION: acpi_ns_valid_path_separator | ||
218 | * | ||
219 | * PARAMETERS: Sep - Character to be checked | ||
220 | * | ||
221 | * RETURN: TRUE if a valid path separator | ||
222 | * | ||
223 | * DESCRIPTION: Check if a character is a valid ACPI path separator | ||
224 | * | ||
225 | ******************************************************************************/ | ||
226 | |||
227 | static u8 acpi_ns_valid_path_separator(char sep) | ||
228 | { | ||
229 | |||
230 | return ((u8) (sep == '.')); | ||
231 | } | ||
232 | |||
233 | /******************************************************************************* | ||
234 | * | ||
235 | * FUNCTION: acpi_ns_get_type | ||
236 | * | ||
237 | * PARAMETERS: Node - Parent Node to be examined | ||
238 | * | ||
239 | * RETURN: Type field from Node whose handle is passed | ||
240 | * | ||
241 | * DESCRIPTION: Return the type of a Namespace node | ||
242 | * | ||
243 | ******************************************************************************/ | ||
244 | |||
245 | acpi_object_type acpi_ns_get_type(struct acpi_namespace_node * node) | ||
246 | { | ||
247 | ACPI_FUNCTION_TRACE(ns_get_type); | ||
248 | |||
249 | if (!node) { | ||
250 | ACPI_WARNING((AE_INFO, "Null Node parameter")); | ||
251 | return_UINT32(ACPI_TYPE_ANY); | ||
252 | } | ||
253 | |||
254 | return_UINT32((acpi_object_type) node->type); | ||
255 | } | ||
256 | |||
257 | /******************************************************************************* | ||
258 | * | ||
259 | * FUNCTION: acpi_ns_local | ||
260 | * | ||
261 | * PARAMETERS: Type - A namespace object type | ||
262 | * | ||
263 | * RETURN: LOCAL if names must be found locally in objects of the | ||
264 | * passed type, 0 if enclosing scopes should be searched | ||
265 | * | ||
266 | * DESCRIPTION: Returns scope rule for the given object type. | ||
267 | * | ||
268 | ******************************************************************************/ | ||
269 | |||
270 | u32 acpi_ns_local(acpi_object_type type) | ||
271 | { | ||
272 | ACPI_FUNCTION_TRACE(ns_local); | ||
273 | |||
274 | if (!acpi_ut_valid_object_type(type)) { | ||
275 | |||
276 | /* Type code out of range */ | ||
277 | |||
278 | ACPI_WARNING((AE_INFO, "Invalid Object Type %X", type)); | ||
279 | return_UINT32(ACPI_NS_NORMAL); | ||
280 | } | ||
281 | |||
282 | return_UINT32((u32) acpi_gbl_ns_properties[type] & ACPI_NS_LOCAL); | ||
283 | } | ||
284 | |||
285 | /******************************************************************************* | ||
286 | * | ||
287 | * FUNCTION: acpi_ns_get_internal_name_length | ||
288 | * | ||
289 | * PARAMETERS: Info - Info struct initialized with the | ||
290 | * external name pointer. | ||
291 | * | ||
292 | * RETURN: None | ||
293 | * | ||
294 | * DESCRIPTION: Calculate the length of the internal (AML) namestring | ||
295 | * corresponding to the external (ASL) namestring. | ||
296 | * | ||
297 | ******************************************************************************/ | ||
298 | |||
299 | void acpi_ns_get_internal_name_length(struct acpi_namestring_info *info) | ||
300 | { | ||
301 | const char *next_external_char; | ||
302 | u32 i; | ||
303 | |||
304 | ACPI_FUNCTION_ENTRY(); | ||
305 | |||
306 | next_external_char = info->external_name; | ||
307 | info->num_carats = 0; | ||
308 | info->num_segments = 0; | ||
309 | info->fully_qualified = FALSE; | ||
310 | |||
311 | /* | ||
312 | * For the internal name, the required length is 4 bytes per segment, plus | ||
313 | * 1 each for root_prefix, multi_name_prefix_op, segment count, trailing null | ||
314 | * (which is not really needed, but no there's harm in putting it there) | ||
315 | * | ||
316 | * strlen() + 1 covers the first name_seg, which has no path separator | ||
317 | */ | ||
318 | if (acpi_ns_valid_root_prefix(*next_external_char)) { | ||
319 | info->fully_qualified = TRUE; | ||
320 | next_external_char++; | ||
321 | |||
322 | /* Skip redundant root_prefix, like \\_SB.PCI0.SBRG.EC0 */ | ||
323 | |||
324 | while (acpi_ns_valid_root_prefix(*next_external_char)) { | ||
325 | next_external_char++; | ||
326 | } | ||
327 | } else { | ||
328 | /* | ||
329 | * Handle Carat prefixes | ||
330 | */ | ||
331 | while (*next_external_char == '^') { | ||
332 | info->num_carats++; | ||
333 | next_external_char++; | ||
334 | } | ||
335 | } | ||
336 | |||
337 | /* | ||
338 | * Determine the number of ACPI name "segments" by counting the number of | ||
339 | * path separators within the string. Start with one segment since the | ||
340 | * segment count is [(# separators) + 1], and zero separators is ok. | ||
341 | */ | ||
342 | if (*next_external_char) { | ||
343 | info->num_segments = 1; | ||
344 | for (i = 0; next_external_char[i]; i++) { | ||
345 | if (acpi_ns_valid_path_separator(next_external_char[i])) { | ||
346 | info->num_segments++; | ||
347 | } | ||
348 | } | ||
349 | } | ||
350 | |||
351 | info->length = (ACPI_NAME_SIZE * info->num_segments) + | ||
352 | 4 + info->num_carats; | ||
353 | |||
354 | info->next_external_char = next_external_char; | ||
355 | } | ||
356 | |||
357 | /******************************************************************************* | ||
358 | * | ||
359 | * FUNCTION: acpi_ns_build_internal_name | ||
360 | * | ||
361 | * PARAMETERS: Info - Info struct fully initialized | ||
362 | * | ||
363 | * RETURN: Status | ||
364 | * | ||
365 | * DESCRIPTION: Construct the internal (AML) namestring | ||
366 | * corresponding to the external (ASL) namestring. | ||
367 | * | ||
368 | ******************************************************************************/ | ||
369 | |||
370 | acpi_status acpi_ns_build_internal_name(struct acpi_namestring_info *info) | ||
371 | { | ||
372 | u32 num_segments = info->num_segments; | ||
373 | char *internal_name = info->internal_name; | ||
374 | const char *external_name = info->next_external_char; | ||
375 | char *result = NULL; | ||
376 | u32 i; | ||
377 | |||
378 | ACPI_FUNCTION_TRACE(ns_build_internal_name); | ||
379 | |||
380 | /* Setup the correct prefixes, counts, and pointers */ | ||
381 | |||
382 | if (info->fully_qualified) { | ||
383 | internal_name[0] = '\\'; | ||
384 | |||
385 | if (num_segments <= 1) { | ||
386 | result = &internal_name[1]; | ||
387 | } else if (num_segments == 2) { | ||
388 | internal_name[1] = AML_DUAL_NAME_PREFIX; | ||
389 | result = &internal_name[2]; | ||
390 | } else { | ||
391 | internal_name[1] = AML_MULTI_NAME_PREFIX_OP; | ||
392 | internal_name[2] = (char)num_segments; | ||
393 | result = &internal_name[3]; | ||
394 | } | ||
395 | } else { | ||
396 | /* | ||
397 | * Not fully qualified. | ||
398 | * Handle Carats first, then append the name segments | ||
399 | */ | ||
400 | i = 0; | ||
401 | if (info->num_carats) { | ||
402 | for (i = 0; i < info->num_carats; i++) { | ||
403 | internal_name[i] = '^'; | ||
404 | } | ||
405 | } | ||
406 | |||
407 | if (num_segments <= 1) { | ||
408 | result = &internal_name[i]; | ||
409 | } else if (num_segments == 2) { | ||
410 | internal_name[i] = AML_DUAL_NAME_PREFIX; | ||
411 | result = &internal_name[(acpi_size) i + 1]; | ||
412 | } else { | ||
413 | internal_name[i] = AML_MULTI_NAME_PREFIX_OP; | ||
414 | internal_name[(acpi_size) i + 1] = (char)num_segments; | ||
415 | result = &internal_name[(acpi_size) i + 2]; | ||
416 | } | ||
417 | } | ||
418 | |||
419 | /* Build the name (minus path separators) */ | ||
420 | |||
421 | for (; num_segments; num_segments--) { | ||
422 | for (i = 0; i < ACPI_NAME_SIZE; i++) { | ||
423 | if (acpi_ns_valid_path_separator(*external_name) || | ||
424 | (*external_name == 0)) { | ||
425 | |||
426 | /* Pad the segment with underscore(s) if segment is short */ | ||
427 | |||
428 | result[i] = '_'; | ||
429 | } else { | ||
430 | /* Convert the character to uppercase and save it */ | ||
431 | |||
432 | result[i] = | ||
433 | (char)ACPI_TOUPPER((int)*external_name); | ||
434 | external_name++; | ||
435 | } | ||
436 | } | ||
437 | |||
438 | /* Now we must have a path separator, or the pathname is bad */ | ||
439 | |||
440 | if (!acpi_ns_valid_path_separator(*external_name) && | ||
441 | (*external_name != 0)) { | ||
442 | return_ACPI_STATUS(AE_BAD_PARAMETER); | ||
443 | } | ||
444 | |||
445 | /* Move on the next segment */ | ||
446 | |||
447 | external_name++; | ||
448 | result += ACPI_NAME_SIZE; | ||
449 | } | ||
450 | |||
451 | /* Terminate the string */ | ||
452 | |||
453 | *result = 0; | ||
454 | |||
455 | if (info->fully_qualified) { | ||
456 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, | ||
457 | "Returning [%p] (abs) \"\\%s\"\n", | ||
458 | internal_name, internal_name)); | ||
459 | } else { | ||
460 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n", | ||
461 | internal_name, internal_name)); | ||
462 | } | ||
463 | |||
464 | return_ACPI_STATUS(AE_OK); | ||
465 | } | ||
466 | |||
467 | /******************************************************************************* | ||
468 | * | ||
469 | * FUNCTION: acpi_ns_internalize_name | ||
470 | * | ||
471 | * PARAMETERS: *external_name - External representation of name | ||
472 | * **Converted Name - Where to return the resulting | ||
473 | * internal represention of the name | ||
474 | * | ||
475 | * RETURN: Status | ||
476 | * | ||
477 | * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0") | ||
478 | * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) | ||
479 | * | ||
480 | *******************************************************************************/ | ||
481 | |||
482 | acpi_status | ||
483 | acpi_ns_internalize_name(const char *external_name, char **converted_name) | ||
484 | { | ||
485 | char *internal_name; | ||
486 | struct acpi_namestring_info info; | ||
487 | acpi_status status; | ||
488 | |||
489 | ACPI_FUNCTION_TRACE(ns_internalize_name); | ||
490 | |||
491 | if ((!external_name) || (*external_name == 0) || (!converted_name)) { | ||
492 | return_ACPI_STATUS(AE_BAD_PARAMETER); | ||
493 | } | ||
494 | |||
495 | /* Get the length of the new internal name */ | ||
496 | |||
497 | info.external_name = external_name; | ||
498 | acpi_ns_get_internal_name_length(&info); | ||
499 | |||
500 | /* We need a segment to store the internal name */ | ||
501 | |||
502 | internal_name = ACPI_ALLOCATE_ZEROED(info.length); | ||
503 | if (!internal_name) { | ||
504 | return_ACPI_STATUS(AE_NO_MEMORY); | ||
505 | } | ||
506 | |||
507 | /* Build the name */ | ||
508 | |||
509 | info.internal_name = internal_name; | ||
510 | status = acpi_ns_build_internal_name(&info); | ||
511 | if (ACPI_FAILURE(status)) { | ||
512 | ACPI_FREE(internal_name); | ||
513 | return_ACPI_STATUS(status); | ||
514 | } | ||
515 | |||
516 | *converted_name = internal_name; | ||
517 | return_ACPI_STATUS(AE_OK); | ||
518 | } | ||
519 | |||
520 | /******************************************************************************* | ||
521 | * | ||
522 | * FUNCTION: acpi_ns_externalize_name | ||
523 | * | ||
524 | * PARAMETERS: internal_name_length - Lenth of the internal name below | ||
525 | * internal_name - Internal representation of name | ||
526 | * converted_name_length - Where the length is returned | ||
527 | * converted_name - Where the resulting external name | ||
528 | * is returned | ||
529 | * | ||
530 | * RETURN: Status | ||
531 | * | ||
532 | * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) | ||
533 | * to its external (printable) form (e.g. "\_PR_.CPU0") | ||
534 | * | ||
535 | ******************************************************************************/ | ||
536 | |||
537 | acpi_status | ||
538 | acpi_ns_externalize_name(u32 internal_name_length, | ||
539 | const char *internal_name, | ||
540 | u32 * converted_name_length, char **converted_name) | ||
541 | { | ||
542 | u32 names_index = 0; | ||
543 | u32 num_segments = 0; | ||
544 | u32 required_length; | ||
545 | u32 prefix_length = 0; | ||
546 | u32 i = 0; | ||
547 | u32 j = 0; | ||
548 | |||
549 | ACPI_FUNCTION_TRACE(ns_externalize_name); | ||
550 | |||
551 | if (!internal_name_length || !internal_name || !converted_name) { | ||
552 | return_ACPI_STATUS(AE_BAD_PARAMETER); | ||
553 | } | ||
554 | |||
555 | /* | ||
556 | * Check for a prefix (one '\' | one or more '^'). | ||
557 | */ | ||
558 | switch (internal_name[0]) { | ||
559 | case '\\': | ||
560 | prefix_length = 1; | ||
561 | break; | ||
562 | |||
563 | case '^': | ||
564 | for (i = 0; i < internal_name_length; i++) { | ||
565 | if (internal_name[i] == '^') { | ||
566 | prefix_length = i + 1; | ||
567 | } else { | ||
568 | break; | ||
569 | } | ||
570 | } | ||
571 | |||
572 | if (i == internal_name_length) { | ||
573 | prefix_length = i; | ||
574 | } | ||
575 | |||
576 | break; | ||
577 | |||
578 | default: | ||
579 | break; | ||
580 | } | ||
581 | |||
582 | /* | ||
583 | * Check for object names. Note that there could be 0-255 of these | ||
584 | * 4-byte elements. | ||
585 | */ | ||
586 | if (prefix_length < internal_name_length) { | ||
587 | switch (internal_name[prefix_length]) { | ||
588 | case AML_MULTI_NAME_PREFIX_OP: | ||
589 | |||
590 | /* <count> 4-byte names */ | ||
591 | |||
592 | names_index = prefix_length + 2; | ||
593 | num_segments = (u8) | ||
594 | internal_name[(acpi_size) prefix_length + 1]; | ||
595 | break; | ||
596 | |||
597 | case AML_DUAL_NAME_PREFIX: | ||
598 | |||
599 | /* Two 4-byte names */ | ||
600 | |||
601 | names_index = prefix_length + 1; | ||
602 | num_segments = 2; | ||
603 | break; | ||
604 | |||
605 | case 0: | ||
606 | |||
607 | /* null_name */ | ||
608 | |||
609 | names_index = 0; | ||
610 | num_segments = 0; | ||
611 | break; | ||
612 | |||
613 | default: | ||
614 | |||
615 | /* one 4-byte name */ | ||
616 | |||
617 | names_index = prefix_length; | ||
618 | num_segments = 1; | ||
619 | break; | ||
620 | } | ||
621 | } | ||
622 | |||
623 | /* | ||
624 | * Calculate the length of converted_name, which equals the length | ||
625 | * of the prefix, length of all object names, length of any required | ||
626 | * punctuation ('.') between object names, plus the NULL terminator. | ||
627 | */ | ||
628 | required_length = prefix_length + (4 * num_segments) + | ||
629 | ((num_segments > 0) ? (num_segments - 1) : 0) + 1; | ||
630 | |||
631 | /* | ||
632 | * Check to see if we're still in bounds. If not, there's a problem | ||
633 | * with internal_name (invalid format). | ||
634 | */ | ||
635 | if (required_length > internal_name_length) { | ||
636 | ACPI_ERROR((AE_INFO, "Invalid internal name")); | ||
637 | return_ACPI_STATUS(AE_BAD_PATHNAME); | ||
638 | } | ||
639 | |||
640 | /* | ||
641 | * Build converted_name | ||
642 | */ | ||
643 | *converted_name = ACPI_ALLOCATE_ZEROED(required_length); | ||
644 | if (!(*converted_name)) { | ||
645 | return_ACPI_STATUS(AE_NO_MEMORY); | ||
646 | } | ||
647 | |||
648 | j = 0; | ||
649 | |||
650 | for (i = 0; i < prefix_length; i++) { | ||
651 | (*converted_name)[j++] = internal_name[i]; | ||
652 | } | ||
653 | |||
654 | if (num_segments > 0) { | ||
655 | for (i = 0; i < num_segments; i++) { | ||
656 | if (i > 0) { | ||
657 | (*converted_name)[j++] = '.'; | ||
658 | } | ||
659 | |||
660 | (*converted_name)[j++] = internal_name[names_index++]; | ||
661 | (*converted_name)[j++] = internal_name[names_index++]; | ||
662 | (*converted_name)[j++] = internal_name[names_index++]; | ||
663 | (*converted_name)[j++] = internal_name[names_index++]; | ||
664 | } | ||
665 | } | ||
666 | |||
667 | if (converted_name_length) { | ||
668 | *converted_name_length = (u32) required_length; | ||
669 | } | ||
670 | |||
671 | return_ACPI_STATUS(AE_OK); | ||
672 | } | ||
673 | |||
674 | /******************************************************************************* | ||
675 | * | ||
676 | * FUNCTION: acpi_ns_map_handle_to_node | ||
677 | * | ||
678 | * PARAMETERS: Handle - Handle to be converted to an Node | ||
679 | * | ||
680 | * RETURN: A Name table entry pointer | ||
681 | * | ||
682 | * DESCRIPTION: Convert a namespace handle to a real Node | ||
683 | * | ||
684 | * Note: Real integer handles would allow for more verification | ||
685 | * and keep all pointers within this subsystem - however this introduces | ||
686 | * more (and perhaps unnecessary) overhead. | ||
687 | * | ||
688 | ******************************************************************************/ | ||
689 | |||
690 | struct acpi_namespace_node *acpi_ns_map_handle_to_node(acpi_handle handle) | ||
691 | { | ||
692 | |||
693 | ACPI_FUNCTION_ENTRY(); | ||
694 | |||
695 | /* | ||
696 | * Simple implementation | ||
697 | */ | ||
698 | if ((!handle) || (handle == ACPI_ROOT_OBJECT)) { | ||
699 | return (acpi_gbl_root_node); | ||
700 | } | ||
701 | |||
702 | /* We can at least attempt to verify the handle */ | ||
703 | |||
704 | if (ACPI_GET_DESCRIPTOR_TYPE(handle) != ACPI_DESC_TYPE_NAMED) { | ||
705 | return (NULL); | ||
706 | } | ||
707 | |||
708 | return (ACPI_CAST_PTR(struct acpi_namespace_node, handle)); | ||
709 | } | ||
710 | |||
711 | /******************************************************************************* | ||
712 | * | ||
713 | * FUNCTION: acpi_ns_convert_entry_to_handle | ||
714 | * | ||
715 | * PARAMETERS: Node - Node to be converted to a Handle | ||
716 | * | ||
717 | * RETURN: A user handle | ||
718 | * | ||
719 | * DESCRIPTION: Convert a real Node to a namespace handle | ||
720 | * | ||
721 | ******************************************************************************/ | ||
722 | |||
723 | acpi_handle acpi_ns_convert_entry_to_handle(struct acpi_namespace_node *node) | ||
724 | { | ||
725 | |||
726 | /* | ||
727 | * Simple implementation for now; | ||
728 | */ | ||
729 | return ((acpi_handle) node); | ||
730 | |||
731 | /* Example future implementation --------------------- | ||
732 | |||
733 | if (!Node) | ||
734 | { | ||
735 | return (NULL); | ||
736 | } | ||
737 | |||
738 | if (Node == acpi_gbl_root_node) | ||
739 | { | ||
740 | return (ACPI_ROOT_OBJECT); | ||
741 | } | ||
742 | |||
743 | return ((acpi_handle) Node); | ||
744 | ------------------------------------------------------*/ | ||
745 | } | ||
746 | |||
747 | /******************************************************************************* | ||
748 | * | ||
749 | * FUNCTION: acpi_ns_terminate | ||
750 | * | ||
751 | * PARAMETERS: none | ||
752 | * | ||
753 | * RETURN: none | ||
754 | * | ||
755 | * DESCRIPTION: free memory allocated for namespace and ACPI table storage. | ||
756 | * | ||
757 | ******************************************************************************/ | ||
758 | |||
759 | void acpi_ns_terminate(void) | ||
760 | { | ||
761 | union acpi_operand_object *obj_desc; | ||
762 | |||
763 | ACPI_FUNCTION_TRACE(ns_terminate); | ||
764 | |||
765 | /* | ||
766 | * 1) Free the entire namespace -- all nodes and objects | ||
767 | * | ||
768 | * Delete all object descriptors attached to namepsace nodes | ||
769 | */ | ||
770 | acpi_ns_delete_namespace_subtree(acpi_gbl_root_node); | ||
771 | |||
772 | /* Detach any objects attached to the root */ | ||
773 | |||
774 | obj_desc = acpi_ns_get_attached_object(acpi_gbl_root_node); | ||
775 | if (obj_desc) { | ||
776 | acpi_ns_detach_object(acpi_gbl_root_node); | ||
777 | } | ||
778 | |||
779 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Namespace freed\n")); | ||
780 | return_VOID; | ||
781 | } | ||
782 | |||
783 | /******************************************************************************* | ||
784 | * | ||
785 | * FUNCTION: acpi_ns_opens_scope | ||
786 | * | ||
787 | * PARAMETERS: Type - A valid namespace type | ||
788 | * | ||
789 | * RETURN: NEWSCOPE if the passed type "opens a name scope" according | ||
790 | * to the ACPI specification, else 0 | ||
791 | * | ||
792 | ******************************************************************************/ | ||
793 | |||
794 | u32 acpi_ns_opens_scope(acpi_object_type type) | ||
795 | { | ||
796 | ACPI_FUNCTION_TRACE_STR(ns_opens_scope, acpi_ut_get_type_name(type)); | ||
797 | |||
798 | if (!acpi_ut_valid_object_type(type)) { | ||
799 | |||
800 | /* type code out of range */ | ||
801 | |||
802 | ACPI_WARNING((AE_INFO, "Invalid Object Type %X", type)); | ||
803 | return_UINT32(ACPI_NS_NORMAL); | ||
804 | } | ||
805 | |||
806 | return_UINT32(((u32) acpi_gbl_ns_properties[type]) & ACPI_NS_NEWSCOPE); | ||
807 | } | ||
808 | |||
809 | /******************************************************************************* | ||
810 | * | ||
811 | * FUNCTION: acpi_ns_get_node | ||
812 | * | ||
813 | * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The | ||
814 | * \ (backslash) and ^ (carat) prefixes, and the | ||
815 | * . (period) to separate segments are supported. | ||
816 | * prefix_node - Root of subtree to be searched, or NS_ALL for the | ||
817 | * root of the name space. If Name is fully | ||
818 | * qualified (first s8 is '\'), the passed value | ||
819 | * of Scope will not be accessed. | ||
820 | * Flags - Used to indicate whether to perform upsearch or | ||
821 | * not. | ||
822 | * return_node - Where the Node is returned | ||
823 | * | ||
824 | * DESCRIPTION: Look up a name relative to a given scope and return the | ||
825 | * corresponding Node. NOTE: Scope can be null. | ||
826 | * | ||
827 | * MUTEX: Locks namespace | ||
828 | * | ||
829 | ******************************************************************************/ | ||
830 | |||
831 | acpi_status | ||
832 | acpi_ns_get_node(struct acpi_namespace_node *prefix_node, | ||
833 | const char *pathname, | ||
834 | u32 flags, struct acpi_namespace_node **return_node) | ||
835 | { | ||
836 | union acpi_generic_state scope_info; | ||
837 | acpi_status status; | ||
838 | char *internal_path; | ||
839 | |||
840 | ACPI_FUNCTION_TRACE_PTR(ns_get_node, pathname); | ||
841 | |||
842 | if (!pathname) { | ||
843 | *return_node = prefix_node; | ||
844 | if (!prefix_node) { | ||
845 | *return_node = acpi_gbl_root_node; | ||
846 | } | ||
847 | return_ACPI_STATUS(AE_OK); | ||
848 | } | ||
849 | |||
850 | /* Convert path to internal representation */ | ||
851 | |||
852 | status = acpi_ns_internalize_name(pathname, &internal_path); | ||
853 | if (ACPI_FAILURE(status)) { | ||
854 | return_ACPI_STATUS(status); | ||
855 | } | ||
856 | |||
857 | /* Must lock namespace during lookup */ | ||
858 | |||
859 | status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); | ||
860 | if (ACPI_FAILURE(status)) { | ||
861 | goto cleanup; | ||
862 | } | ||
863 | |||
864 | /* Setup lookup scope (search starting point) */ | ||
865 | |||
866 | scope_info.scope.node = prefix_node; | ||
867 | |||
868 | /* Lookup the name in the namespace */ | ||
869 | |||
870 | status = acpi_ns_lookup(&scope_info, internal_path, ACPI_TYPE_ANY, | ||
871 | ACPI_IMODE_EXECUTE, | ||
872 | (flags | ACPI_NS_DONT_OPEN_SCOPE), NULL, | ||
873 | return_node); | ||
874 | if (ACPI_FAILURE(status)) { | ||
875 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s, %s\n", | ||
876 | pathname, acpi_format_exception(status))); | ||
877 | } | ||
878 | |||
879 | (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); | ||
880 | |||
881 | cleanup: | ||
882 | ACPI_FREE(internal_path); | ||
883 | return_ACPI_STATUS(status); | ||
884 | } | ||
885 | |||
886 | /******************************************************************************* | ||
887 | * | ||
888 | * FUNCTION: acpi_ns_get_parent_node | ||
889 | * | ||
890 | * PARAMETERS: Node - Current table entry | ||
891 | * | ||
892 | * RETURN: Parent entry of the given entry | ||
893 | * | ||
894 | * DESCRIPTION: Obtain the parent entry for a given entry in the namespace. | ||
895 | * | ||
896 | ******************************************************************************/ | ||
897 | |||
898 | struct acpi_namespace_node *acpi_ns_get_parent_node(struct acpi_namespace_node | ||
899 | *node) | ||
900 | { | ||
901 | ACPI_FUNCTION_ENTRY(); | ||
902 | |||
903 | if (!node) { | ||
904 | return (NULL); | ||
905 | } | ||
906 | |||
907 | /* | ||
908 | * Walk to the end of this peer list. The last entry is marked with a flag | ||
909 | * and the peer pointer is really a pointer back to the parent. This saves | ||
910 | * putting a parent back pointer in each and every named object! | ||
911 | */ | ||
912 | while (!(node->flags & ANOBJ_END_OF_PEER_LIST)) { | ||
913 | node = node->peer; | ||
914 | } | ||
915 | |||
916 | return (node->peer); | ||
917 | } | ||
918 | |||
919 | /******************************************************************************* | ||
920 | * | ||
921 | * FUNCTION: acpi_ns_get_next_valid_node | ||
922 | * | ||
923 | * PARAMETERS: Node - Current table entry | ||
924 | * | ||
925 | * RETURN: Next valid Node in the linked node list. NULL if no more valid | ||
926 | * nodes. | ||
927 | * | ||
928 | * DESCRIPTION: Find the next valid node within a name table. | ||
929 | * Useful for implementing NULL-end-of-list loops. | ||
930 | * | ||
931 | ******************************************************************************/ | ||
932 | |||
933 | struct acpi_namespace_node *acpi_ns_get_next_valid_node(struct | ||
934 | acpi_namespace_node | ||
935 | *node) | ||
936 | { | ||
937 | |||
938 | /* If we are at the end of this peer list, return NULL */ | ||
939 | |||
940 | if (node->flags & ANOBJ_END_OF_PEER_LIST) { | ||
941 | return NULL; | ||
942 | } | ||
943 | |||
944 | /* Otherwise just return the next peer */ | ||
945 | |||
946 | return (node->peer); | ||
947 | } | ||
948 | |||
949 | #ifdef ACPI_OBSOLETE_FUNCTIONS | ||
950 | /******************************************************************************* | ||
951 | * | ||
952 | * FUNCTION: acpi_ns_find_parent_name | ||
953 | * | ||
954 | * PARAMETERS: *child_node - Named Obj whose name is to be found | ||
955 | * | ||
956 | * RETURN: The ACPI name | ||
957 | * | ||
958 | * DESCRIPTION: Search for the given obj in its parent scope and return the | ||
959 | * name segment, or "????" if the parent name can't be found | ||
960 | * (which "should not happen"). | ||
961 | * | ||
962 | ******************************************************************************/ | ||
963 | |||
964 | acpi_name acpi_ns_find_parent_name(struct acpi_namespace_node * child_node) | ||
965 | { | ||
966 | struct acpi_namespace_node *parent_node; | ||
967 | |||
968 | ACPI_FUNCTION_TRACE(ns_find_parent_name); | ||
969 | |||
970 | if (child_node) { | ||
971 | |||
972 | /* Valid entry. Get the parent Node */ | ||
973 | |||
974 | parent_node = acpi_ns_get_parent_node(child_node); | ||
975 | if (parent_node) { | ||
976 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, | ||
977 | "Parent of %p [%4.4s] is %p [%4.4s]\n", | ||
978 | child_node, | ||
979 | acpi_ut_get_node_name(child_node), | ||
980 | parent_node, | ||
981 | acpi_ut_get_node_name(parent_node))); | ||
982 | |||
983 | if (parent_node->name.integer) { | ||
984 | return_VALUE((acpi_name) parent_node->name. | ||
985 | integer); | ||
986 | } | ||
987 | } | ||
988 | |||
989 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, | ||
990 | "Unable to find parent of %p (%4.4s)\n", | ||
991 | child_node, | ||
992 | acpi_ut_get_node_name(child_node))); | ||
993 | } | ||
994 | |||
995 | return_VALUE(ACPI_UNKNOWN_NAME); | ||
996 | } | ||
997 | #endif | ||