6 *
7 *****************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights. You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code. No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision. In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change. Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee. Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution. In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government. In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118#define __NSUTILS_C__
119
120#include "acpi.h"
121#include "acnamesp.h"
122#include "amlcode.h"
123#include "actables.h"
124
125#define _COMPONENT ACPI_NAMESPACE
126 ACPI_MODULE_NAME ("nsutils")
127
128
129/*******************************************************************************
130 *
131 * FUNCTION: AcpiNsReportError
132 *
133 * PARAMETERS: ModuleName - Caller's module name (for error output)
134 * LineNumber - Caller's line number (for error output)
135 * ComponentId - Caller's component ID (for error output)
136 * Message - Error message to use on failure
137 *
138 * RETURN: None
139 *
140 * DESCRIPTION: Print warning message with full pathname
141 *
142 ******************************************************************************/
143
144void
145AcpiNsReportError (
146 char *ModuleName,
147 UINT32 LineNumber,
148 UINT32 ComponentId,
149 char *InternalName,
150 ACPI_STATUS LookupStatus)
151{
152 ACPI_STATUS Status;
153 char *Name = NULL;
154
155
156 AcpiOsPrintf ("%8s-%04d: *** Error: Looking up ",
157 ModuleName, LineNumber);
158
159 if (LookupStatus == AE_BAD_CHARACTER)
160 {
161 /* There is a non-ascii character in the name */
162
163 AcpiOsPrintf ("[0x%4.4X] (NON-ASCII)\n", *(ACPI_CAST_PTR (UINT32, InternalName)));
164 }
165 else
166 {
167 /* Convert path to external format */
168
169 Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, InternalName, NULL, &Name);
170
171 /* Print target name */
172
173 if (ACPI_SUCCESS (Status))
174 {
175 AcpiOsPrintf ("[%s]", Name);
176 }
177 else
178 {
179 AcpiOsPrintf ("[COULD NOT EXTERNALIZE NAME]");
180 }
181
182 if (Name)
183 {
184 ACPI_MEM_FREE (Name);
185 }
186 }
187
188 AcpiOsPrintf (" in namespace, %s\n",
189 AcpiFormatException (LookupStatus));
190}
191
192
193/*******************************************************************************
194 *
195 * FUNCTION: AcpiNsReportMethodError
196 *
197 * PARAMETERS: ModuleName - Caller's module name (for error output)
198 * LineNumber - Caller's line number (for error output)
199 * ComponentId - Caller's component ID (for error output)
200 * Message - Error message to use on failure
201 *
202 * RETURN: None
203 *
204 * DESCRIPTION: Print warning message with full pathname
205 *
206 ******************************************************************************/
207
208void
209AcpiNsReportMethodError (
210 char *ModuleName,
211 UINT32 LineNumber,
212 UINT32 ComponentId,
213 char *Message,
214 ACPI_NAMESPACE_NODE *PrefixNode,
215 char *Path,
216 ACPI_STATUS MethodStatus)
217{
218 ACPI_STATUS Status;
219 ACPI_NAMESPACE_NODE *Node = PrefixNode;
220
221
222 if (Path)
223 {
224 Status = AcpiNsGetNodeByPath (Path, PrefixNode, ACPI_NS_NO_UPSEARCH, &Node);
225 if (ACPI_FAILURE (Status))
226 {
227 AcpiOsPrintf ("ReportMethodError: Could not get node\n");
228 return;
229 }
230 }
231
232 AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber);
233 AcpiNsPrintNodePathname (Node, Message);
234 AcpiOsPrintf (", %s\n", AcpiFormatException (MethodStatus));
235}
236
237
238/*******************************************************************************
239 *
240 * FUNCTION: AcpiNsPrintNodePathname
241 *
242 * PARAMETERS: Node - Object
243 * Msg - Prefix message
244 *
245 * DESCRIPTION: Print an object's full namespace pathname
246 * Manages allocation/freeing of a pathname buffer
247 *
248 ******************************************************************************/
249
250void
251AcpiNsPrintNodePathname (
252 ACPI_NAMESPACE_NODE *Node,
253 char *Msg)
254{
255 ACPI_BUFFER Buffer;
256 ACPI_STATUS Status;
257
258
259 if (!Node)
260 {
261 AcpiOsPrintf ("[NULL NAME]");
262 return;
263 }
264
265 /* Convert handle to a full pathname and print it (with supplied message) */
266
267 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
268
269 Status = AcpiNsHandleToPathname (Node, &Buffer);
270 if (ACPI_SUCCESS (Status))
271 {
272 if (Msg)
273 {
274 AcpiOsPrintf ("%s ", Msg);
275 }
276
277 AcpiOsPrintf ("[%s] (Node %p)", (char *) Buffer.Pointer, Node);
278 ACPI_MEM_FREE (Buffer.Pointer);
279 }
280}
281
282
283/*******************************************************************************
284 *
285 * FUNCTION: AcpiNsValidRootPrefix
286 *
287 * PARAMETERS: Prefix - Character to be checked
288 *
289 * RETURN: TRUE if a valid prefix
290 *
291 * DESCRIPTION: Check if a character is a valid ACPI Root prefix
292 *
293 ******************************************************************************/
294
295BOOLEAN
296AcpiNsValidRootPrefix (
297 char Prefix)
298{
299
300 return ((BOOLEAN) (Prefix == '\\'));
301}
302
303
304/*******************************************************************************
305 *
306 * FUNCTION: AcpiNsValidPathSeparator
307 *
308 * PARAMETERS: Sep - Character to be checked
309 *
310 * RETURN: TRUE if a valid path separator
311 *
312 * DESCRIPTION: Check if a character is a valid ACPI path separator
313 *
314 ******************************************************************************/
315
316BOOLEAN
317AcpiNsValidPathSeparator (
318 char Sep)
319{
320
321 return ((BOOLEAN) (Sep == '.'));
322}
323
324
325/*******************************************************************************
326 *
327 * FUNCTION: AcpiNsGetType
328 *
329 * PARAMETERS: Handle - Parent Node to be examined
330 *
331 * RETURN: Type field from Node whose handle is passed
332 *
333 ******************************************************************************/
334
335ACPI_OBJECT_TYPE
336AcpiNsGetType (
337 ACPI_NAMESPACE_NODE *Node)
338{
339 ACPI_FUNCTION_TRACE ("NsGetType");
340
341
342 if (!Node)
343 {
| 6 *
7 *****************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights. You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code. No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision. In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change. Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee. Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution. In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government. In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118#define __NSUTILS_C__
119
120#include "acpi.h"
121#include "acnamesp.h"
122#include "amlcode.h"
123#include "actables.h"
124
125#define _COMPONENT ACPI_NAMESPACE
126 ACPI_MODULE_NAME ("nsutils")
127
128
129/*******************************************************************************
130 *
131 * FUNCTION: AcpiNsReportError
132 *
133 * PARAMETERS: ModuleName - Caller's module name (for error output)
134 * LineNumber - Caller's line number (for error output)
135 * ComponentId - Caller's component ID (for error output)
136 * Message - Error message to use on failure
137 *
138 * RETURN: None
139 *
140 * DESCRIPTION: Print warning message with full pathname
141 *
142 ******************************************************************************/
143
144void
145AcpiNsReportError (
146 char *ModuleName,
147 UINT32 LineNumber,
148 UINT32 ComponentId,
149 char *InternalName,
150 ACPI_STATUS LookupStatus)
151{
152 ACPI_STATUS Status;
153 char *Name = NULL;
154
155
156 AcpiOsPrintf ("%8s-%04d: *** Error: Looking up ",
157 ModuleName, LineNumber);
158
159 if (LookupStatus == AE_BAD_CHARACTER)
160 {
161 /* There is a non-ascii character in the name */
162
163 AcpiOsPrintf ("[0x%4.4X] (NON-ASCII)\n", *(ACPI_CAST_PTR (UINT32, InternalName)));
164 }
165 else
166 {
167 /* Convert path to external format */
168
169 Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, InternalName, NULL, &Name);
170
171 /* Print target name */
172
173 if (ACPI_SUCCESS (Status))
174 {
175 AcpiOsPrintf ("[%s]", Name);
176 }
177 else
178 {
179 AcpiOsPrintf ("[COULD NOT EXTERNALIZE NAME]");
180 }
181
182 if (Name)
183 {
184 ACPI_MEM_FREE (Name);
185 }
186 }
187
188 AcpiOsPrintf (" in namespace, %s\n",
189 AcpiFormatException (LookupStatus));
190}
191
192
193/*******************************************************************************
194 *
195 * FUNCTION: AcpiNsReportMethodError
196 *
197 * PARAMETERS: ModuleName - Caller's module name (for error output)
198 * LineNumber - Caller's line number (for error output)
199 * ComponentId - Caller's component ID (for error output)
200 * Message - Error message to use on failure
201 *
202 * RETURN: None
203 *
204 * DESCRIPTION: Print warning message with full pathname
205 *
206 ******************************************************************************/
207
208void
209AcpiNsReportMethodError (
210 char *ModuleName,
211 UINT32 LineNumber,
212 UINT32 ComponentId,
213 char *Message,
214 ACPI_NAMESPACE_NODE *PrefixNode,
215 char *Path,
216 ACPI_STATUS MethodStatus)
217{
218 ACPI_STATUS Status;
219 ACPI_NAMESPACE_NODE *Node = PrefixNode;
220
221
222 if (Path)
223 {
224 Status = AcpiNsGetNodeByPath (Path, PrefixNode, ACPI_NS_NO_UPSEARCH, &Node);
225 if (ACPI_FAILURE (Status))
226 {
227 AcpiOsPrintf ("ReportMethodError: Could not get node\n");
228 return;
229 }
230 }
231
232 AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber);
233 AcpiNsPrintNodePathname (Node, Message);
234 AcpiOsPrintf (", %s\n", AcpiFormatException (MethodStatus));
235}
236
237
238/*******************************************************************************
239 *
240 * FUNCTION: AcpiNsPrintNodePathname
241 *
242 * PARAMETERS: Node - Object
243 * Msg - Prefix message
244 *
245 * DESCRIPTION: Print an object's full namespace pathname
246 * Manages allocation/freeing of a pathname buffer
247 *
248 ******************************************************************************/
249
250void
251AcpiNsPrintNodePathname (
252 ACPI_NAMESPACE_NODE *Node,
253 char *Msg)
254{
255 ACPI_BUFFER Buffer;
256 ACPI_STATUS Status;
257
258
259 if (!Node)
260 {
261 AcpiOsPrintf ("[NULL NAME]");
262 return;
263 }
264
265 /* Convert handle to a full pathname and print it (with supplied message) */
266
267 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
268
269 Status = AcpiNsHandleToPathname (Node, &Buffer);
270 if (ACPI_SUCCESS (Status))
271 {
272 if (Msg)
273 {
274 AcpiOsPrintf ("%s ", Msg);
275 }
276
277 AcpiOsPrintf ("[%s] (Node %p)", (char *) Buffer.Pointer, Node);
278 ACPI_MEM_FREE (Buffer.Pointer);
279 }
280}
281
282
283/*******************************************************************************
284 *
285 * FUNCTION: AcpiNsValidRootPrefix
286 *
287 * PARAMETERS: Prefix - Character to be checked
288 *
289 * RETURN: TRUE if a valid prefix
290 *
291 * DESCRIPTION: Check if a character is a valid ACPI Root prefix
292 *
293 ******************************************************************************/
294
295BOOLEAN
296AcpiNsValidRootPrefix (
297 char Prefix)
298{
299
300 return ((BOOLEAN) (Prefix == '\\'));
301}
302
303
304/*******************************************************************************
305 *
306 * FUNCTION: AcpiNsValidPathSeparator
307 *
308 * PARAMETERS: Sep - Character to be checked
309 *
310 * RETURN: TRUE if a valid path separator
311 *
312 * DESCRIPTION: Check if a character is a valid ACPI path separator
313 *
314 ******************************************************************************/
315
316BOOLEAN
317AcpiNsValidPathSeparator (
318 char Sep)
319{
320
321 return ((BOOLEAN) (Sep == '.'));
322}
323
324
325/*******************************************************************************
326 *
327 * FUNCTION: AcpiNsGetType
328 *
329 * PARAMETERS: Handle - Parent Node to be examined
330 *
331 * RETURN: Type field from Node whose handle is passed
332 *
333 ******************************************************************************/
334
335ACPI_OBJECT_TYPE
336AcpiNsGetType (
337 ACPI_NAMESPACE_NODE *Node)
338{
339 ACPI_FUNCTION_TRACE ("NsGetType");
340
341
342 if (!Node)
343 {
|
345 return_VALUE (ACPI_TYPE_ANY);
346 }
347
348 return_VALUE ((ACPI_OBJECT_TYPE) Node->Type);
349}
350
351
352/*******************************************************************************
353 *
354 * FUNCTION: AcpiNsLocal
355 *
356 * PARAMETERS: Type - A namespace object type
357 *
358 * RETURN: LOCAL if names must be found locally in objects of the
359 * passed type, 0 if enclosing scopes should be searched
360 *
361 ******************************************************************************/
362
363UINT32
364AcpiNsLocal (
365 ACPI_OBJECT_TYPE Type)
366{
367 ACPI_FUNCTION_TRACE ("NsLocal");
368
369
370 if (!AcpiUtValidObjectType (Type))
371 {
372 /* Type code out of range */
373
374 ACPI_REPORT_WARNING (("NsLocal: Invalid Object Type\n"));
375 return_VALUE (ACPI_NS_NORMAL);
376 }
377
378 return_VALUE ((UINT32) AcpiGbl_NsProperties[Type] & ACPI_NS_LOCAL);
379}
380
381
382/*******************************************************************************
383 *
384 * FUNCTION: AcpiNsGetInternalNameLength
385 *
386 * PARAMETERS: Info - Info struct initialized with the
387 * external name pointer.
388 *
389 * RETURN: Status
390 *
391 * DESCRIPTION: Calculate the length of the internal (AML) namestring
392 * corresponding to the external (ASL) namestring.
393 *
394 ******************************************************************************/
395
396void
397AcpiNsGetInternalNameLength (
398 ACPI_NAMESTRING_INFO *Info)
399{
400 char *NextExternalChar;
401 UINT32 i;
402
403
404 ACPI_FUNCTION_ENTRY ();
405
406
407 NextExternalChar = Info->ExternalName;
408 Info->NumCarats = 0;
409 Info->NumSegments = 0;
410 Info->FullyQualified = FALSE;
411
412 /*
413 * For the internal name, the required length is 4 bytes
414 * per segment, plus 1 each for RootPrefix, MultiNamePrefixOp,
415 * segment count, trailing null (which is not really needed,
416 * but no there's harm in putting it there)
417 *
418 * strlen() + 1 covers the first NameSeg, which has no
419 * path separator
420 */
421 if (AcpiNsValidRootPrefix (NextExternalChar[0]))
422 {
423 Info->FullyQualified = TRUE;
424 NextExternalChar++;
425 }
426 else
427 {
428 /*
429 * Handle Carat prefixes
430 */
431 while (*NextExternalChar == '^')
432 {
433 Info->NumCarats++;
434 NextExternalChar++;
435 }
436 }
437
438 /*
439 * Determine the number of ACPI name "segments" by counting
440 * the number of path separators within the string. Start
441 * with one segment since the segment count is (# separators)
442 * + 1, and zero separators is ok.
443 */
444 if (*NextExternalChar)
445 {
446 Info->NumSegments = 1;
447 for (i = 0; NextExternalChar[i]; i++)
448 {
449 if (AcpiNsValidPathSeparator (NextExternalChar[i]))
450 {
451 Info->NumSegments++;
452 }
453 }
454 }
455
456 Info->Length = (ACPI_NAME_SIZE * Info->NumSegments) +
457 4 + Info->NumCarats;
458
459 Info->NextExternalChar = NextExternalChar;
460}
461
462
463/*******************************************************************************
464 *
465 * FUNCTION: AcpiNsBuildInternalName
466 *
467 * PARAMETERS: Info - Info struct fully initialized
468 *
469 * RETURN: Status
470 *
471 * DESCRIPTION: Construct the internal (AML) namestring
472 * corresponding to the external (ASL) namestring.
473 *
474 ******************************************************************************/
475
476ACPI_STATUS
477AcpiNsBuildInternalName (
478 ACPI_NAMESTRING_INFO *Info)
479{
480 UINT32 NumSegments = Info->NumSegments;
481 char *InternalName = Info->InternalName;
482 char *ExternalName = Info->NextExternalChar;
483 char *Result = NULL;
484 ACPI_NATIVE_UINT i;
485
486
487 ACPI_FUNCTION_TRACE ("NsBuildInternalName");
488
489
490 /* Setup the correct prefixes, counts, and pointers */
491
492 if (Info->FullyQualified)
493 {
494 InternalName[0] = '\\';
495
496 if (NumSegments <= 1)
497 {
498 Result = &InternalName[1];
499 }
500 else if (NumSegments == 2)
501 {
502 InternalName[1] = AML_DUAL_NAME_PREFIX;
503 Result = &InternalName[2];
504 }
505 else
506 {
507 InternalName[1] = AML_MULTI_NAME_PREFIX_OP;
508 InternalName[2] = (char) NumSegments;
509 Result = &InternalName[3];
510 }
511 }
512 else
513 {
514 /*
515 * Not fully qualified.
516 * Handle Carats first, then append the name segments
517 */
518 i = 0;
519 if (Info->NumCarats)
520 {
521 for (i = 0; i < Info->NumCarats; i++)
522 {
523 InternalName[i] = '^';
524 }
525 }
526
527 if (NumSegments <= 1)
528 {
529 Result = &InternalName[i];
530 }
531 else if (NumSegments == 2)
532 {
533 InternalName[i] = AML_DUAL_NAME_PREFIX;
534 Result = &InternalName[(ACPI_NATIVE_UINT) (i+1)];
535 }
536 else
537 {
538 InternalName[i] = AML_MULTI_NAME_PREFIX_OP;
539 InternalName[(ACPI_NATIVE_UINT) (i+1)] = (char) NumSegments;
540 Result = &InternalName[(ACPI_NATIVE_UINT) (i+2)];
541 }
542 }
543
544 /* Build the name (minus path separators) */
545
546 for (; NumSegments; NumSegments--)
547 {
548 for (i = 0; i < ACPI_NAME_SIZE; i++)
549 {
550 if (AcpiNsValidPathSeparator (*ExternalName) ||
551 (*ExternalName == 0))
552 {
553 /* Pad the segment with underscore(s) if segment is short */
554
555 Result[i] = '_';
556 }
557 else
558 {
559 /* Convert the character to uppercase and save it */
560
561 Result[i] = (char) ACPI_TOUPPER ((int) *ExternalName);
562 ExternalName++;
563 }
564 }
565
566 /* Now we must have a path separator, or the pathname is bad */
567
568 if (!AcpiNsValidPathSeparator (*ExternalName) &&
569 (*ExternalName != 0))
570 {
571 return_ACPI_STATUS (AE_BAD_PARAMETER);
572 }
573
574 /* Move on the next segment */
575
576 ExternalName++;
577 Result += ACPI_NAME_SIZE;
578 }
579
580 /* Terminate the string */
581
582 *Result = 0;
583
584 if (Info->FullyQualified)
585 {
586 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n",
587 InternalName, InternalName));
588 }
589 else
590 {
591 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n",
592 InternalName, InternalName));
593 }
594
595 return_ACPI_STATUS (AE_OK);
596}
597
598
599/*******************************************************************************
600 *
601 * FUNCTION: AcpiNsInternalizeName
602 *
603 * PARAMETERS: *ExternalName - External representation of name
604 * **Converted Name - Where to return the resulting
605 * internal represention of the name
606 *
607 * RETURN: Status
608 *
609 * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0")
610 * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
611 *
612 *******************************************************************************/
613
614ACPI_STATUS
615AcpiNsInternalizeName (
616 char *ExternalName,
617 char **ConvertedName)
618{
619 char *InternalName;
620 ACPI_NAMESTRING_INFO Info;
621 ACPI_STATUS Status;
622
623
624 ACPI_FUNCTION_TRACE ("NsInternalizeName");
625
626
627 if ((!ExternalName) ||
628 (*ExternalName == 0) ||
629 (!ConvertedName))
630 {
631 return_ACPI_STATUS (AE_BAD_PARAMETER);
632 }
633
634 /* Get the length of the new internal name */
635
636 Info.ExternalName = ExternalName;
637 AcpiNsGetInternalNameLength (&Info);
638
639 /* We need a segment to store the internal name */
640
641 InternalName = ACPI_MEM_CALLOCATE (Info.Length);
642 if (!InternalName)
643 {
644 return_ACPI_STATUS (AE_NO_MEMORY);
645 }
646
647 /* Build the name */
648
649 Info.InternalName = InternalName;
650 Status = AcpiNsBuildInternalName (&Info);
651 if (ACPI_FAILURE (Status))
652 {
653 ACPI_MEM_FREE (InternalName);
654 return_ACPI_STATUS (Status);
655 }
656
657 *ConvertedName = InternalName;
658 return_ACPI_STATUS (AE_OK);
659}
660
661
662/*******************************************************************************
663 *
664 * FUNCTION: AcpiNsExternalizeName
665 *
666 * PARAMETERS: *InternalName - Internal representation of name
667 * **ConvertedName - Where to return the resulting
668 * external representation of name
669 *
670 * RETURN: Status
671 *
672 * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
673 * to its external form (e.g. "\_PR_.CPU0")
674 *
675 ******************************************************************************/
676
677ACPI_STATUS
678AcpiNsExternalizeName (
679 UINT32 InternalNameLength,
680 char *InternalName,
681 UINT32 *ConvertedNameLength,
682 char **ConvertedName)
683{
684 ACPI_NATIVE_UINT NamesIndex = 0;
685 ACPI_NATIVE_UINT NumSegments = 0;
686 ACPI_NATIVE_UINT RequiredLength;
687 ACPI_NATIVE_UINT PrefixLength = 0;
688 ACPI_NATIVE_UINT i = 0;
689 ACPI_NATIVE_UINT j = 0;
690
691
692 ACPI_FUNCTION_TRACE ("NsExternalizeName");
693
694
695 if (!InternalNameLength ||
696 !InternalName ||
697 !ConvertedName)
698 {
699 return_ACPI_STATUS (AE_BAD_PARAMETER);
700 }
701
702 /*
703 * Check for a prefix (one '\' | one or more '^').
704 */
705 switch (InternalName[0])
706 {
707 case '\\':
708 PrefixLength = 1;
709 break;
710
711 case '^':
712 for (i = 0; i < InternalNameLength; i++)
713 {
714 if (InternalName[i] == '^')
715 {
716 PrefixLength = i + 1;
717 }
718 else
719 {
720 break;
721 }
722 }
723
724 if (i == InternalNameLength)
725 {
726 PrefixLength = i;
727 }
728
729 break;
730
731 default:
732 break;
733 }
734
735 /*
736 * Check for object names. Note that there could be 0-255 of these
737 * 4-byte elements.
738 */
739 if (PrefixLength < InternalNameLength)
740 {
741 switch (InternalName[PrefixLength])
742 {
743 case AML_MULTI_NAME_PREFIX_OP:
744
745 /* <count> 4-byte names */
746
747 NamesIndex = PrefixLength + 2;
748 NumSegments = (ACPI_NATIVE_UINT) (UINT8) InternalName[(ACPI_NATIVE_UINT) (PrefixLength + 1)];
749 break;
750
751 case AML_DUAL_NAME_PREFIX:
752
753 /* Two 4-byte names */
754
755 NamesIndex = PrefixLength + 1;
756 NumSegments = 2;
757 break;
758
759 case 0:
760
761 /* NullName */
762
763 NamesIndex = 0;
764 NumSegments = 0;
765 break;
766
767 default:
768
769 /* one 4-byte name */
770
771 NamesIndex = PrefixLength;
772 NumSegments = 1;
773 break;
774 }
775 }
776
777 /*
778 * Calculate the length of ConvertedName, which equals the length
779 * of the prefix, length of all object names, length of any required
780 * punctuation ('.') between object names, plus the NULL terminator.
781 */
782 RequiredLength = PrefixLength + (4 * NumSegments) +
783 ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1;
784
785 /*
786 * Check to see if we're still in bounds. If not, there's a problem
787 * with InternalName (invalid format).
788 */
789 if (RequiredLength > InternalNameLength)
790 {
791 ACPI_REPORT_ERROR (("NsExternalizeName: Invalid internal name\n"));
792 return_ACPI_STATUS (AE_BAD_PATHNAME);
793 }
794
795 /*
796 * Build ConvertedName...
797 */
798 *ConvertedName = ACPI_MEM_CALLOCATE (RequiredLength);
799 if (!(*ConvertedName))
800 {
801 return_ACPI_STATUS (AE_NO_MEMORY);
802 }
803
804 j = 0;
805
806 for (i = 0; i < PrefixLength; i++)
807 {
808 (*ConvertedName)[j++] = InternalName[i];
809 }
810
811 if (NumSegments > 0)
812 {
813 for (i = 0; i < NumSegments; i++)
814 {
815 if (i > 0)
816 {
817 (*ConvertedName)[j++] = '.';
818 }
819
820 (*ConvertedName)[j++] = InternalName[NamesIndex++];
821 (*ConvertedName)[j++] = InternalName[NamesIndex++];
822 (*ConvertedName)[j++] = InternalName[NamesIndex++];
823 (*ConvertedName)[j++] = InternalName[NamesIndex++];
824 }
825 }
826
827 if (ConvertedNameLength)
828 {
829 *ConvertedNameLength = (UINT32) RequiredLength;
830 }
831
832 return_ACPI_STATUS (AE_OK);
833}
834
835
836/*******************************************************************************
837 *
838 * FUNCTION: AcpiNsMapHandleToNode
839 *
840 * PARAMETERS: Handle - Handle to be converted to an Node
841 *
842 * RETURN: A Name table entry pointer
843 *
844 * DESCRIPTION: Convert a namespace handle to a real Node
845 *
846 * Note: Real integer handles allow for more verification
847 * and keep all pointers within this subsystem.
848 *
849 ******************************************************************************/
850
851ACPI_NAMESPACE_NODE *
852AcpiNsMapHandleToNode (
853 ACPI_HANDLE Handle)
854{
855
856 ACPI_FUNCTION_ENTRY ();
857
858
859 /*
860 * Simple implementation.
861 */
862 if (!Handle)
863 {
864 return (NULL);
865 }
866
867 if (Handle == ACPI_ROOT_OBJECT)
868 {
869 return (AcpiGbl_RootNode);
870 }
871
872 /* We can at least attempt to verify the handle */
873
874 if (ACPI_GET_DESCRIPTOR_TYPE (Handle) != ACPI_DESC_TYPE_NAMED)
875 {
876 return (NULL);
877 }
878
879 return ((ACPI_NAMESPACE_NODE *) Handle);
880}
881
882
883/*******************************************************************************
884 *
885 * FUNCTION: AcpiNsConvertEntryToHandle
886 *
887 * PARAMETERS: Node - Node to be converted to a Handle
888 *
889 * RETURN: An USER ACPI_HANDLE
890 *
891 * DESCRIPTION: Convert a real Node to a namespace handle
892 *
893 ******************************************************************************/
894
895ACPI_HANDLE
896AcpiNsConvertEntryToHandle (
897 ACPI_NAMESPACE_NODE *Node)
898{
899
900
901 /*
902 * Simple implementation for now;
903 */
904 return ((ACPI_HANDLE) Node);
905
906
907/* ---------------------------------------------------
908
909 if (!Node)
910 {
911 return (NULL);
912 }
913
914 if (Node == AcpiGbl_RootNode)
915 {
916 return (ACPI_ROOT_OBJECT);
917 }
918
919
920 return ((ACPI_HANDLE) Node);
921------------------------------------------------------*/
922}
923
924
925/*******************************************************************************
926 *
927 * FUNCTION: AcpiNsTerminate
928 *
929 * PARAMETERS: none
930 *
931 * RETURN: none
932 *
933 * DESCRIPTION: free memory allocated for table storage.
934 *
935 ******************************************************************************/
936
937void
938AcpiNsTerminate (void)
939{
940 ACPI_OPERAND_OBJECT *ObjDesc;
941
942
943 ACPI_FUNCTION_TRACE ("NsTerminate");
944
945
946 /*
947 * 1) Free the entire namespace -- all nodes and objects
948 *
949 * Delete all object descriptors attached to namepsace nodes
950 */
951 AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
952
953 /* Detach any objects attached to the root */
954
955 ObjDesc = AcpiNsGetAttachedObject (AcpiGbl_RootNode);
956 if (ObjDesc)
957 {
958 AcpiNsDetachObject (AcpiGbl_RootNode);
959 }
960
961 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n"));
962
963 /*
964 * 2) Now we can delete the ACPI tables
965 */
966 AcpiTbDeleteAllTables ();
967 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n"));
968
969 return_VOID;
970}
971
972
973/*******************************************************************************
974 *
975 * FUNCTION: AcpiNsOpensScope
976 *
977 * PARAMETERS: Type - A valid namespace type
978 *
979 * RETURN: NEWSCOPE if the passed type "opens a name scope" according
980 * to the ACPI specification, else 0
981 *
982 ******************************************************************************/
983
984UINT32
985AcpiNsOpensScope (
986 ACPI_OBJECT_TYPE Type)
987{
988 ACPI_FUNCTION_TRACE_STR ("NsOpensScope", AcpiUtGetTypeName (Type));
989
990
991 if (!AcpiUtValidObjectType (Type))
992 {
993 /* type code out of range */
994
995 ACPI_REPORT_WARNING (("NsOpensScope: Invalid Object Type %X\n", Type));
996 return_VALUE (ACPI_NS_NORMAL);
997 }
998
999 return_VALUE (((UINT32) AcpiGbl_NsProperties[Type]) & ACPI_NS_NEWSCOPE);
1000}
1001
1002
1003/*******************************************************************************
1004 *
1005 * FUNCTION: AcpiNsGetNodeByPath
1006 *
1007 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
1008 * \ (backslash) and ^ (carat) prefixes, and the
1009 * . (period) to separate segments are supported.
1010 * StartNode - Root of subtree to be searched, or NS_ALL for the
1011 * root of the name space. If Name is fully
1012 * qualified (first INT8 is '\'), the passed value
1013 * of Scope will not be accessed.
1014 * Flags - Used to indicate whether to perform upsearch or
1015 * not.
1016 * ReturnNode - Where the Node is returned
1017 *
1018 * DESCRIPTION: Look up a name relative to a given scope and return the
1019 * corresponding Node. NOTE: Scope can be null.
1020 *
1021 * MUTEX: Locks namespace
1022 *
1023 ******************************************************************************/
1024
1025ACPI_STATUS
1026AcpiNsGetNodeByPath (
1027 char *Pathname,
1028 ACPI_NAMESPACE_NODE *StartNode,
1029 UINT32 Flags,
1030 ACPI_NAMESPACE_NODE **ReturnNode)
1031{
1032 ACPI_GENERIC_STATE ScopeInfo;
1033 ACPI_STATUS Status;
1034 char *InternalPath = NULL;
1035
1036
1037 ACPI_FUNCTION_TRACE_PTR ("NsGetNodeByPath", Pathname);
1038
1039
1040 if (Pathname)
1041 {
1042 /* Convert path to internal representation */
1043
1044 Status = AcpiNsInternalizeName (Pathname, &InternalPath);
1045 if (ACPI_FAILURE (Status))
1046 {
1047 return_ACPI_STATUS (Status);
1048 }
1049 }
1050
1051 /* Must lock namespace during lookup */
1052
1053 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
1054 if (ACPI_FAILURE (Status))
1055 {
1056 goto Cleanup;
1057 }
1058
1059 /* Setup lookup scope (search starting point) */
1060
1061 ScopeInfo.Scope.Node = StartNode;
1062
1063 /* Lookup the name in the namespace */
1064
1065 Status = AcpiNsLookup (&ScopeInfo, InternalPath,
1066 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
1067 (Flags | ACPI_NS_DONT_OPEN_SCOPE),
1068 NULL, ReturnNode);
1069 if (ACPI_FAILURE (Status))
1070 {
1071 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s, %s\n",
1072 InternalPath, AcpiFormatException (Status)));
1073 }
1074
1075 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
1076
1077Cleanup:
1078 /* Cleanup */
1079 if (InternalPath)
1080 {
1081 ACPI_MEM_FREE (InternalPath);
1082 }
1083 return_ACPI_STATUS (Status);
1084}
1085
1086
1087/*******************************************************************************
1088 *
1089 * FUNCTION: AcpiNsFindParentName
1090 *
1091 * PARAMETERS: *ChildNode - Named Obj whose name is to be found
1092 *
1093 * RETURN: The ACPI name
1094 *
1095 * DESCRIPTION: Search for the given obj in its parent scope and return the
1096 * name segment, or "????" if the parent name can't be found
1097 * (which "should not happen").
1098 *
1099 ******************************************************************************/
1100
1101ACPI_NAME
1102AcpiNsFindParentName (
1103 ACPI_NAMESPACE_NODE *ChildNode)
1104{
1105 ACPI_NAMESPACE_NODE *ParentNode;
1106
1107
1108 ACPI_FUNCTION_TRACE ("NsFindParentName");
1109
1110
1111 if (ChildNode)
1112 {
1113 /* Valid entry. Get the parent Node */
1114
1115 ParentNode = AcpiNsGetParentNode (ChildNode);
1116 if (ParentNode)
1117 {
1118 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]\n",
1119 ChildNode, AcpiUtGetNodeName (ChildNode),
1120 ParentNode, AcpiUtGetNodeName (ParentNode)));
1121
1122 if (ParentNode->Name.Integer)
1123 {
1124 return_VALUE ((ACPI_NAME) ParentNode->Name.Integer);
1125 }
1126 }
1127
1128 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)\n",
1129 ChildNode, AcpiUtGetNodeName (ChildNode)));
1130 }
1131
1132 return_VALUE (ACPI_UNKNOWN_NAME);
1133}
1134
1135
1136/*******************************************************************************
1137 *
1138 * FUNCTION: AcpiNsGetParentNode
1139 *
1140 * PARAMETERS: Node - Current table entry
1141 *
1142 * RETURN: Parent entry of the given entry
1143 *
1144 * DESCRIPTION: Obtain the parent entry for a given entry in the namespace.
1145 *
1146 ******************************************************************************/
1147
1148
1149ACPI_NAMESPACE_NODE *
1150AcpiNsGetParentNode (
1151 ACPI_NAMESPACE_NODE *Node)
1152{
1153 ACPI_FUNCTION_ENTRY ();
1154
1155
1156 if (!Node)
1157 {
1158 return (NULL);
1159 }
1160
1161 /*
1162 * Walk to the end of this peer list.
1163 * The last entry is marked with a flag and the peer
1164 * pointer is really a pointer back to the parent.
1165 * This saves putting a parent back pointer in each and
1166 * every named object!
1167 */
1168 while (!(Node->Flags & ANOBJ_END_OF_PEER_LIST))
1169 {
1170 Node = Node->Peer;
1171 }
1172
1173
1174 return (Node->Peer);
1175}
1176
1177
1178/*******************************************************************************
1179 *
1180 * FUNCTION: AcpiNsGetNextValidNode
1181 *
1182 * PARAMETERS: Node - Current table entry
1183 *
1184 * RETURN: Next valid Node in the linked node list. NULL if no more valid
1185 * nodess
1186 *
1187 * DESCRIPTION: Find the next valid node within a name table.
1188 * Useful for implementing NULL-end-of-list loops.
1189 *
1190 ******************************************************************************/
1191
1192
1193ACPI_NAMESPACE_NODE *
1194AcpiNsGetNextValidNode (
1195 ACPI_NAMESPACE_NODE *Node)
1196{
1197
1198 /* If we are at the end of this peer list, return NULL */
1199
1200 if (Node->Flags & ANOBJ_END_OF_PEER_LIST)
1201 {
1202 return NULL;
1203 }
1204
1205 /* Otherwise just return the next peer */
1206
1207 return (Node->Peer);
1208}
1209
1210
| 345 return_VALUE (ACPI_TYPE_ANY);
346 }
347
348 return_VALUE ((ACPI_OBJECT_TYPE) Node->Type);
349}
350
351
352/*******************************************************************************
353 *
354 * FUNCTION: AcpiNsLocal
355 *
356 * PARAMETERS: Type - A namespace object type
357 *
358 * RETURN: LOCAL if names must be found locally in objects of the
359 * passed type, 0 if enclosing scopes should be searched
360 *
361 ******************************************************************************/
362
363UINT32
364AcpiNsLocal (
365 ACPI_OBJECT_TYPE Type)
366{
367 ACPI_FUNCTION_TRACE ("NsLocal");
368
369
370 if (!AcpiUtValidObjectType (Type))
371 {
372 /* Type code out of range */
373
374 ACPI_REPORT_WARNING (("NsLocal: Invalid Object Type\n"));
375 return_VALUE (ACPI_NS_NORMAL);
376 }
377
378 return_VALUE ((UINT32) AcpiGbl_NsProperties[Type] & ACPI_NS_LOCAL);
379}
380
381
382/*******************************************************************************
383 *
384 * FUNCTION: AcpiNsGetInternalNameLength
385 *
386 * PARAMETERS: Info - Info struct initialized with the
387 * external name pointer.
388 *
389 * RETURN: Status
390 *
391 * DESCRIPTION: Calculate the length of the internal (AML) namestring
392 * corresponding to the external (ASL) namestring.
393 *
394 ******************************************************************************/
395
396void
397AcpiNsGetInternalNameLength (
398 ACPI_NAMESTRING_INFO *Info)
399{
400 char *NextExternalChar;
401 UINT32 i;
402
403
404 ACPI_FUNCTION_ENTRY ();
405
406
407 NextExternalChar = Info->ExternalName;
408 Info->NumCarats = 0;
409 Info->NumSegments = 0;
410 Info->FullyQualified = FALSE;
411
412 /*
413 * For the internal name, the required length is 4 bytes
414 * per segment, plus 1 each for RootPrefix, MultiNamePrefixOp,
415 * segment count, trailing null (which is not really needed,
416 * but no there's harm in putting it there)
417 *
418 * strlen() + 1 covers the first NameSeg, which has no
419 * path separator
420 */
421 if (AcpiNsValidRootPrefix (NextExternalChar[0]))
422 {
423 Info->FullyQualified = TRUE;
424 NextExternalChar++;
425 }
426 else
427 {
428 /*
429 * Handle Carat prefixes
430 */
431 while (*NextExternalChar == '^')
432 {
433 Info->NumCarats++;
434 NextExternalChar++;
435 }
436 }
437
438 /*
439 * Determine the number of ACPI name "segments" by counting
440 * the number of path separators within the string. Start
441 * with one segment since the segment count is (# separators)
442 * + 1, and zero separators is ok.
443 */
444 if (*NextExternalChar)
445 {
446 Info->NumSegments = 1;
447 for (i = 0; NextExternalChar[i]; i++)
448 {
449 if (AcpiNsValidPathSeparator (NextExternalChar[i]))
450 {
451 Info->NumSegments++;
452 }
453 }
454 }
455
456 Info->Length = (ACPI_NAME_SIZE * Info->NumSegments) +
457 4 + Info->NumCarats;
458
459 Info->NextExternalChar = NextExternalChar;
460}
461
462
463/*******************************************************************************
464 *
465 * FUNCTION: AcpiNsBuildInternalName
466 *
467 * PARAMETERS: Info - Info struct fully initialized
468 *
469 * RETURN: Status
470 *
471 * DESCRIPTION: Construct the internal (AML) namestring
472 * corresponding to the external (ASL) namestring.
473 *
474 ******************************************************************************/
475
476ACPI_STATUS
477AcpiNsBuildInternalName (
478 ACPI_NAMESTRING_INFO *Info)
479{
480 UINT32 NumSegments = Info->NumSegments;
481 char *InternalName = Info->InternalName;
482 char *ExternalName = Info->NextExternalChar;
483 char *Result = NULL;
484 ACPI_NATIVE_UINT i;
485
486
487 ACPI_FUNCTION_TRACE ("NsBuildInternalName");
488
489
490 /* Setup the correct prefixes, counts, and pointers */
491
492 if (Info->FullyQualified)
493 {
494 InternalName[0] = '\\';
495
496 if (NumSegments <= 1)
497 {
498 Result = &InternalName[1];
499 }
500 else if (NumSegments == 2)
501 {
502 InternalName[1] = AML_DUAL_NAME_PREFIX;
503 Result = &InternalName[2];
504 }
505 else
506 {
507 InternalName[1] = AML_MULTI_NAME_PREFIX_OP;
508 InternalName[2] = (char) NumSegments;
509 Result = &InternalName[3];
510 }
511 }
512 else
513 {
514 /*
515 * Not fully qualified.
516 * Handle Carats first, then append the name segments
517 */
518 i = 0;
519 if (Info->NumCarats)
520 {
521 for (i = 0; i < Info->NumCarats; i++)
522 {
523 InternalName[i] = '^';
524 }
525 }
526
527 if (NumSegments <= 1)
528 {
529 Result = &InternalName[i];
530 }
531 else if (NumSegments == 2)
532 {
533 InternalName[i] = AML_DUAL_NAME_PREFIX;
534 Result = &InternalName[(ACPI_NATIVE_UINT) (i+1)];
535 }
536 else
537 {
538 InternalName[i] = AML_MULTI_NAME_PREFIX_OP;
539 InternalName[(ACPI_NATIVE_UINT) (i+1)] = (char) NumSegments;
540 Result = &InternalName[(ACPI_NATIVE_UINT) (i+2)];
541 }
542 }
543
544 /* Build the name (minus path separators) */
545
546 for (; NumSegments; NumSegments--)
547 {
548 for (i = 0; i < ACPI_NAME_SIZE; i++)
549 {
550 if (AcpiNsValidPathSeparator (*ExternalName) ||
551 (*ExternalName == 0))
552 {
553 /* Pad the segment with underscore(s) if segment is short */
554
555 Result[i] = '_';
556 }
557 else
558 {
559 /* Convert the character to uppercase and save it */
560
561 Result[i] = (char) ACPI_TOUPPER ((int) *ExternalName);
562 ExternalName++;
563 }
564 }
565
566 /* Now we must have a path separator, or the pathname is bad */
567
568 if (!AcpiNsValidPathSeparator (*ExternalName) &&
569 (*ExternalName != 0))
570 {
571 return_ACPI_STATUS (AE_BAD_PARAMETER);
572 }
573
574 /* Move on the next segment */
575
576 ExternalName++;
577 Result += ACPI_NAME_SIZE;
578 }
579
580 /* Terminate the string */
581
582 *Result = 0;
583
584 if (Info->FullyQualified)
585 {
586 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n",
587 InternalName, InternalName));
588 }
589 else
590 {
591 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n",
592 InternalName, InternalName));
593 }
594
595 return_ACPI_STATUS (AE_OK);
596}
597
598
599/*******************************************************************************
600 *
601 * FUNCTION: AcpiNsInternalizeName
602 *
603 * PARAMETERS: *ExternalName - External representation of name
604 * **Converted Name - Where to return the resulting
605 * internal represention of the name
606 *
607 * RETURN: Status
608 *
609 * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0")
610 * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
611 *
612 *******************************************************************************/
613
614ACPI_STATUS
615AcpiNsInternalizeName (
616 char *ExternalName,
617 char **ConvertedName)
618{
619 char *InternalName;
620 ACPI_NAMESTRING_INFO Info;
621 ACPI_STATUS Status;
622
623
624 ACPI_FUNCTION_TRACE ("NsInternalizeName");
625
626
627 if ((!ExternalName) ||
628 (*ExternalName == 0) ||
629 (!ConvertedName))
630 {
631 return_ACPI_STATUS (AE_BAD_PARAMETER);
632 }
633
634 /* Get the length of the new internal name */
635
636 Info.ExternalName = ExternalName;
637 AcpiNsGetInternalNameLength (&Info);
638
639 /* We need a segment to store the internal name */
640
641 InternalName = ACPI_MEM_CALLOCATE (Info.Length);
642 if (!InternalName)
643 {
644 return_ACPI_STATUS (AE_NO_MEMORY);
645 }
646
647 /* Build the name */
648
649 Info.InternalName = InternalName;
650 Status = AcpiNsBuildInternalName (&Info);
651 if (ACPI_FAILURE (Status))
652 {
653 ACPI_MEM_FREE (InternalName);
654 return_ACPI_STATUS (Status);
655 }
656
657 *ConvertedName = InternalName;
658 return_ACPI_STATUS (AE_OK);
659}
660
661
662/*******************************************************************************
663 *
664 * FUNCTION: AcpiNsExternalizeName
665 *
666 * PARAMETERS: *InternalName - Internal representation of name
667 * **ConvertedName - Where to return the resulting
668 * external representation of name
669 *
670 * RETURN: Status
671 *
672 * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
673 * to its external form (e.g. "\_PR_.CPU0")
674 *
675 ******************************************************************************/
676
677ACPI_STATUS
678AcpiNsExternalizeName (
679 UINT32 InternalNameLength,
680 char *InternalName,
681 UINT32 *ConvertedNameLength,
682 char **ConvertedName)
683{
684 ACPI_NATIVE_UINT NamesIndex = 0;
685 ACPI_NATIVE_UINT NumSegments = 0;
686 ACPI_NATIVE_UINT RequiredLength;
687 ACPI_NATIVE_UINT PrefixLength = 0;
688 ACPI_NATIVE_UINT i = 0;
689 ACPI_NATIVE_UINT j = 0;
690
691
692 ACPI_FUNCTION_TRACE ("NsExternalizeName");
693
694
695 if (!InternalNameLength ||
696 !InternalName ||
697 !ConvertedName)
698 {
699 return_ACPI_STATUS (AE_BAD_PARAMETER);
700 }
701
702 /*
703 * Check for a prefix (one '\' | one or more '^').
704 */
705 switch (InternalName[0])
706 {
707 case '\\':
708 PrefixLength = 1;
709 break;
710
711 case '^':
712 for (i = 0; i < InternalNameLength; i++)
713 {
714 if (InternalName[i] == '^')
715 {
716 PrefixLength = i + 1;
717 }
718 else
719 {
720 break;
721 }
722 }
723
724 if (i == InternalNameLength)
725 {
726 PrefixLength = i;
727 }
728
729 break;
730
731 default:
732 break;
733 }
734
735 /*
736 * Check for object names. Note that there could be 0-255 of these
737 * 4-byte elements.
738 */
739 if (PrefixLength < InternalNameLength)
740 {
741 switch (InternalName[PrefixLength])
742 {
743 case AML_MULTI_NAME_PREFIX_OP:
744
745 /* <count> 4-byte names */
746
747 NamesIndex = PrefixLength + 2;
748 NumSegments = (ACPI_NATIVE_UINT) (UINT8) InternalName[(ACPI_NATIVE_UINT) (PrefixLength + 1)];
749 break;
750
751 case AML_DUAL_NAME_PREFIX:
752
753 /* Two 4-byte names */
754
755 NamesIndex = PrefixLength + 1;
756 NumSegments = 2;
757 break;
758
759 case 0:
760
761 /* NullName */
762
763 NamesIndex = 0;
764 NumSegments = 0;
765 break;
766
767 default:
768
769 /* one 4-byte name */
770
771 NamesIndex = PrefixLength;
772 NumSegments = 1;
773 break;
774 }
775 }
776
777 /*
778 * Calculate the length of ConvertedName, which equals the length
779 * of the prefix, length of all object names, length of any required
780 * punctuation ('.') between object names, plus the NULL terminator.
781 */
782 RequiredLength = PrefixLength + (4 * NumSegments) +
783 ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1;
784
785 /*
786 * Check to see if we're still in bounds. If not, there's a problem
787 * with InternalName (invalid format).
788 */
789 if (RequiredLength > InternalNameLength)
790 {
791 ACPI_REPORT_ERROR (("NsExternalizeName: Invalid internal name\n"));
792 return_ACPI_STATUS (AE_BAD_PATHNAME);
793 }
794
795 /*
796 * Build ConvertedName...
797 */
798 *ConvertedName = ACPI_MEM_CALLOCATE (RequiredLength);
799 if (!(*ConvertedName))
800 {
801 return_ACPI_STATUS (AE_NO_MEMORY);
802 }
803
804 j = 0;
805
806 for (i = 0; i < PrefixLength; i++)
807 {
808 (*ConvertedName)[j++] = InternalName[i];
809 }
810
811 if (NumSegments > 0)
812 {
813 for (i = 0; i < NumSegments; i++)
814 {
815 if (i > 0)
816 {
817 (*ConvertedName)[j++] = '.';
818 }
819
820 (*ConvertedName)[j++] = InternalName[NamesIndex++];
821 (*ConvertedName)[j++] = InternalName[NamesIndex++];
822 (*ConvertedName)[j++] = InternalName[NamesIndex++];
823 (*ConvertedName)[j++] = InternalName[NamesIndex++];
824 }
825 }
826
827 if (ConvertedNameLength)
828 {
829 *ConvertedNameLength = (UINT32) RequiredLength;
830 }
831
832 return_ACPI_STATUS (AE_OK);
833}
834
835
836/*******************************************************************************
837 *
838 * FUNCTION: AcpiNsMapHandleToNode
839 *
840 * PARAMETERS: Handle - Handle to be converted to an Node
841 *
842 * RETURN: A Name table entry pointer
843 *
844 * DESCRIPTION: Convert a namespace handle to a real Node
845 *
846 * Note: Real integer handles allow for more verification
847 * and keep all pointers within this subsystem.
848 *
849 ******************************************************************************/
850
851ACPI_NAMESPACE_NODE *
852AcpiNsMapHandleToNode (
853 ACPI_HANDLE Handle)
854{
855
856 ACPI_FUNCTION_ENTRY ();
857
858
859 /*
860 * Simple implementation.
861 */
862 if (!Handle)
863 {
864 return (NULL);
865 }
866
867 if (Handle == ACPI_ROOT_OBJECT)
868 {
869 return (AcpiGbl_RootNode);
870 }
871
872 /* We can at least attempt to verify the handle */
873
874 if (ACPI_GET_DESCRIPTOR_TYPE (Handle) != ACPI_DESC_TYPE_NAMED)
875 {
876 return (NULL);
877 }
878
879 return ((ACPI_NAMESPACE_NODE *) Handle);
880}
881
882
883/*******************************************************************************
884 *
885 * FUNCTION: AcpiNsConvertEntryToHandle
886 *
887 * PARAMETERS: Node - Node to be converted to a Handle
888 *
889 * RETURN: An USER ACPI_HANDLE
890 *
891 * DESCRIPTION: Convert a real Node to a namespace handle
892 *
893 ******************************************************************************/
894
895ACPI_HANDLE
896AcpiNsConvertEntryToHandle (
897 ACPI_NAMESPACE_NODE *Node)
898{
899
900
901 /*
902 * Simple implementation for now;
903 */
904 return ((ACPI_HANDLE) Node);
905
906
907/* ---------------------------------------------------
908
909 if (!Node)
910 {
911 return (NULL);
912 }
913
914 if (Node == AcpiGbl_RootNode)
915 {
916 return (ACPI_ROOT_OBJECT);
917 }
918
919
920 return ((ACPI_HANDLE) Node);
921------------------------------------------------------*/
922}
923
924
925/*******************************************************************************
926 *
927 * FUNCTION: AcpiNsTerminate
928 *
929 * PARAMETERS: none
930 *
931 * RETURN: none
932 *
933 * DESCRIPTION: free memory allocated for table storage.
934 *
935 ******************************************************************************/
936
937void
938AcpiNsTerminate (void)
939{
940 ACPI_OPERAND_OBJECT *ObjDesc;
941
942
943 ACPI_FUNCTION_TRACE ("NsTerminate");
944
945
946 /*
947 * 1) Free the entire namespace -- all nodes and objects
948 *
949 * Delete all object descriptors attached to namepsace nodes
950 */
951 AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
952
953 /* Detach any objects attached to the root */
954
955 ObjDesc = AcpiNsGetAttachedObject (AcpiGbl_RootNode);
956 if (ObjDesc)
957 {
958 AcpiNsDetachObject (AcpiGbl_RootNode);
959 }
960
961 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n"));
962
963 /*
964 * 2) Now we can delete the ACPI tables
965 */
966 AcpiTbDeleteAllTables ();
967 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n"));
968
969 return_VOID;
970}
971
972
973/*******************************************************************************
974 *
975 * FUNCTION: AcpiNsOpensScope
976 *
977 * PARAMETERS: Type - A valid namespace type
978 *
979 * RETURN: NEWSCOPE if the passed type "opens a name scope" according
980 * to the ACPI specification, else 0
981 *
982 ******************************************************************************/
983
984UINT32
985AcpiNsOpensScope (
986 ACPI_OBJECT_TYPE Type)
987{
988 ACPI_FUNCTION_TRACE_STR ("NsOpensScope", AcpiUtGetTypeName (Type));
989
990
991 if (!AcpiUtValidObjectType (Type))
992 {
993 /* type code out of range */
994
995 ACPI_REPORT_WARNING (("NsOpensScope: Invalid Object Type %X\n", Type));
996 return_VALUE (ACPI_NS_NORMAL);
997 }
998
999 return_VALUE (((UINT32) AcpiGbl_NsProperties[Type]) & ACPI_NS_NEWSCOPE);
1000}
1001
1002
1003/*******************************************************************************
1004 *
1005 * FUNCTION: AcpiNsGetNodeByPath
1006 *
1007 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
1008 * \ (backslash) and ^ (carat) prefixes, and the
1009 * . (period) to separate segments are supported.
1010 * StartNode - Root of subtree to be searched, or NS_ALL for the
1011 * root of the name space. If Name is fully
1012 * qualified (first INT8 is '\'), the passed value
1013 * of Scope will not be accessed.
1014 * Flags - Used to indicate whether to perform upsearch or
1015 * not.
1016 * ReturnNode - Where the Node is returned
1017 *
1018 * DESCRIPTION: Look up a name relative to a given scope and return the
1019 * corresponding Node. NOTE: Scope can be null.
1020 *
1021 * MUTEX: Locks namespace
1022 *
1023 ******************************************************************************/
1024
1025ACPI_STATUS
1026AcpiNsGetNodeByPath (
1027 char *Pathname,
1028 ACPI_NAMESPACE_NODE *StartNode,
1029 UINT32 Flags,
1030 ACPI_NAMESPACE_NODE **ReturnNode)
1031{
1032 ACPI_GENERIC_STATE ScopeInfo;
1033 ACPI_STATUS Status;
1034 char *InternalPath = NULL;
1035
1036
1037 ACPI_FUNCTION_TRACE_PTR ("NsGetNodeByPath", Pathname);
1038
1039
1040 if (Pathname)
1041 {
1042 /* Convert path to internal representation */
1043
1044 Status = AcpiNsInternalizeName (Pathname, &InternalPath);
1045 if (ACPI_FAILURE (Status))
1046 {
1047 return_ACPI_STATUS (Status);
1048 }
1049 }
1050
1051 /* Must lock namespace during lookup */
1052
1053 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
1054 if (ACPI_FAILURE (Status))
1055 {
1056 goto Cleanup;
1057 }
1058
1059 /* Setup lookup scope (search starting point) */
1060
1061 ScopeInfo.Scope.Node = StartNode;
1062
1063 /* Lookup the name in the namespace */
1064
1065 Status = AcpiNsLookup (&ScopeInfo, InternalPath,
1066 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
1067 (Flags | ACPI_NS_DONT_OPEN_SCOPE),
1068 NULL, ReturnNode);
1069 if (ACPI_FAILURE (Status))
1070 {
1071 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s, %s\n",
1072 InternalPath, AcpiFormatException (Status)));
1073 }
1074
1075 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
1076
1077Cleanup:
1078 /* Cleanup */
1079 if (InternalPath)
1080 {
1081 ACPI_MEM_FREE (InternalPath);
1082 }
1083 return_ACPI_STATUS (Status);
1084}
1085
1086
1087/*******************************************************************************
1088 *
1089 * FUNCTION: AcpiNsFindParentName
1090 *
1091 * PARAMETERS: *ChildNode - Named Obj whose name is to be found
1092 *
1093 * RETURN: The ACPI name
1094 *
1095 * DESCRIPTION: Search for the given obj in its parent scope and return the
1096 * name segment, or "????" if the parent name can't be found
1097 * (which "should not happen").
1098 *
1099 ******************************************************************************/
1100
1101ACPI_NAME
1102AcpiNsFindParentName (
1103 ACPI_NAMESPACE_NODE *ChildNode)
1104{
1105 ACPI_NAMESPACE_NODE *ParentNode;
1106
1107
1108 ACPI_FUNCTION_TRACE ("NsFindParentName");
1109
1110
1111 if (ChildNode)
1112 {
1113 /* Valid entry. Get the parent Node */
1114
1115 ParentNode = AcpiNsGetParentNode (ChildNode);
1116 if (ParentNode)
1117 {
1118 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]\n",
1119 ChildNode, AcpiUtGetNodeName (ChildNode),
1120 ParentNode, AcpiUtGetNodeName (ParentNode)));
1121
1122 if (ParentNode->Name.Integer)
1123 {
1124 return_VALUE ((ACPI_NAME) ParentNode->Name.Integer);
1125 }
1126 }
1127
1128 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)\n",
1129 ChildNode, AcpiUtGetNodeName (ChildNode)));
1130 }
1131
1132 return_VALUE (ACPI_UNKNOWN_NAME);
1133}
1134
1135
1136/*******************************************************************************
1137 *
1138 * FUNCTION: AcpiNsGetParentNode
1139 *
1140 * PARAMETERS: Node - Current table entry
1141 *
1142 * RETURN: Parent entry of the given entry
1143 *
1144 * DESCRIPTION: Obtain the parent entry for a given entry in the namespace.
1145 *
1146 ******************************************************************************/
1147
1148
1149ACPI_NAMESPACE_NODE *
1150AcpiNsGetParentNode (
1151 ACPI_NAMESPACE_NODE *Node)
1152{
1153 ACPI_FUNCTION_ENTRY ();
1154
1155
1156 if (!Node)
1157 {
1158 return (NULL);
1159 }
1160
1161 /*
1162 * Walk to the end of this peer list.
1163 * The last entry is marked with a flag and the peer
1164 * pointer is really a pointer back to the parent.
1165 * This saves putting a parent back pointer in each and
1166 * every named object!
1167 */
1168 while (!(Node->Flags & ANOBJ_END_OF_PEER_LIST))
1169 {
1170 Node = Node->Peer;
1171 }
1172
1173
1174 return (Node->Peer);
1175}
1176
1177
1178/*******************************************************************************
1179 *
1180 * FUNCTION: AcpiNsGetNextValidNode
1181 *
1182 * PARAMETERS: Node - Current table entry
1183 *
1184 * RETURN: Next valid Node in the linked node list. NULL if no more valid
1185 * nodess
1186 *
1187 * DESCRIPTION: Find the next valid node within a name table.
1188 * Useful for implementing NULL-end-of-list loops.
1189 *
1190 ******************************************************************************/
1191
1192
1193ACPI_NAMESPACE_NODE *
1194AcpiNsGetNextValidNode (
1195 ACPI_NAMESPACE_NODE *Node)
1196{
1197
1198 /* If we are at the end of this peer list, return NULL */
1199
1200 if (Node->Flags & ANOBJ_END_OF_PEER_LIST)
1201 {
1202 return NULL;
1203 }
1204
1205 /* Otherwise just return the next peer */
1206
1207 return (Node->Peer);
1208}
1209
1210
|