1 /******************************************************************************
2 *
3 * Module Name: exdump - Interpreter debug output routines
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acinterp.h"
155 #include "amlcode.h"
156 #include "acnamesp.h"
157
158
159 #define _COMPONENT ACPI_EXECUTER
160 ACPI_MODULE_NAME ("exdump")
161
162 /*
163 * The following routines are used for debug output only
164 */
165 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
166
167 /* Local prototypes */
168
169 static void
170 AcpiExOutString (
171 const char *Title,
172 const char *Value);
173
174 static void
175 AcpiExOutPointer (
176 const char *Title,
177 const void *Value);
178
179 static void
180 AcpiExDumpObject (
181 ACPI_OPERAND_OBJECT *ObjDesc,
182 ACPI_EXDUMP_INFO *Info);
183
184 static void
185 AcpiExDumpReferenceObj (
186 ACPI_OPERAND_OBJECT *ObjDesc);
187
188 static void
189 AcpiExDumpPackageObj (
190 ACPI_OPERAND_OBJECT *ObjDesc,
191 UINT32 Level,
192 UINT32 Index);
193
194
195 /*******************************************************************************
196 *
197 * Object Descriptor info tables
198 *
199 * Note: The first table entry must be an INIT opcode and must contain
200 * the table length (number of table entries)
201 *
202 ******************************************************************************/
203
204 static ACPI_EXDUMP_INFO AcpiExDumpInteger[2] =
205 {
206 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpInteger), NULL},
207 {ACPI_EXD_UINT64, ACPI_EXD_OFFSET (Integer.Value), "Value"}
208 };
209
210 static ACPI_EXDUMP_INFO AcpiExDumpString[4] =
211 {
212 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpString), NULL},
213 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (String.Length), "Length"},
214 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (String.Pointer), "Pointer"},
215 {ACPI_EXD_STRING, 0, NULL}
216 };
217
218 static ACPI_EXDUMP_INFO AcpiExDumpBuffer[5] =
219 {
220 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBuffer), NULL},
221 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Buffer.Length), "Length"},
222 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Buffer.Pointer), "Pointer"},
223 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Buffer.Node), "Parent Node"},
224 {ACPI_EXD_BUFFER, 0, NULL}
225 };
226
227 static ACPI_EXDUMP_INFO AcpiExDumpPackage[6] =
228 {
229 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPackage), NULL},
230 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Package.Node), "Parent Node"},
231 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Package.Flags), "Flags"},
232 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Package.Count), "Element Count"},
233 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Package.Elements), "Element List"},
234 {ACPI_EXD_PACKAGE, 0, NULL}
235 };
236
237 static ACPI_EXDUMP_INFO AcpiExDumpDevice[4] =
238 {
239 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpDevice), NULL},
240 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.NotifyList[0]), "System Notify"},
241 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.NotifyList[1]), "Device Notify"},
242 {ACPI_EXD_HDLR_LIST,ACPI_EXD_OFFSET (Device.Handler), "Handler"}
243 };
244
245 static ACPI_EXDUMP_INFO AcpiExDumpEvent[2] =
246 {
247 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpEvent), NULL},
248 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Event.OsSemaphore), "OsSemaphore"}
249 };
250
251 static ACPI_EXDUMP_INFO AcpiExDumpMethod[9] =
252 {
253 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpMethod), NULL},
254 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.InfoFlags), "Info Flags"},
255 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.ParamCount), "Parameter Count"},
256 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.SyncLevel), "Sync Level"},
257 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Method.Mutex), "Mutex"},
258 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET (Method.OwnerId), "Owner Id"},
259 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.ThreadCount), "Thread Count"},
260 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Method.AmlLength), "Aml Length"},
261 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Method.AmlStart), "Aml Start"}
262 };
263
264 static ACPI_EXDUMP_INFO AcpiExDumpMutex[6] =
265 {
266 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpMutex), NULL},
267 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Mutex.SyncLevel), "Sync Level"},
268 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Mutex.OriginalSyncLevel), "Original Sync Level"},
269 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Mutex.OwnerThread), "Owner Thread"},
270 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET (Mutex.AcquisitionDepth), "Acquire Depth"},
271 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Mutex.OsMutex), "OsMutex"}
272 };
273
274 static ACPI_EXDUMP_INFO AcpiExDumpRegion[8] =
275 {
276 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpRegion), NULL},
277 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Region.SpaceId), "Space Id"},
278 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Region.Flags), "Flags"},
279 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Region.Node), "Parent Node"},
280 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Region.Address), "Address"},
281 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Region.Length), "Length"},
282 {ACPI_EXD_HDLR_LIST,ACPI_EXD_OFFSET (Region.Handler), "Handler"},
283 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Region.Next), "Next"}
284 };
285
286 static ACPI_EXDUMP_INFO AcpiExDumpPower[6] =
287 {
288 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPower), NULL},
289 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.SystemLevel), "System Level"},
290 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.ResourceOrder), "Resource Order"},
291 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.NotifyList[0]), "System Notify"},
292 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.NotifyList[1]), "Device Notify"},
293 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.Handler), "Handler"}
294 };
295
296 static ACPI_EXDUMP_INFO AcpiExDumpProcessor[7] =
297 {
298 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpProcessor), NULL},
299 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Processor.ProcId), "Processor ID"},
300 {ACPI_EXD_UINT8 , ACPI_EXD_OFFSET (Processor.Length), "Length"},
301 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Processor.Address), "Address"},
302 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.NotifyList[0]), "System Notify"},
303 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.NotifyList[1]), "Device Notify"},
304 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.Handler), "Handler"}
305 };
306
307 static ACPI_EXDUMP_INFO AcpiExDumpThermal[4] =
308 {
309 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpThermal), NULL},
310 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.NotifyList[0]), "System Notify"},
311 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.NotifyList[1]), "Device Notify"},
312 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.Handler), "Handler"}
313 };
314
315 static ACPI_EXDUMP_INFO AcpiExDumpBufferField[3] =
316 {
317 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBufferField), NULL},
318 {ACPI_EXD_FIELD, 0, NULL},
319 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BufferField.BufferObj), "Buffer Object"}
320 };
321
322 static ACPI_EXDUMP_INFO AcpiExDumpRegionField[5] =
323 {
324 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpRegionField), NULL},
325 {ACPI_EXD_FIELD, 0, NULL},
326 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Field.AccessLength), "AccessLength"},
327 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Field.RegionObj), "Region Object"},
328 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Field.ResourceBuffer), "ResourceBuffer"}
329 };
330
331 static ACPI_EXDUMP_INFO AcpiExDumpBankField[5] =
332 {
333 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBankField), NULL},
334 {ACPI_EXD_FIELD, 0, NULL},
335 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (BankField.Value), "Value"},
336 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BankField.RegionObj), "Region Object"},
337 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BankField.BankObj), "Bank Object"}
338 };
339
340 static ACPI_EXDUMP_INFO AcpiExDumpIndexField[5] =
341 {
342 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBankField), NULL},
343 {ACPI_EXD_FIELD, 0, NULL},
344 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (IndexField.Value), "Value"},
345 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (IndexField.IndexObj), "Index Object"},
346 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (IndexField.DataObj), "Data Object"}
347 };
348
349 static ACPI_EXDUMP_INFO AcpiExDumpReference[9] =
350 {
351 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpReference), NULL},
352 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Reference.Class), "Class"},
353 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Reference.TargetType), "Target Type"},
354 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Reference.Value), "Value"},
355 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.Object), "Object Desc"},
356 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Reference.Node), "Node"},
357 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.Where), "Where"},
358 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.IndexPointer), "Index Pointer"},
359 {ACPI_EXD_REFERENCE,0, NULL}
360 };
361
362 static ACPI_EXDUMP_INFO AcpiExDumpAddressHandler[6] =
363 {
364 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpAddressHandler), NULL},
365 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (AddressSpace.SpaceId), "Space Id"},
366 {ACPI_EXD_HDLR_LIST,ACPI_EXD_OFFSET (AddressSpace.Next), "Next"},
367 {ACPI_EXD_RGN_LIST, ACPI_EXD_OFFSET (AddressSpace.RegionList), "Region List"},
368 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (AddressSpace.Node), "Node"},
369 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Context), "Context"}
370 };
371
372 static ACPI_EXDUMP_INFO AcpiExDumpNotify[7] =
373 {
374 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNotify), NULL},
375 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Notify.Node), "Node"},
376 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Notify.HandlerType), "Handler Type"},
377 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Handler), "Handler"},
378 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Context), "Context"},
379 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Next[0]), "Next System Notify"},
380 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Next[1]), "Next Device Notify"}
381 };
382
383 static ACPI_EXDUMP_INFO AcpiExDumpExtra[6] =
384 {
385 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpExtra), NULL},
386 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Extra.Method_REG), "_REG Method"},
387 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (Extra.ScopeNode), "Scope Node"},
388 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Extra.RegionContext), "Region Context"},
389 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Extra.AmlStart), "Aml Start"},
390 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Extra.AmlLength), "Aml Length"}
391 };
392
393 static ACPI_EXDUMP_INFO AcpiExDumpData[3] =
394 {
395 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpData), NULL},
396 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Data.Handler), "Handler"},
397 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Data.Pointer), "Raw Data"}
398 };
399
400 /* Miscellaneous tables */
401
402 static ACPI_EXDUMP_INFO AcpiExDumpCommon[5] =
403 {
404 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpCommon), NULL},
405 {ACPI_EXD_TYPE , 0, NULL},
406 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET (Common.ReferenceCount), "Reference Count"},
407 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Common.Flags), "Flags"},
408 {ACPI_EXD_LIST, ACPI_EXD_OFFSET (Common.NextObject), "Object List"}
409 };
410
411 static ACPI_EXDUMP_INFO AcpiExDumpFieldCommon[7] =
412 {
413 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpFieldCommon), NULL},
414 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.FieldFlags), "Field Flags"},
415 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.AccessByteWidth), "Access Byte Width"},
416 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (CommonField.BitLength), "Bit Length"},
417 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.StartFieldBitOffset),"Field Bit Offset"},
418 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (CommonField.BaseByteOffset), "Base Byte Offset"},
419 {ACPI_EXD_NODE, ACPI_EXD_OFFSET (CommonField.Node), "Parent Node"}
420 };
421
422 static ACPI_EXDUMP_INFO AcpiExDumpNode[7] =
423 {
424 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNode), NULL},
425 {ACPI_EXD_UINT16, ACPI_EXD_NSOFFSET (Flags), "Flags"},
426 {ACPI_EXD_UINT16, ACPI_EXD_NSOFFSET (OwnerId), "Owner Id"},
427 {ACPI_EXD_LIST, ACPI_EXD_NSOFFSET (Object), "Object List"},
428 {ACPI_EXD_NODE, ACPI_EXD_NSOFFSET (Parent), "Parent"},
429 {ACPI_EXD_NODE, ACPI_EXD_NSOFFSET (Child), "Child"},
430 {ACPI_EXD_NODE, ACPI_EXD_NSOFFSET (Peer), "Peer"}
431 };
432
433
434 /* Dispatch table, indexed by object type */
435
436 static ACPI_EXDUMP_INFO *AcpiExDumpInfo[] =
437 {
438 NULL,
439 AcpiExDumpInteger,
440 AcpiExDumpString,
441 AcpiExDumpBuffer,
442 AcpiExDumpPackage,
443 NULL,
444 AcpiExDumpDevice,
445 AcpiExDumpEvent,
446 AcpiExDumpMethod,
447 AcpiExDumpMutex,
448 AcpiExDumpRegion,
449 AcpiExDumpPower,
450 AcpiExDumpProcessor,
451 AcpiExDumpThermal,
452 AcpiExDumpBufferField,
453 NULL,
454 NULL,
455 AcpiExDumpRegionField,
456 AcpiExDumpBankField,
457 AcpiExDumpIndexField,
458 AcpiExDumpReference,
459 NULL,
460 NULL,
461 AcpiExDumpNotify,
462 AcpiExDumpAddressHandler,
463 NULL,
464 NULL,
465 NULL,
466 AcpiExDumpExtra,
467 AcpiExDumpData
468 };
469
470
471 /*******************************************************************************
472 *
473 * FUNCTION: AcpiExDumpObject
474 *
475 * PARAMETERS: ObjDesc - Descriptor to dump
476 * Info - Info table corresponding to this object
477 * type
478 *
479 * RETURN: None
480 *
481 * DESCRIPTION: Walk the info table for this object
482 *
483 ******************************************************************************/
484
485 static void
AcpiExDumpObject(ACPI_OPERAND_OBJECT * ObjDesc,ACPI_EXDUMP_INFO * Info)486 AcpiExDumpObject (
487 ACPI_OPERAND_OBJECT *ObjDesc,
488 ACPI_EXDUMP_INFO *Info)
489 {
490 UINT8 *Target;
491 const char *Name;
492 UINT8 Count;
493 ACPI_OPERAND_OBJECT *Start;
494 ACPI_OPERAND_OBJECT *Data = NULL;
495 ACPI_OPERAND_OBJECT *Next;
496 ACPI_NAMESPACE_NODE *Node;
497
498
499 if (!Info)
500 {
501 AcpiOsPrintf (
502 "ExDumpObject: Display not implemented for object type %s\n",
503 AcpiUtGetObjectTypeName (ObjDesc));
504 return;
505 }
506
507 /* First table entry must contain the table length (# of table entries) */
508
509 Count = Info->Offset;
510
511 while (Count)
512 {
513 if (!ObjDesc)
514 {
515 return;
516 }
517
518 Target = ACPI_ADD_PTR (UINT8, ObjDesc, Info->Offset);
519 Name = Info->Name;
520
521 switch (Info->Opcode)
522 {
523 case ACPI_EXD_INIT:
524
525 break;
526
527 case ACPI_EXD_TYPE:
528
529 AcpiOsPrintf ("%20s : %2.2X [%s]\n", "Type",
530 ObjDesc->Common.Type,
531 AcpiUtGetObjectTypeName (ObjDesc));
532 break;
533
534 case ACPI_EXD_UINT8:
535
536 AcpiOsPrintf ("%20s : %2.2X\n", Name, *Target);
537 break;
538
539 case ACPI_EXD_UINT16:
540
541 AcpiOsPrintf ("%20s : %4.4X\n", Name, ACPI_GET16 (Target));
542 break;
543
544 case ACPI_EXD_UINT32:
545
546 AcpiOsPrintf ("%20s : %8.8X\n", Name, ACPI_GET32 (Target));
547 break;
548
549 case ACPI_EXD_UINT64:
550
551 AcpiOsPrintf ("%20s : %8.8X%8.8X\n", "Value",
552 ACPI_FORMAT_UINT64 (ACPI_GET64 (Target)));
553 break;
554
555 case ACPI_EXD_POINTER:
556 case ACPI_EXD_ADDRESS:
557
558 AcpiExOutPointer (Name, *ACPI_CAST_PTR (void *, Target));
559 break;
560
561 case ACPI_EXD_STRING:
562
563 AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX);
564 AcpiOsPrintf ("\n");
565 break;
566
567 case ACPI_EXD_BUFFER:
568
569 ACPI_DUMP_BUFFER (
570 ObjDesc->Buffer.Pointer, ObjDesc->Buffer.Length);
571 break;
572
573 case ACPI_EXD_PACKAGE:
574
575 /* Dump the package contents */
576
577 AcpiOsPrintf ("\nPackage Contents:\n");
578 AcpiExDumpPackageObj (ObjDesc, 0, 0);
579 break;
580
581 case ACPI_EXD_FIELD:
582
583 AcpiExDumpObject (ObjDesc, AcpiExDumpFieldCommon);
584 break;
585
586 case ACPI_EXD_REFERENCE:
587
588 AcpiExOutString ("Class Name", AcpiUtGetReferenceName (ObjDesc));
589 AcpiExDumpReferenceObj (ObjDesc);
590 break;
591
592 case ACPI_EXD_LIST:
593
594 Start = *ACPI_CAST_PTR (void *, Target);
595 Next = Start;
596
597 AcpiOsPrintf ("%20s : %p ", Name, Next);
598 if (Next)
599 {
600 AcpiOsPrintf ("%s (Type %2.2X)",
601 AcpiUtGetObjectTypeName (Next), Next->Common.Type);
602
603 while (Next->Common.NextObject)
604 {
605 if ((Next->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
606 !Data)
607 {
608 Data = Next;
609 }
610
611 Next = Next->Common.NextObject;
612 AcpiOsPrintf ("->%p(%s %2.2X)", Next,
613 AcpiUtGetObjectTypeName (Next), Next->Common.Type);
614
615 if ((Next == Start) || (Next == Data))
616 {
617 AcpiOsPrintf (
618 "\n**** Error: Object list appears to be circular linked");
619 break;
620 }
621 }
622 }
623 else
624 {
625 AcpiOsPrintf ("- No attached objects");
626 }
627
628 AcpiOsPrintf ("\n");
629 break;
630
631 case ACPI_EXD_HDLR_LIST:
632
633 Start = *ACPI_CAST_PTR (void *, Target);
634 Next = Start;
635
636 AcpiOsPrintf ("%20s : %p", Name, Next);
637 if (Next)
638 {
639 AcpiOsPrintf ("(%s %2.2X)",
640 AcpiUtGetObjectTypeName (Next),
641 Next->AddressSpace.SpaceId);
642
643 while (Next->AddressSpace.Next)
644 {
645 if ((Next->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
646 !Data)
647 {
648 Data = Next;
649 }
650
651 Next = Next->AddressSpace.Next;
652 AcpiOsPrintf ("->%p(%s %2.2X)", Next,
653 AcpiUtGetObjectTypeName (Next),
654 Next->AddressSpace.SpaceId);
655
656 if ((Next == Start) || (Next == Data))
657 {
658 AcpiOsPrintf (
659 "\n**** Error: Handler list appears to be circular linked");
660 break;
661 }
662 }
663 }
664
665 AcpiOsPrintf ("\n");
666 break;
667
668 case ACPI_EXD_RGN_LIST:
669
670 Start = *ACPI_CAST_PTR (void *, Target);
671 Next = Start;
672
673 AcpiOsPrintf ("%20s : %p", Name, Next);
674 if (Next)
675 {
676 AcpiOsPrintf ("(%s %2.2X)",
677 AcpiUtGetObjectTypeName (Next), Next->Common.Type);
678
679 while (Next->Region.Next)
680 {
681 if ((Next->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
682 !Data)
683 {
684 Data = Next;
685 }
686
687 Next = Next->Region.Next;
688 AcpiOsPrintf ("->%p(%s %2.2X)", Next,
689 AcpiUtGetObjectTypeName (Next), Next->Common.Type);
690
691 if ((Next == Start) || (Next == Data))
692 {
693 AcpiOsPrintf (
694 "\n**** Error: Region list appears to be circular linked");
695 break;
696 }
697 }
698 }
699
700 AcpiOsPrintf ("\n");
701 break;
702
703 case ACPI_EXD_NODE:
704
705 Node = *ACPI_CAST_PTR (ACPI_NAMESPACE_NODE *, Target);
706
707 AcpiOsPrintf ("%20s : %p", Name, Node);
708 if (Node)
709 {
710 AcpiOsPrintf (" [%4.4s]", Node->Name.Ascii);
711 }
712 AcpiOsPrintf ("\n");
713 break;
714
715 default:
716
717 AcpiOsPrintf ("**** Invalid table opcode [%X] ****\n",
718 Info->Opcode);
719 return;
720 }
721
722 Info++;
723 Count--;
724 }
725 }
726
727
728 /*******************************************************************************
729 *
730 * FUNCTION: AcpiExDumpOperand
731 *
732 * PARAMETERS: *ObjDesc - Pointer to entry to be dumped
733 * Depth - Current nesting depth
734 *
735 * RETURN: None
736 *
737 * DESCRIPTION: Dump an operand object
738 *
739 ******************************************************************************/
740
741 void
AcpiExDumpOperand(ACPI_OPERAND_OBJECT * ObjDesc,UINT32 Depth)742 AcpiExDumpOperand (
743 ACPI_OPERAND_OBJECT *ObjDesc,
744 UINT32 Depth)
745 {
746 UINT32 Length;
747 UINT32 Index;
748
749
750 ACPI_FUNCTION_NAME (ExDumpOperand);
751
752
753 /* Check if debug output enabled */
754
755 if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_EXEC, _COMPONENT))
756 {
757 return;
758 }
759
760 if (!ObjDesc)
761 {
762 /* This could be a null element of a package */
763
764 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Null Object Descriptor\n"));
765 return;
766 }
767
768 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
769 {
770 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p Namespace Node: ", ObjDesc));
771 ACPI_DUMP_ENTRY (ObjDesc, ACPI_LV_EXEC);
772 return;
773 }
774
775 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND)
776 {
777 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
778 "%p is not a node or operand object: [%s]\n",
779 ObjDesc, AcpiUtGetDescriptorName (ObjDesc)));
780 ACPI_DUMP_BUFFER (ObjDesc, sizeof (ACPI_OPERAND_OBJECT));
781 return;
782 }
783
784 /* ObjDesc is a valid object */
785
786 if (Depth > 0)
787 {
788 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%*s[%u] %p Refs=%u ",
789 Depth, " ", Depth, ObjDesc, ObjDesc->Common.ReferenceCount));
790 }
791 else
792 {
793 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p Refs=%u ",
794 ObjDesc, ObjDesc->Common.ReferenceCount));
795 }
796
797 /* Decode object type */
798
799 switch (ObjDesc->Common.Type)
800 {
801 case ACPI_TYPE_LOCAL_REFERENCE:
802
803 AcpiOsPrintf ("Reference: [%s] ",
804 AcpiUtGetReferenceName (ObjDesc));
805
806 switch (ObjDesc->Reference.Class)
807 {
808 case ACPI_REFCLASS_DEBUG:
809
810 AcpiOsPrintf ("\n");
811 break;
812
813 case ACPI_REFCLASS_INDEX:
814
815 AcpiOsPrintf ("%p\n", ObjDesc->Reference.Object);
816 break;
817
818 case ACPI_REFCLASS_TABLE:
819
820 AcpiOsPrintf ("Table Index %X\n", ObjDesc->Reference.Value);
821 break;
822
823 case ACPI_REFCLASS_REFOF:
824
825 AcpiOsPrintf ("%p [%s]\n", ObjDesc->Reference.Object,
826 AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *)
827 ObjDesc->Reference.Object)->Common.Type));
828 break;
829
830 case ACPI_REFCLASS_NAME:
831
832 AcpiUtRepairName (ObjDesc->Reference.Node->Name.Ascii);
833 AcpiOsPrintf ("- [%4.4s] (Node %p)\n",
834 ObjDesc->Reference.Node->Name.Ascii,
835 ObjDesc->Reference.Node);
836 break;
837
838 case ACPI_REFCLASS_ARG:
839 case ACPI_REFCLASS_LOCAL:
840
841 AcpiOsPrintf ("%X\n", ObjDesc->Reference.Value);
842 break;
843
844 default: /* Unknown reference class */
845
846 AcpiOsPrintf ("%2.2X\n", ObjDesc->Reference.Class);
847 break;
848 }
849 break;
850
851 case ACPI_TYPE_BUFFER:
852
853 AcpiOsPrintf ("Buffer length %.2X @ %p\n",
854 ObjDesc->Buffer.Length, ObjDesc->Buffer.Pointer);
855
856 /* Debug only -- dump the buffer contents */
857
858 if (ObjDesc->Buffer.Pointer)
859 {
860 Length = ObjDesc->Buffer.Length;
861 if (Length > 128)
862 {
863 Length = 128;
864 }
865
866 AcpiOsPrintf (
867 "Buffer Contents: (displaying length 0x%.2X)\n", Length);
868 ACPI_DUMP_BUFFER (ObjDesc->Buffer.Pointer, Length);
869 }
870 break;
871
872 case ACPI_TYPE_INTEGER:
873
874 AcpiOsPrintf ("Integer %8.8X%8.8X\n",
875 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
876 break;
877
878 case ACPI_TYPE_PACKAGE:
879
880 AcpiOsPrintf ("Package [Len %X] ElementArray %p\n",
881 ObjDesc->Package.Count, ObjDesc->Package.Elements);
882
883 /*
884 * If elements exist, package element pointer is valid,
885 * and debug_level exceeds 1, dump package's elements.
886 */
887 if (ObjDesc->Package.Count &&
888 ObjDesc->Package.Elements &&
889 AcpiDbgLevel > 1)
890 {
891 for (Index = 0; Index < ObjDesc->Package.Count; Index++)
892 {
893 AcpiExDumpOperand (
894 ObjDesc->Package.Elements[Index], Depth + 1);
895 }
896 }
897 break;
898
899 case ACPI_TYPE_REGION:
900
901 AcpiOsPrintf ("Region %s (%X)",
902 AcpiUtGetRegionName (ObjDesc->Region.SpaceId),
903 ObjDesc->Region.SpaceId);
904
905 /*
906 * If the address and length have not been evaluated,
907 * don't print them.
908 */
909 if (!(ObjDesc->Region.Flags & AOPOBJ_DATA_VALID))
910 {
911 AcpiOsPrintf ("\n");
912 }
913 else
914 {
915 AcpiOsPrintf (" base %8.8X%8.8X Length %X\n",
916 ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),
917 ObjDesc->Region.Length);
918 }
919 break;
920
921 case ACPI_TYPE_STRING:
922
923 AcpiOsPrintf ("String length %X @ %p ",
924 ObjDesc->String.Length,
925 ObjDesc->String.Pointer);
926
927 AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX);
928 AcpiOsPrintf ("\n");
929 break;
930
931 case ACPI_TYPE_LOCAL_BANK_FIELD:
932
933 AcpiOsPrintf ("BankField\n");
934 break;
935
936 case ACPI_TYPE_LOCAL_REGION_FIELD:
937
938 AcpiOsPrintf ("RegionField: Bits=%X AccWidth=%X Lock=%X Update=%X at "
939 "byte=%X bit=%X of below:\n",
940 ObjDesc->Field.BitLength,
941 ObjDesc->Field.AccessByteWidth,
942 ObjDesc->Field.FieldFlags & AML_FIELD_LOCK_RULE_MASK,
943 ObjDesc->Field.FieldFlags & AML_FIELD_UPDATE_RULE_MASK,
944 ObjDesc->Field.BaseByteOffset,
945 ObjDesc->Field.StartFieldBitOffset);
946
947 AcpiExDumpOperand (ObjDesc->Field.RegionObj, Depth + 1);
948 break;
949
950 case ACPI_TYPE_LOCAL_INDEX_FIELD:
951
952 AcpiOsPrintf ("IndexField\n");
953 break;
954
955 case ACPI_TYPE_BUFFER_FIELD:
956
957 AcpiOsPrintf ("BufferField: %X bits at byte %X bit %X of\n",
958 ObjDesc->BufferField.BitLength,
959 ObjDesc->BufferField.BaseByteOffset,
960 ObjDesc->BufferField.StartFieldBitOffset);
961
962 if (!ObjDesc->BufferField.BufferObj)
963 {
964 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "*NULL*\n"));
965 }
966 else if ((ObjDesc->BufferField.BufferObj)->Common.Type !=
967 ACPI_TYPE_BUFFER)
968 {
969 AcpiOsPrintf ("*not a Buffer*\n");
970 }
971 else
972 {
973 AcpiExDumpOperand (ObjDesc->BufferField.BufferObj, Depth + 1);
974 }
975 break;
976
977 case ACPI_TYPE_EVENT:
978
979 AcpiOsPrintf ("Event\n");
980 break;
981
982 case ACPI_TYPE_METHOD:
983
984 AcpiOsPrintf ("Method(%X) @ %p:%X\n",
985 ObjDesc->Method.ParamCount,
986 ObjDesc->Method.AmlStart,
987 ObjDesc->Method.AmlLength);
988 break;
989
990 case ACPI_TYPE_MUTEX:
991
992 AcpiOsPrintf ("Mutex\n");
993 break;
994
995 case ACPI_TYPE_DEVICE:
996
997 AcpiOsPrintf ("Device\n");
998 break;
999
1000 case ACPI_TYPE_POWER:
1001
1002 AcpiOsPrintf ("Power\n");
1003 break;
1004
1005 case ACPI_TYPE_PROCESSOR:
1006
1007 AcpiOsPrintf ("Processor\n");
1008 break;
1009
1010 case ACPI_TYPE_THERMAL:
1011
1012 AcpiOsPrintf ("Thermal\n");
1013 break;
1014
1015 default:
1016
1017 /* Unknown Type */
1018
1019 AcpiOsPrintf ("Unknown Type %X\n", ObjDesc->Common.Type);
1020 break;
1021 }
1022
1023 return;
1024 }
1025
1026
1027 /*******************************************************************************
1028 *
1029 * FUNCTION: AcpiExDumpOperands
1030 *
1031 * PARAMETERS: Operands - A list of Operand objects
1032 * OpcodeName - AML opcode name
1033 * NumOperands - Operand count for this opcode
1034 *
1035 * DESCRIPTION: Dump the operands associated with the opcode
1036 *
1037 ******************************************************************************/
1038
1039 void
AcpiExDumpOperands(ACPI_OPERAND_OBJECT ** Operands,const char * OpcodeName,UINT32 NumOperands)1040 AcpiExDumpOperands (
1041 ACPI_OPERAND_OBJECT **Operands,
1042 const char *OpcodeName,
1043 UINT32 NumOperands)
1044 {
1045 ACPI_FUNCTION_TRACE (ExDumpOperands);
1046
1047
1048 if (!OpcodeName)
1049 {
1050 OpcodeName = "UNKNOWN";
1051 }
1052
1053 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
1054 "**** Start operand dump for opcode [%s], %u operands\n",
1055 OpcodeName, NumOperands));
1056
1057 if (NumOperands == 0)
1058 {
1059 NumOperands = 1;
1060 }
1061
1062 /* Dump the individual operands */
1063
1064 while (NumOperands)
1065 {
1066 AcpiExDumpOperand (*Operands, 0);
1067 Operands++;
1068 NumOperands--;
1069 }
1070
1071 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
1072 "**** End operand dump for [%s]\n", OpcodeName));
1073 return_VOID;
1074 }
1075
1076
1077 /*******************************************************************************
1078 *
1079 * FUNCTION: AcpiExOut* functions
1080 *
1081 * PARAMETERS: Title - Descriptive text
1082 * Value - Value to be displayed
1083 *
1084 * DESCRIPTION: Object dump output formatting functions. These functions
1085 * reduce the number of format strings required and keeps them
1086 * all in one place for easy modification.
1087 *
1088 ******************************************************************************/
1089
1090 static void
AcpiExOutString(const char * Title,const char * Value)1091 AcpiExOutString (
1092 const char *Title,
1093 const char *Value)
1094 {
1095 AcpiOsPrintf ("%20s : %s\n", Title, Value);
1096 }
1097
1098 static void
AcpiExOutPointer(const char * Title,const void * Value)1099 AcpiExOutPointer (
1100 const char *Title,
1101 const void *Value)
1102 {
1103 AcpiOsPrintf ("%20s : %p\n", Title, Value);
1104 }
1105
1106
1107 /*******************************************************************************
1108 *
1109 * FUNCTION: AcpiExDumpNamespaceNode
1110 *
1111 * PARAMETERS: Node - Descriptor to dump
1112 * Flags - Force display if TRUE
1113 *
1114 * DESCRIPTION: Dumps the members of the given.Node
1115 *
1116 ******************************************************************************/
1117
1118 void
AcpiExDumpNamespaceNode(ACPI_NAMESPACE_NODE * Node,UINT32 Flags)1119 AcpiExDumpNamespaceNode (
1120 ACPI_NAMESPACE_NODE *Node,
1121 UINT32 Flags)
1122 {
1123
1124 ACPI_FUNCTION_ENTRY ();
1125
1126
1127 if (!Flags)
1128 {
1129 /* Check if debug output enabled */
1130
1131 if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_OBJECTS, _COMPONENT))
1132 {
1133 return;
1134 }
1135 }
1136
1137 AcpiOsPrintf ("%20s : %4.4s\n", "Name", AcpiUtGetNodeName (Node));
1138 AcpiOsPrintf ("%20s : %2.2X [%s]\n", "Type",
1139 Node->Type, AcpiUtGetTypeName (Node->Type));
1140
1141 AcpiExDumpObject (ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Node),
1142 AcpiExDumpNode);
1143 }
1144
1145
1146 /*******************************************************************************
1147 *
1148 * FUNCTION: AcpiExDumpReferenceObj
1149 *
1150 * PARAMETERS: Object - Descriptor to dump
1151 *
1152 * DESCRIPTION: Dumps a reference object
1153 *
1154 ******************************************************************************/
1155
1156 static void
AcpiExDumpReferenceObj(ACPI_OPERAND_OBJECT * ObjDesc)1157 AcpiExDumpReferenceObj (
1158 ACPI_OPERAND_OBJECT *ObjDesc)
1159 {
1160 ACPI_BUFFER RetBuf;
1161 ACPI_STATUS Status;
1162
1163
1164 RetBuf.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
1165
1166 if (ObjDesc->Reference.Class == ACPI_REFCLASS_NAME)
1167 {
1168 AcpiOsPrintf (" %p ", ObjDesc->Reference.Node);
1169
1170 Status = AcpiNsHandleToPathname (ObjDesc->Reference.Node,
1171 &RetBuf, TRUE);
1172 if (ACPI_FAILURE (Status))
1173 {
1174 AcpiOsPrintf (" Could not convert name to pathname: %s\n",
1175 AcpiFormatException (Status));
1176 }
1177 else
1178 {
1179 AcpiOsPrintf ("%s: %s\n",
1180 AcpiUtGetTypeName (ObjDesc->Reference.Node->Type),
1181 (char *) RetBuf.Pointer);
1182 ACPI_FREE (RetBuf.Pointer);
1183 }
1184 }
1185 else if (ObjDesc->Reference.Object)
1186 {
1187 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND)
1188 {
1189 AcpiOsPrintf ("%22s %p", "Target :",
1190 ObjDesc->Reference.Object);
1191 if (ObjDesc->Reference.Class == ACPI_REFCLASS_TABLE)
1192 {
1193 AcpiOsPrintf (" Table Index: %X\n",
1194 ObjDesc->Reference.Value);
1195 }
1196 else
1197 {
1198 AcpiOsPrintf (" [%s]\n",
1199 AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *)
1200 ObjDesc->Reference.Object)->Common.Type));
1201 }
1202 }
1203 else
1204 {
1205 AcpiOsPrintf (" Target: %p\n", ObjDesc->Reference.Object);
1206 }
1207 }
1208 }
1209
1210
1211 /*******************************************************************************
1212 *
1213 * FUNCTION: AcpiExDumpPackageObj
1214 *
1215 * PARAMETERS: ObjDesc - Descriptor to dump
1216 * Level - Indentation Level
1217 * Index - Package index for this object
1218 *
1219 * DESCRIPTION: Dumps the elements of the package
1220 *
1221 ******************************************************************************/
1222
1223 static void
AcpiExDumpPackageObj(ACPI_OPERAND_OBJECT * ObjDesc,UINT32 Level,UINT32 Index)1224 AcpiExDumpPackageObj (
1225 ACPI_OPERAND_OBJECT *ObjDesc,
1226 UINT32 Level,
1227 UINT32 Index)
1228 {
1229 UINT32 i;
1230
1231
1232 /* Indentation and index output */
1233
1234 if (Level > 0)
1235 {
1236 for (i = 0; i < Level; i++)
1237 {
1238 AcpiOsPrintf (" ");
1239 }
1240
1241 AcpiOsPrintf ("[%.2d] ", Index);
1242 }
1243
1244 AcpiOsPrintf ("%p ", ObjDesc);
1245
1246 /* Null package elements are allowed */
1247
1248 if (!ObjDesc)
1249 {
1250 AcpiOsPrintf ("[Null Object]\n");
1251 return;
1252 }
1253
1254 /* Packages may only contain a few object types */
1255
1256 switch (ObjDesc->Common.Type)
1257 {
1258 case ACPI_TYPE_INTEGER:
1259
1260 AcpiOsPrintf ("[Integer] = %8.8X%8.8X\n",
1261 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
1262 break;
1263
1264 case ACPI_TYPE_STRING:
1265
1266 AcpiOsPrintf ("[String] Value: ");
1267 AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX);
1268 AcpiOsPrintf ("\n");
1269 break;
1270
1271 case ACPI_TYPE_BUFFER:
1272
1273 AcpiOsPrintf ("[Buffer] Length %.2X = ", ObjDesc->Buffer.Length);
1274 if (ObjDesc->Buffer.Length)
1275 {
1276 AcpiUtDebugDumpBuffer (
1277 ACPI_CAST_PTR (UINT8, ObjDesc->Buffer.Pointer),
1278 ObjDesc->Buffer.Length, DB_DWORD_DISPLAY, _COMPONENT);
1279 }
1280 else
1281 {
1282 AcpiOsPrintf ("\n");
1283 }
1284 break;
1285
1286 case ACPI_TYPE_PACKAGE:
1287
1288 AcpiOsPrintf ("[Package] Contains %u Elements:\n",
1289 ObjDesc->Package.Count);
1290
1291 for (i = 0; i < ObjDesc->Package.Count; i++)
1292 {
1293 AcpiExDumpPackageObj (
1294 ObjDesc->Package.Elements[i], Level + 1, i);
1295 }
1296 break;
1297
1298 case ACPI_TYPE_LOCAL_REFERENCE:
1299
1300 AcpiOsPrintf ("[Object Reference] Class [%s]",
1301 AcpiUtGetReferenceName (ObjDesc));
1302 AcpiExDumpReferenceObj (ObjDesc);
1303 break;
1304
1305 default:
1306
1307 AcpiOsPrintf ("[%s] Type: %2.2X\n",
1308 AcpiUtGetTypeName (ObjDesc->Common.Type), ObjDesc->Common.Type);
1309 break;
1310 }
1311 }
1312
1313
1314 /*******************************************************************************
1315 *
1316 * FUNCTION: AcpiExDumpObjectDescriptor
1317 *
1318 * PARAMETERS: ObjDesc - Descriptor to dump
1319 * Flags - Force display if TRUE
1320 *
1321 * DESCRIPTION: Dumps the members of the object descriptor given.
1322 *
1323 ******************************************************************************/
1324
1325 void
AcpiExDumpObjectDescriptor(ACPI_OPERAND_OBJECT * ObjDesc,UINT32 Flags)1326 AcpiExDumpObjectDescriptor (
1327 ACPI_OPERAND_OBJECT *ObjDesc,
1328 UINT32 Flags)
1329 {
1330 ACPI_FUNCTION_TRACE (ExDumpObjectDescriptor);
1331
1332
1333 if (!ObjDesc)
1334 {
1335 return_VOID;
1336 }
1337
1338 if (!Flags)
1339 {
1340 /* Check if debug output enabled */
1341
1342 if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_OBJECTS, _COMPONENT))
1343 {
1344 return_VOID;
1345 }
1346 }
1347
1348 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
1349 {
1350 AcpiExDumpNamespaceNode ((ACPI_NAMESPACE_NODE *) ObjDesc, Flags);
1351
1352 ObjDesc = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Object;
1353 if (!ObjDesc)
1354 {
1355 return_VOID;
1356 }
1357
1358 AcpiOsPrintf ("\nAttached Object %p", ObjDesc);
1359 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
1360 {
1361 AcpiOsPrintf (" - Namespace Node");
1362 }
1363
1364 AcpiOsPrintf (":\n");
1365 goto DumpObject;
1366 }
1367
1368 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND)
1369 {
1370 AcpiOsPrintf (
1371 "%p is not an ACPI operand object: [%s]\n",
1372 ObjDesc, AcpiUtGetDescriptorName (ObjDesc));
1373 return_VOID;
1374 }
1375
1376 /* Validate the object type */
1377
1378 if (ObjDesc->Common.Type > ACPI_TYPE_LOCAL_MAX)
1379 {
1380 AcpiOsPrintf ("Not a known object type: %2.2X\n",
1381 ObjDesc->Common.Type);
1382 return_VOID;
1383 }
1384
1385
1386 DumpObject:
1387
1388 if (!ObjDesc)
1389 {
1390 return_VOID;
1391 }
1392
1393 /* Common Fields */
1394
1395 AcpiExDumpObject (ObjDesc, AcpiExDumpCommon);
1396
1397 /* Object-specific fields */
1398
1399 AcpiExDumpObject (ObjDesc, AcpiExDumpInfo[ObjDesc->Common.Type]);
1400
1401 if (ObjDesc->Common.Type == ACPI_TYPE_REGION)
1402 {
1403 ObjDesc = ObjDesc->Common.NextObject;
1404 if (ObjDesc->Common.Type > ACPI_TYPE_LOCAL_MAX)
1405 {
1406 AcpiOsPrintf (
1407 "Secondary object is not a known object type: %2.2X\n",
1408 ObjDesc->Common.Type);
1409
1410 return_VOID;
1411 }
1412
1413 AcpiOsPrintf ("\nExtra attached Object (%p):\n", ObjDesc);
1414 AcpiExDumpObject (ObjDesc, AcpiExDumpInfo[ObjDesc->Common.Type]);
1415 }
1416
1417 return_VOID;
1418 }
1419
1420 #endif
1421
