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 - 2009, 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 #define __EXDUMP_C__ 117 118 #include "acpi.h" 119 #include "accommon.h" 120 #include "acinterp.h" 121 #include "amlcode.h" 122 #include "acnamesp.h" 123 124 125 #define _COMPONENT ACPI_EXECUTER 126 ACPI_MODULE_NAME ("exdump") 127 128 /* 129 * The following routines are used for debug output only 130 */ 131 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 132 133 /* Local prototypes */ 134 135 static void 136 AcpiExOutString ( 137 char *Title, 138 char *Value); 139 140 static void 141 AcpiExOutPointer ( 142 char *Title, 143 void *Value); 144 145 static void 146 AcpiExDumpObject ( 147 ACPI_OPERAND_OBJECT *ObjDesc, 148 ACPI_EXDUMP_INFO *Info); 149 150 static void 151 AcpiExDumpReferenceObj ( 152 ACPI_OPERAND_OBJECT *ObjDesc); 153 154 static void 155 AcpiExDumpPackageObj ( 156 ACPI_OPERAND_OBJECT *ObjDesc, 157 UINT32 Level, 158 UINT32 Index); 159 160 161 /******************************************************************************* 162 * 163 * Object Descriptor info tables 164 * 165 * Note: The first table entry must be an INIT opcode and must contain 166 * the table length (number of table entries) 167 * 168 ******************************************************************************/ 169 170 static ACPI_EXDUMP_INFO AcpiExDumpInteger[2] = 171 { 172 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpInteger), NULL}, 173 {ACPI_EXD_UINT64, ACPI_EXD_OFFSET (Integer.Value), "Value"} 174 }; 175 176 static ACPI_EXDUMP_INFO AcpiExDumpString[4] = 177 { 178 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpString), NULL}, 179 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (String.Length), "Length"}, 180 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (String.Pointer), "Pointer"}, 181 {ACPI_EXD_STRING, 0, NULL} 182 }; 183 184 static ACPI_EXDUMP_INFO AcpiExDumpBuffer[5] = 185 { 186 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBuffer), NULL}, 187 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Buffer.Length), "Length"}, 188 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Buffer.Pointer), "Pointer"}, 189 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Buffer.Node), "Parent Node"}, 190 {ACPI_EXD_BUFFER, 0, NULL} 191 }; 192 193 static ACPI_EXDUMP_INFO AcpiExDumpPackage[5] = 194 { 195 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPackage), NULL}, 196 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Package.Flags), "Flags"}, 197 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Package.Count), "Elements"}, 198 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Package.Elements), "Element List"}, 199 {ACPI_EXD_PACKAGE, 0, NULL} 200 }; 201 202 static ACPI_EXDUMP_INFO AcpiExDumpDevice[4] = 203 { 204 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpDevice), NULL}, 205 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.Handler), "Handler"}, 206 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.SystemNotify), "System Notify"}, 207 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.DeviceNotify), "Device Notify"} 208 }; 209 210 static ACPI_EXDUMP_INFO AcpiExDumpEvent[2] = 211 { 212 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpEvent), NULL}, 213 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Event.OsSemaphore), "OsSemaphore"} 214 }; 215 216 static ACPI_EXDUMP_INFO AcpiExDumpMethod[9] = 217 { 218 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpMethod), NULL}, 219 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.MethodFlags), "Method Flags"}, 220 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.ParamCount), "Parameter Count"}, 221 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.SyncLevel), "Sync Level"}, 222 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Method.Mutex), "Mutex"}, 223 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.OwnerId), "Owner Id"}, 224 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Method.ThreadCount), "Thread Count"}, 225 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Method.AmlLength), "Aml Length"}, 226 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Method.AmlStart), "Aml Start"} 227 }; 228 229 static ACPI_EXDUMP_INFO AcpiExDumpMutex[5] = 230 { 231 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpMutex), NULL}, 232 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Mutex.SyncLevel), "Sync Level"}, 233 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Mutex.OwnerThread), "Owner Thread"}, 234 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET (Mutex.AcquisitionDepth), "Acquire Depth"}, 235 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Mutex.OsMutex), "OsMutex"} 236 }; 237 238 static ACPI_EXDUMP_INFO AcpiExDumpRegion[7] = 239 { 240 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpRegion), NULL}, 241 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Region.SpaceId), "Space Id"}, 242 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Region.Flags), "Flags"}, 243 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Region.Address), "Address"}, 244 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Region.Length), "Length"}, 245 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Region.Handler), "Handler"}, 246 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Region.Next), "Next"} 247 }; 248 249 static ACPI_EXDUMP_INFO AcpiExDumpPower[5] = 250 { 251 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPower), NULL}, 252 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.SystemLevel), "System Level"}, 253 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.ResourceOrder), "Resource Order"}, 254 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.SystemNotify), "System Notify"}, 255 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.DeviceNotify), "Device Notify"} 256 }; 257 258 static ACPI_EXDUMP_INFO AcpiExDumpProcessor[7] = 259 { 260 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpProcessor), NULL}, 261 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Processor.ProcId), "Processor ID"}, 262 {ACPI_EXD_UINT8 , ACPI_EXD_OFFSET (Processor.Length), "Length"}, 263 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Processor.Address), "Address"}, 264 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.SystemNotify), "System Notify"}, 265 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.DeviceNotify), "Device Notify"}, 266 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.Handler), "Handler"} 267 }; 268 269 static ACPI_EXDUMP_INFO AcpiExDumpThermal[4] = 270 { 271 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpThermal), NULL}, 272 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.SystemNotify), "System Notify"}, 273 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.DeviceNotify), "Device Notify"}, 274 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.Handler), "Handler"} 275 }; 276 277 static ACPI_EXDUMP_INFO AcpiExDumpBufferField[3] = 278 { 279 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBufferField), NULL}, 280 {ACPI_EXD_FIELD, 0, NULL}, 281 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BufferField.BufferObj), "Buffer Object"} 282 }; 283 284 static ACPI_EXDUMP_INFO AcpiExDumpRegionField[3] = 285 { 286 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpRegionField), NULL}, 287 {ACPI_EXD_FIELD, 0, NULL}, 288 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Field.RegionObj), "Region Object"} 289 }; 290 291 static ACPI_EXDUMP_INFO AcpiExDumpBankField[5] = 292 { 293 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBankField), NULL}, 294 {ACPI_EXD_FIELD, 0, NULL}, 295 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (BankField.Value), "Value"}, 296 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BankField.RegionObj), "Region Object"}, 297 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (BankField.BankObj), "Bank Object"} 298 }; 299 300 static ACPI_EXDUMP_INFO AcpiExDumpIndexField[5] = 301 { 302 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpBankField), NULL}, 303 {ACPI_EXD_FIELD, 0, NULL}, 304 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (IndexField.Value), "Value"}, 305 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (IndexField.IndexObj), "Index Object"}, 306 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (IndexField.DataObj), "Data Object"} 307 }; 308 309 static ACPI_EXDUMP_INFO AcpiExDumpReference[8] = 310 { 311 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpReference), NULL}, 312 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Reference.Class), "Class"}, 313 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Reference.TargetType), "Target Type"}, 314 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Reference.Value), "Value"}, 315 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.Object), "Object Desc"}, 316 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.Node), "Node"}, 317 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Reference.Where), "Where"}, 318 {ACPI_EXD_REFERENCE,0, NULL} 319 }; 320 321 static ACPI_EXDUMP_INFO AcpiExDumpAddressHandler[6] = 322 { 323 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpAddressHandler), NULL}, 324 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (AddressSpace.SpaceId), "Space Id"}, 325 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Next), "Next"}, 326 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.RegionList), "Region List"}, 327 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Node), "Node"}, 328 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Context), "Context"} 329 }; 330 331 static ACPI_EXDUMP_INFO AcpiExDumpNotify[3] = 332 { 333 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNotify), NULL}, 334 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Node), "Node"}, 335 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Context), "Context"} 336 }; 337 338 339 /* Miscellaneous tables */ 340 341 static ACPI_EXDUMP_INFO AcpiExDumpCommon[4] = 342 { 343 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpCommon), NULL}, 344 {ACPI_EXD_TYPE , 0, NULL}, 345 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET (Common.ReferenceCount), "Reference Count"}, 346 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Common.Flags), "Flags"} 347 }; 348 349 static ACPI_EXDUMP_INFO AcpiExDumpFieldCommon[7] = 350 { 351 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpFieldCommon), NULL}, 352 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.FieldFlags), "Field Flags"}, 353 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.AccessByteWidth), "Access Byte Width"}, 354 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (CommonField.BitLength), "Bit Length"}, 355 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (CommonField.StartFieldBitOffset),"Field Bit Offset"}, 356 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (CommonField.BaseByteOffset), "Base Byte Offset"}, 357 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (CommonField.Node), "Parent Node"} 358 }; 359 360 static ACPI_EXDUMP_INFO AcpiExDumpNode[5] = 361 { 362 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNode), NULL}, 363 {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET (Flags), "Flags"}, 364 {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET (OwnerId), "Owner Id"}, 365 {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET (Child), "Child List"}, 366 {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET (Peer), "Next Peer"} 367 }; 368 369 370 /* Dispatch table, indexed by object type */ 371 372 static ACPI_EXDUMP_INFO *AcpiExDumpInfo[] = 373 { 374 NULL, 375 AcpiExDumpInteger, 376 AcpiExDumpString, 377 AcpiExDumpBuffer, 378 AcpiExDumpPackage, 379 NULL, 380 AcpiExDumpDevice, 381 AcpiExDumpEvent, 382 AcpiExDumpMethod, 383 AcpiExDumpMutex, 384 AcpiExDumpRegion, 385 AcpiExDumpPower, 386 AcpiExDumpProcessor, 387 AcpiExDumpThermal, 388 AcpiExDumpBufferField, 389 NULL, 390 NULL, 391 AcpiExDumpRegionField, 392 AcpiExDumpBankField, 393 AcpiExDumpIndexField, 394 AcpiExDumpReference, 395 NULL, 396 NULL, 397 AcpiExDumpNotify, 398 AcpiExDumpAddressHandler, 399 NULL, 400 NULL, 401 NULL 402 }; 403 404 405 /******************************************************************************* 406 * 407 * FUNCTION: AcpiExDumpObject 408 * 409 * PARAMETERS: ObjDesc - Descriptor to dump 410 * Info - Info table corresponding to this object 411 * type 412 * 413 * RETURN: None 414 * 415 * DESCRIPTION: Walk the info table for this object 416 * 417 ******************************************************************************/ 418 419 static void 420 AcpiExDumpObject ( 421 ACPI_OPERAND_OBJECT *ObjDesc, 422 ACPI_EXDUMP_INFO *Info) 423 { 424 UINT8 *Target; 425 char *Name; 426 UINT8 Count; 427 428 429 if (!Info) 430 { 431 AcpiOsPrintf ( 432 "ExDumpObject: Display not implemented for object type %s\n", 433 AcpiUtGetObjectTypeName (ObjDesc)); 434 return; 435 } 436 437 /* First table entry must contain the table length (# of table entries) */ 438 439 Count = Info->Offset; 440 441 while (Count) 442 { 443 Target = ACPI_ADD_PTR (UINT8, ObjDesc, Info->Offset); 444 Name = Info->Name; 445 446 switch (Info->Opcode) 447 { 448 case ACPI_EXD_INIT: 449 break; 450 451 case ACPI_EXD_TYPE: 452 453 AcpiExOutString ("Type", AcpiUtGetObjectTypeName (ObjDesc)); 454 break; 455 456 case ACPI_EXD_UINT8: 457 458 AcpiOsPrintf ("%20s : %2.2X\n", Name, *Target); 459 break; 460 461 case ACPI_EXD_UINT16: 462 463 AcpiOsPrintf ("%20s : %4.4X\n", Name, ACPI_GET16 (Target)); 464 break; 465 466 case ACPI_EXD_UINT32: 467 468 AcpiOsPrintf ("%20s : %8.8X\n", Name, ACPI_GET32 (Target)); 469 break; 470 471 case ACPI_EXD_UINT64: 472 473 AcpiOsPrintf ("%20s : %8.8X%8.8X\n", "Value", 474 ACPI_FORMAT_UINT64 (ACPI_GET64 (Target))); 475 break; 476 477 case ACPI_EXD_POINTER: 478 case ACPI_EXD_ADDRESS: 479 480 AcpiExOutPointer (Name, *ACPI_CAST_PTR (void *, Target)); 481 break; 482 483 case ACPI_EXD_STRING: 484 485 AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX); 486 AcpiOsPrintf ("\n"); 487 break; 488 489 case ACPI_EXD_BUFFER: 490 491 ACPI_DUMP_BUFFER (ObjDesc->Buffer.Pointer, ObjDesc->Buffer.Length); 492 break; 493 494 case ACPI_EXD_PACKAGE: 495 496 /* Dump the package contents */ 497 498 AcpiOsPrintf ("\nPackage Contents:\n"); 499 AcpiExDumpPackageObj (ObjDesc, 0, 0); 500 break; 501 502 case ACPI_EXD_FIELD: 503 504 AcpiExDumpObject (ObjDesc, AcpiExDumpFieldCommon); 505 break; 506 507 case ACPI_EXD_REFERENCE: 508 509 AcpiExOutString ("Class Name", 510 (char *) AcpiUtGetReferenceName (ObjDesc)); 511 AcpiExDumpReferenceObj (ObjDesc); 512 break; 513 514 default: 515 516 AcpiOsPrintf ("**** Invalid table opcode [%X] ****\n", 517 Info->Opcode); 518 return; 519 } 520 521 Info++; 522 Count--; 523 } 524 } 525 526 527 /******************************************************************************* 528 * 529 * FUNCTION: AcpiExDumpOperand 530 * 531 * PARAMETERS: *ObjDesc - Pointer to entry to be dumped 532 * Depth - Current nesting depth 533 * 534 * RETURN: None 535 * 536 * DESCRIPTION: Dump an operand object 537 * 538 ******************************************************************************/ 539 540 void 541 AcpiExDumpOperand ( 542 ACPI_OPERAND_OBJECT *ObjDesc, 543 UINT32 Depth) 544 { 545 UINT32 Length; 546 UINT32 Index; 547 548 549 ACPI_FUNCTION_NAME (ExDumpOperand) 550 551 552 if (!((ACPI_LV_EXEC & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) 553 { 554 return; 555 } 556 557 if (!ObjDesc) 558 { 559 /* This could be a null element of a package */ 560 561 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Null Object Descriptor\n")); 562 return; 563 } 564 565 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) 566 { 567 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p Namespace Node: ", ObjDesc)); 568 ACPI_DUMP_ENTRY (ObjDesc, ACPI_LV_EXEC); 569 return; 570 } 571 572 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) 573 { 574 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 575 "%p is not a node or operand object: [%s]\n", 576 ObjDesc, AcpiUtGetDescriptorName (ObjDesc))); 577 ACPI_DUMP_BUFFER (ObjDesc, sizeof (ACPI_OPERAND_OBJECT)); 578 return; 579 } 580 581 /* ObjDesc is a valid object */ 582 583 if (Depth > 0) 584 { 585 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%*s[%u] %p ", 586 Depth, " ", Depth, ObjDesc)); 587 } 588 else 589 { 590 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p ", ObjDesc)); 591 } 592 593 /* Decode object type */ 594 595 switch (ObjDesc->Common.Type) 596 { 597 case ACPI_TYPE_LOCAL_REFERENCE: 598 599 AcpiOsPrintf ("Reference: [%s] ", AcpiUtGetReferenceName (ObjDesc)); 600 601 switch (ObjDesc->Reference.Class) 602 { 603 case ACPI_REFCLASS_DEBUG: 604 605 AcpiOsPrintf ("\n"); 606 break; 607 608 609 case ACPI_REFCLASS_INDEX: 610 611 AcpiOsPrintf ("%p\n", ObjDesc->Reference.Object); 612 break; 613 614 615 case ACPI_REFCLASS_TABLE: 616 617 AcpiOsPrintf ("Table Index %X\n", ObjDesc->Reference.Value); 618 break; 619 620 621 case ACPI_REFCLASS_REFOF: 622 623 AcpiOsPrintf ("%p [%s]\n", ObjDesc->Reference.Object, 624 AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) 625 ObjDesc->Reference.Object)->Common.Type)); 626 break; 627 628 629 case ACPI_REFCLASS_NAME: 630 631 AcpiOsPrintf ("- [%4.4s]\n", ObjDesc->Reference.Node->Name.Ascii); 632 break; 633 634 635 case ACPI_REFCLASS_ARG: 636 case ACPI_REFCLASS_LOCAL: 637 638 AcpiOsPrintf ("%X\n", ObjDesc->Reference.Value); 639 break; 640 641 642 default: /* Unknown reference class */ 643 644 AcpiOsPrintf ("%2.2X\n", ObjDesc->Reference.Class); 645 break; 646 } 647 break; 648 649 650 case ACPI_TYPE_BUFFER: 651 652 AcpiOsPrintf ("Buffer length %.2X @ %p\n", 653 ObjDesc->Buffer.Length, ObjDesc->Buffer.Pointer); 654 655 /* Debug only -- dump the buffer contents */ 656 657 if (ObjDesc->Buffer.Pointer) 658 { 659 Length = ObjDesc->Buffer.Length; 660 if (Length > 128) 661 { 662 Length = 128; 663 } 664 665 AcpiOsPrintf ("Buffer Contents: (displaying length 0x%.2X)\n", 666 Length); 667 ACPI_DUMP_BUFFER (ObjDesc->Buffer.Pointer, Length); 668 } 669 break; 670 671 672 case ACPI_TYPE_INTEGER: 673 674 AcpiOsPrintf ("Integer %8.8X%8.8X\n", 675 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 676 break; 677 678 679 case ACPI_TYPE_PACKAGE: 680 681 AcpiOsPrintf ("Package [Len %X] ElementArray %p\n", 682 ObjDesc->Package.Count, ObjDesc->Package.Elements); 683 684 /* 685 * If elements exist, package element pointer is valid, 686 * and debug_level exceeds 1, dump package's elements. 687 */ 688 if (ObjDesc->Package.Count && 689 ObjDesc->Package.Elements && 690 AcpiDbgLevel > 1) 691 { 692 for (Index = 0; Index < ObjDesc->Package.Count; Index++) 693 { 694 AcpiExDumpOperand (ObjDesc->Package.Elements[Index], Depth+1); 695 } 696 } 697 break; 698 699 700 case ACPI_TYPE_REGION: 701 702 AcpiOsPrintf ("Region %s (%X)", 703 AcpiUtGetRegionName (ObjDesc->Region.SpaceId), 704 ObjDesc->Region.SpaceId); 705 706 /* 707 * If the address and length have not been evaluated, 708 * don't print them. 709 */ 710 if (!(ObjDesc->Region.Flags & AOPOBJ_DATA_VALID)) 711 { 712 AcpiOsPrintf ("\n"); 713 } 714 else 715 { 716 AcpiOsPrintf (" base %8.8X%8.8X Length %X\n", 717 ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address), 718 ObjDesc->Region.Length); 719 } 720 break; 721 722 723 case ACPI_TYPE_STRING: 724 725 AcpiOsPrintf ("String length %X @ %p ", 726 ObjDesc->String.Length, 727 ObjDesc->String.Pointer); 728 729 AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX); 730 AcpiOsPrintf ("\n"); 731 break; 732 733 734 case ACPI_TYPE_LOCAL_BANK_FIELD: 735 736 AcpiOsPrintf ("BankField\n"); 737 break; 738 739 740 case ACPI_TYPE_LOCAL_REGION_FIELD: 741 742 AcpiOsPrintf ("RegionField: Bits=%X AccWidth=%X Lock=%X Update=%X at " 743 "byte=%X bit=%X of below:\n", 744 ObjDesc->Field.BitLength, 745 ObjDesc->Field.AccessByteWidth, 746 ObjDesc->Field.FieldFlags & AML_FIELD_LOCK_RULE_MASK, 747 ObjDesc->Field.FieldFlags & AML_FIELD_UPDATE_RULE_MASK, 748 ObjDesc->Field.BaseByteOffset, 749 ObjDesc->Field.StartFieldBitOffset); 750 751 AcpiExDumpOperand (ObjDesc->Field.RegionObj, Depth+1); 752 break; 753 754 755 case ACPI_TYPE_LOCAL_INDEX_FIELD: 756 757 AcpiOsPrintf ("IndexField\n"); 758 break; 759 760 761 case ACPI_TYPE_BUFFER_FIELD: 762 763 AcpiOsPrintf ("BufferField: %X bits at byte %X bit %X of\n", 764 ObjDesc->BufferField.BitLength, 765 ObjDesc->BufferField.BaseByteOffset, 766 ObjDesc->BufferField.StartFieldBitOffset); 767 768 if (!ObjDesc->BufferField.BufferObj) 769 { 770 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "*NULL*\n")); 771 } 772 else if ((ObjDesc->BufferField.BufferObj)->Common.Type != 773 ACPI_TYPE_BUFFER) 774 { 775 AcpiOsPrintf ("*not a Buffer*\n"); 776 } 777 else 778 { 779 AcpiExDumpOperand (ObjDesc->BufferField.BufferObj, Depth+1); 780 } 781 break; 782 783 784 case ACPI_TYPE_EVENT: 785 786 AcpiOsPrintf ("Event\n"); 787 break; 788 789 790 case ACPI_TYPE_METHOD: 791 792 AcpiOsPrintf ("Method(%X) @ %p:%X\n", 793 ObjDesc->Method.ParamCount, 794 ObjDesc->Method.AmlStart, 795 ObjDesc->Method.AmlLength); 796 break; 797 798 799 case ACPI_TYPE_MUTEX: 800 801 AcpiOsPrintf ("Mutex\n"); 802 break; 803 804 805 case ACPI_TYPE_DEVICE: 806 807 AcpiOsPrintf ("Device\n"); 808 break; 809 810 811 case ACPI_TYPE_POWER: 812 813 AcpiOsPrintf ("Power\n"); 814 break; 815 816 817 case ACPI_TYPE_PROCESSOR: 818 819 AcpiOsPrintf ("Processor\n"); 820 break; 821 822 823 case ACPI_TYPE_THERMAL: 824 825 AcpiOsPrintf ("Thermal\n"); 826 break; 827 828 829 default: 830 /* Unknown Type */ 831 832 AcpiOsPrintf ("Unknown Type %X\n", ObjDesc->Common.Type); 833 break; 834 } 835 836 return; 837 } 838 839 840 /******************************************************************************* 841 * 842 * FUNCTION: AcpiExDumpOperands 843 * 844 * PARAMETERS: Operands - A list of Operand objects 845 * OpcodeName - AML opcode name 846 * NumOperands - Operand count for this opcode 847 * 848 * DESCRIPTION: Dump the operands associated with the opcode 849 * 850 ******************************************************************************/ 851 852 void 853 AcpiExDumpOperands ( 854 ACPI_OPERAND_OBJECT **Operands, 855 const char *OpcodeName, 856 UINT32 NumOperands) 857 { 858 ACPI_FUNCTION_NAME (ExDumpOperands); 859 860 861 if (!OpcodeName) 862 { 863 OpcodeName = "UNKNOWN"; 864 } 865 866 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 867 "**** Start operand dump for opcode [%s], %d operands\n", 868 OpcodeName, NumOperands)); 869 870 if (NumOperands == 0) 871 { 872 NumOperands = 1; 873 } 874 875 /* Dump the individual operands */ 876 877 while (NumOperands) 878 { 879 AcpiExDumpOperand (*Operands, 0); 880 Operands++; 881 NumOperands--; 882 } 883 884 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 885 "**** End operand dump for [%s]\n", OpcodeName)); 886 return; 887 } 888 889 890 /******************************************************************************* 891 * 892 * FUNCTION: AcpiExOut* functions 893 * 894 * PARAMETERS: Title - Descriptive text 895 * Value - Value to be displayed 896 * 897 * DESCRIPTION: Object dump output formatting functions. These functions 898 * reduce the number of format strings required and keeps them 899 * all in one place for easy modification. 900 * 901 ******************************************************************************/ 902 903 static void 904 AcpiExOutString ( 905 char *Title, 906 char *Value) 907 { 908 AcpiOsPrintf ("%20s : %s\n", Title, Value); 909 } 910 911 static void 912 AcpiExOutPointer ( 913 char *Title, 914 void *Value) 915 { 916 AcpiOsPrintf ("%20s : %p\n", Title, Value); 917 } 918 919 920 /******************************************************************************* 921 * 922 * FUNCTION: AcpiExDumpNamespaceNode 923 * 924 * PARAMETERS: Node - Descriptor to dump 925 * Flags - Force display if TRUE 926 * 927 * DESCRIPTION: Dumps the members of the given.Node 928 * 929 ******************************************************************************/ 930 931 void 932 AcpiExDumpNamespaceNode ( 933 ACPI_NAMESPACE_NODE *Node, 934 UINT32 Flags) 935 { 936 937 ACPI_FUNCTION_ENTRY (); 938 939 940 if (!Flags) 941 { 942 if (!((ACPI_LV_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) 943 { 944 return; 945 } 946 } 947 948 AcpiOsPrintf ("%20s : %4.4s\n", "Name", AcpiUtGetNodeName (Node)); 949 AcpiExOutString ("Type", AcpiUtGetTypeName (Node->Type)); 950 AcpiExOutPointer ("Attached Object", AcpiNsGetAttachedObject (Node)); 951 AcpiExOutPointer ("Parent", AcpiNsGetParentNode (Node)); 952 953 AcpiExDumpObject (ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Node), 954 AcpiExDumpNode); 955 } 956 957 958 /******************************************************************************* 959 * 960 * FUNCTION: AcpiExDumpReferenceObj 961 * 962 * PARAMETERS: Object - Descriptor to dump 963 * 964 * DESCRIPTION: Dumps a reference object 965 * 966 ******************************************************************************/ 967 968 static void 969 AcpiExDumpReferenceObj ( 970 ACPI_OPERAND_OBJECT *ObjDesc) 971 { 972 ACPI_BUFFER RetBuf; 973 ACPI_STATUS Status; 974 975 976 RetBuf.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 977 978 if (ObjDesc->Reference.Class == ACPI_REFCLASS_NAME) 979 { 980 AcpiOsPrintf (" %p ", ObjDesc->Reference.Node); 981 982 Status = AcpiNsHandleToPathname (ObjDesc->Reference.Node, &RetBuf); 983 if (ACPI_FAILURE (Status)) 984 { 985 AcpiOsPrintf (" Could not convert name to pathname\n"); 986 } 987 else 988 { 989 AcpiOsPrintf ("%s\n", (char *) RetBuf.Pointer); 990 ACPI_FREE (RetBuf.Pointer); 991 } 992 } 993 else if (ObjDesc->Reference.Object) 994 { 995 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) 996 { 997 AcpiOsPrintf (" Target: %p", ObjDesc->Reference.Object); 998 if (ObjDesc->Reference.Class == ACPI_REFCLASS_TABLE) 999 { 1000 AcpiOsPrintf (" Table Index: %X\n", ObjDesc->Reference.Value); 1001 } 1002 else 1003 { 1004 AcpiOsPrintf (" Target: %p [%s]\n", ObjDesc->Reference.Object, 1005 AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) 1006 ObjDesc->Reference.Object)->Common.Type)); 1007 } 1008 } 1009 else 1010 { 1011 AcpiOsPrintf (" Target: %p\n", ObjDesc->Reference.Object); 1012 } 1013 } 1014 } 1015 1016 1017 /******************************************************************************* 1018 * 1019 * FUNCTION: AcpiExDumpPackageObj 1020 * 1021 * PARAMETERS: ObjDesc - Descriptor to dump 1022 * Level - Indentation Level 1023 * Index - Package index for this object 1024 * 1025 * DESCRIPTION: Dumps the elements of the package 1026 * 1027 ******************************************************************************/ 1028 1029 static void 1030 AcpiExDumpPackageObj ( 1031 ACPI_OPERAND_OBJECT *ObjDesc, 1032 UINT32 Level, 1033 UINT32 Index) 1034 { 1035 UINT32 i; 1036 1037 1038 /* Indentation and index output */ 1039 1040 if (Level > 0) 1041 { 1042 for (i = 0; i < Level; i++) 1043 { 1044 AcpiOsPrintf (" "); 1045 } 1046 1047 AcpiOsPrintf ("[%.2d] ", Index); 1048 } 1049 1050 AcpiOsPrintf ("%p ", ObjDesc); 1051 1052 /* Null package elements are allowed */ 1053 1054 if (!ObjDesc) 1055 { 1056 AcpiOsPrintf ("[Null Object]\n"); 1057 return; 1058 } 1059 1060 /* Packages may only contain a few object types */ 1061 1062 switch (ObjDesc->Common.Type) 1063 { 1064 case ACPI_TYPE_INTEGER: 1065 1066 AcpiOsPrintf ("[Integer] = %8.8X%8.8X\n", 1067 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 1068 break; 1069 1070 1071 case ACPI_TYPE_STRING: 1072 1073 AcpiOsPrintf ("[String] Value: "); 1074 for (i = 0; i < ObjDesc->String.Length; i++) 1075 { 1076 AcpiOsPrintf ("%c", ObjDesc->String.Pointer[i]); 1077 } 1078 AcpiOsPrintf ("\n"); 1079 break; 1080 1081 1082 case ACPI_TYPE_BUFFER: 1083 1084 AcpiOsPrintf ("[Buffer] Length %.2X = ", ObjDesc->Buffer.Length); 1085 if (ObjDesc->Buffer.Length) 1086 { 1087 AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, ObjDesc->Buffer.Pointer), 1088 ObjDesc->Buffer.Length, DB_DWORD_DISPLAY, _COMPONENT); 1089 } 1090 else 1091 { 1092 AcpiOsPrintf ("\n"); 1093 } 1094 break; 1095 1096 1097 case ACPI_TYPE_PACKAGE: 1098 1099 AcpiOsPrintf ("[Package] Contains %d Elements:\n", 1100 ObjDesc->Package.Count); 1101 1102 for (i = 0; i < ObjDesc->Package.Count; i++) 1103 { 1104 AcpiExDumpPackageObj (ObjDesc->Package.Elements[i], Level+1, i); 1105 } 1106 break; 1107 1108 1109 case ACPI_TYPE_LOCAL_REFERENCE: 1110 1111 AcpiOsPrintf ("[Object Reference] Type [%s] %2.2X", 1112 AcpiUtGetReferenceName (ObjDesc), 1113 ObjDesc->Reference.Class); 1114 AcpiExDumpReferenceObj (ObjDesc); 1115 break; 1116 1117 1118 default: 1119 1120 AcpiOsPrintf ("[Unknown Type] %X\n", ObjDesc->Common.Type); 1121 break; 1122 } 1123 } 1124 1125 1126 /******************************************************************************* 1127 * 1128 * FUNCTION: AcpiExDumpObjectDescriptor 1129 * 1130 * PARAMETERS: ObjDesc - Descriptor to dump 1131 * Flags - Force display if TRUE 1132 * 1133 * DESCRIPTION: Dumps the members of the object descriptor given. 1134 * 1135 ******************************************************************************/ 1136 1137 void 1138 AcpiExDumpObjectDescriptor ( 1139 ACPI_OPERAND_OBJECT *ObjDesc, 1140 UINT32 Flags) 1141 { 1142 ACPI_FUNCTION_TRACE (ExDumpObjectDescriptor); 1143 1144 1145 if (!ObjDesc) 1146 { 1147 return_VOID; 1148 } 1149 1150 if (!Flags) 1151 { 1152 if (!((ACPI_LV_OBJECTS & AcpiDbgLevel) && (_COMPONENT & AcpiDbgLayer))) 1153 { 1154 return_VOID; 1155 } 1156 } 1157 1158 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) 1159 { 1160 AcpiExDumpNamespaceNode ((ACPI_NAMESPACE_NODE *) ObjDesc, Flags); 1161 1162 AcpiOsPrintf ("\nAttached Object (%p):\n", 1163 ((ACPI_NAMESPACE_NODE *) ObjDesc)->Object); 1164 1165 AcpiExDumpObjectDescriptor ( 1166 ((ACPI_NAMESPACE_NODE *) ObjDesc)->Object, Flags); 1167 return_VOID; 1168 } 1169 1170 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) 1171 { 1172 AcpiOsPrintf ( 1173 "ExDumpObjectDescriptor: %p is not an ACPI operand object: [%s]\n", 1174 ObjDesc, AcpiUtGetDescriptorName (ObjDesc)); 1175 return_VOID; 1176 } 1177 1178 if (ObjDesc->Common.Type > ACPI_TYPE_NS_NODE_MAX) 1179 { 1180 return_VOID; 1181 } 1182 1183 /* Common Fields */ 1184 1185 AcpiExDumpObject (ObjDesc, AcpiExDumpCommon); 1186 1187 /* Object-specific fields */ 1188 1189 AcpiExDumpObject (ObjDesc, AcpiExDumpInfo[ObjDesc->Common.Type]); 1190 return_VOID; 1191 } 1192 1193 #endif 1194 1195