1/****************************************************************************** 2 * 3 * Module Name: exdump - Interpreter debug output routines 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44#include <acpi/acpi.h> 45#include "accommon.h" 46#include "acinterp.h" 47#include "amlcode.h" 48#include "acnamesp.h" 49 50#define _COMPONENT ACPI_EXECUTER 51ACPI_MODULE_NAME("exdump") 52 53/* 54 * The following routines are used for debug output only 55 */ 56#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 57/* Local prototypes */ 58static void acpi_ex_out_string(char *title, char *value); 59 60static void acpi_ex_out_pointer(char *title, void *value); 61 62static void 63acpi_ex_dump_object(union acpi_operand_object *obj_desc, 64 struct acpi_exdump_info *info); 65 66static void acpi_ex_dump_reference_obj(union acpi_operand_object *obj_desc); 67 68static void 69acpi_ex_dump_package_obj(union acpi_operand_object *obj_desc, 70 u32 level, u32 index); 71 72/******************************************************************************* 73 * 74 * Object Descriptor info tables 75 * 76 * Note: The first table entry must be an INIT opcode and must contain 77 * the table length (number of table entries) 78 * 79 ******************************************************************************/ 80 81static struct acpi_exdump_info acpi_ex_dump_integer[2] = { 82 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_integer), NULL}, 83 {ACPI_EXD_UINT64, ACPI_EXD_OFFSET(integer.value), "Value"} 84}; 85 86static struct acpi_exdump_info acpi_ex_dump_string[4] = { 87 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_string), NULL}, 88 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(string.length), "Length"}, 89 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(string.pointer), "Pointer"}, 90 {ACPI_EXD_STRING, 0, NULL} 91}; 92 93static struct acpi_exdump_info acpi_ex_dump_buffer[5] = { 94 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_buffer), NULL}, 95 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(buffer.length), "Length"}, 96 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer.pointer), "Pointer"}, 97 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer.node), "Parent Node"}, 98 {ACPI_EXD_BUFFER, 0, NULL} 99}; 100 101static struct acpi_exdump_info acpi_ex_dump_package[5] = { 102 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_package), NULL}, 103 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(package.flags), "Flags"}, 104 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(package.count), "Elements"}, 105 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(package.elements), "Element List"}, 106 {ACPI_EXD_PACKAGE, 0, NULL} 107}; 108 109static struct acpi_exdump_info acpi_ex_dump_device[4] = { 110 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_device), NULL}, 111 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.handler), "Handler"}, 112 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.system_notify), 113 "System Notify"}, 114 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.device_notify), 115 "Device Notify"} 116}; 117 118static struct acpi_exdump_info acpi_ex_dump_event[2] = { 119 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_event), NULL}, 120 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(event.os_semaphore), "OsSemaphore"} 121}; 122 123static struct acpi_exdump_info acpi_ex_dump_method[9] = { 124 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_method), NULL}, 125 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.method_flags), "Method Flags"}, 126 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.param_count), 127 "Parameter Count"}, 128 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.sync_level), "Sync Level"}, 129 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.mutex), "Mutex"}, 130 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.owner_id), "Owner Id"}, 131 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.thread_count), "Thread Count"}, 132 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(method.aml_length), "Aml Length"}, 133 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.aml_start), "Aml Start"} 134}; 135 136static struct acpi_exdump_info acpi_ex_dump_mutex[5] = { 137 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_mutex), NULL}, 138 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(mutex.sync_level), "Sync Level"}, 139 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.owner_thread), "Owner Thread"}, 140 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(mutex.acquisition_depth), 141 "Acquire Depth"}, 142 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.os_mutex), "OsMutex"} 143}; 144 145static struct acpi_exdump_info acpi_ex_dump_region[7] = { 146 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_region), NULL}, 147 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(region.space_id), "Space Id"}, 148 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(region.flags), "Flags"}, 149 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET(region.address), "Address"}, 150 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(region.length), "Length"}, 151 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(region.handler), "Handler"}, 152 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(region.next), "Next"} 153}; 154 155static struct acpi_exdump_info acpi_ex_dump_power[5] = { 156 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_power), NULL}, 157 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(power_resource.system_level), 158 "System Level"}, 159 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(power_resource.resource_order), 160 "Resource Order"}, 161 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(power_resource.system_notify), 162 "System Notify"}, 163 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(power_resource.device_notify), 164 "Device Notify"} 165}; 166 167static struct acpi_exdump_info acpi_ex_dump_processor[7] = { 168 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_processor), NULL}, 169 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(processor.proc_id), "Processor ID"}, 170 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(processor.length), "Length"}, 171 {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET(processor.address), "Address"}, 172 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.system_notify), 173 "System Notify"}, 174 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.device_notify), 175 "Device Notify"}, 176 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.handler), "Handler"} 177}; 178 179static struct acpi_exdump_info acpi_ex_dump_thermal[4] = { 180 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_thermal), NULL}, 181 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.system_notify), 182 "System Notify"}, 183 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.device_notify), 184 "Device Notify"}, 185 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.handler), "Handler"} 186}; 187 188static struct acpi_exdump_info acpi_ex_dump_buffer_field[3] = { 189 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_buffer_field), NULL}, 190 {ACPI_EXD_FIELD, 0, NULL}, 191 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer_field.buffer_obj), 192 "Buffer Object"} 193}; 194 195static struct acpi_exdump_info acpi_ex_dump_region_field[3] = { 196 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_region_field), NULL}, 197 {ACPI_EXD_FIELD, 0, NULL}, 198 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(field.region_obj), "Region Object"} 199}; 200 201static struct acpi_exdump_info acpi_ex_dump_bank_field[5] = { 202 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_bank_field), NULL}, 203 {ACPI_EXD_FIELD, 0, NULL}, 204 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(bank_field.value), "Value"}, 205 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(bank_field.region_obj), 206 "Region Object"}, 207 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(bank_field.bank_obj), "Bank Object"} 208}; 209 210static struct acpi_exdump_info acpi_ex_dump_index_field[5] = { 211 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_bank_field), NULL}, 212 {ACPI_EXD_FIELD, 0, NULL}, 213 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(index_field.value), "Value"}, 214 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(index_field.index_obj), 215 "Index Object"}, 216 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(index_field.data_obj), "Data Object"} 217}; 218 219static struct acpi_exdump_info acpi_ex_dump_reference[8] = { 220 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_reference), NULL}, 221 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(reference.class), "Class"}, 222 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(reference.target_type), "Target Type"}, 223 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(reference.value), "Value"}, 224 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.object), "Object Desc"}, 225 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.node), "Node"}, 226 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.where), "Where"}, 227 {ACPI_EXD_REFERENCE, 0, NULL} 228}; 229 230static struct acpi_exdump_info acpi_ex_dump_address_handler[6] = { 231 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_address_handler), 232 NULL}, 233 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(address_space.space_id), "Space Id"}, 234 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.next), "Next"}, 235 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.region_list), 236 "Region List"}, 237 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.node), "Node"}, 238 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.context), "Context"} 239}; 240 241static struct acpi_exdump_info acpi_ex_dump_notify[3] = { 242 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_notify), NULL}, 243 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(notify.node), "Node"}, 244 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(notify.context), "Context"} 245}; 246 247/* Miscellaneous tables */ 248 249static struct acpi_exdump_info acpi_ex_dump_common[4] = { 250 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_common), NULL}, 251 {ACPI_EXD_TYPE, 0, NULL}, 252 {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(common.reference_count), 253 "Reference Count"}, 254 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common.flags), "Flags"} 255}; 256 257static struct acpi_exdump_info acpi_ex_dump_field_common[7] = { 258 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_field_common), NULL}, 259 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.field_flags), 260 "Field Flags"}, 261 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.access_byte_width), 262 "Access Byte Width"}, 263 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(common_field.bit_length), 264 "Bit Length"}, 265 {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.start_field_bit_offset), 266 "Field Bit Offset"}, 267 {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(common_field.base_byte_offset), 268 "Base Byte Offset"}, 269 {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(common_field.node), "Parent Node"} 270}; 271 272static struct acpi_exdump_info acpi_ex_dump_node[5] = { 273 {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_node), NULL}, 274 {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET(flags), "Flags"}, 275 {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET(owner_id), "Owner Id"}, 276 {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET(child), "Child List"}, 277 {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET(peer), "Next Peer"} 278}; 279 280/* Dispatch table, indexed by object type */ 281 282static struct acpi_exdump_info *acpi_ex_dump_info[] = { 283 NULL, 284 acpi_ex_dump_integer, 285 acpi_ex_dump_string, 286 acpi_ex_dump_buffer, 287 acpi_ex_dump_package, 288 NULL, 289 acpi_ex_dump_device, 290 acpi_ex_dump_event, 291 acpi_ex_dump_method, 292 acpi_ex_dump_mutex, 293 acpi_ex_dump_region, 294 acpi_ex_dump_power, 295 acpi_ex_dump_processor, 296 acpi_ex_dump_thermal, 297 acpi_ex_dump_buffer_field, 298 NULL, 299 NULL, 300 acpi_ex_dump_region_field, 301 acpi_ex_dump_bank_field, 302 acpi_ex_dump_index_field, 303 acpi_ex_dump_reference, 304 NULL, 305 NULL, 306 acpi_ex_dump_notify, 307 acpi_ex_dump_address_handler, 308 NULL, 309 NULL, 310 NULL 311}; 312 313/******************************************************************************* 314 * 315 * FUNCTION: acpi_ex_dump_object 316 * 317 * PARAMETERS: obj_desc - Descriptor to dump 318 * Info - Info table corresponding to this object 319 * type 320 * 321 * RETURN: None 322 * 323 * DESCRIPTION: Walk the info table for this object 324 * 325 ******************************************************************************/ 326 327static void 328acpi_ex_dump_object(union acpi_operand_object *obj_desc, 329 struct acpi_exdump_info *info) 330{ 331 u8 *target; 332 char *name; 333 u8 count; 334 335 if (!info) { 336 acpi_os_printf 337 ("ExDumpObject: Display not implemented for object type %s\n", 338 acpi_ut_get_object_type_name(obj_desc)); 339 return; 340 } 341 342 /* First table entry must contain the table length (# of table entries) */ 343 344 count = info->offset; 345 346 while (count) { 347 target = ACPI_ADD_PTR(u8, obj_desc, info->offset); 348 name = info->name; 349 350 switch (info->opcode) { 351 case ACPI_EXD_INIT: 352 break; 353 354 case ACPI_EXD_TYPE: 355 356 acpi_ex_out_string("Type", 357 acpi_ut_get_object_type_name 358 (obj_desc)); 359 break; 360 361 case ACPI_EXD_UINT8: 362 363 acpi_os_printf("%20s : %2.2X\n", name, *target); 364 break; 365 366 case ACPI_EXD_UINT16: 367 368 acpi_os_printf("%20s : %4.4X\n", name, 369 ACPI_GET16(target)); 370 break; 371 372 case ACPI_EXD_UINT32: 373 374 acpi_os_printf("%20s : %8.8X\n", name, 375 ACPI_GET32(target)); 376 break; 377 378 case ACPI_EXD_UINT64: 379 380 acpi_os_printf("%20s : %8.8X%8.8X\n", "Value", 381 ACPI_FORMAT_UINT64(ACPI_GET64(target))); 382 break; 383 384 case ACPI_EXD_POINTER: 385 case ACPI_EXD_ADDRESS: 386 387 acpi_ex_out_pointer(name, 388 *ACPI_CAST_PTR(void *, target)); 389 break; 390 391 case ACPI_EXD_STRING: 392 393 acpi_ut_print_string(obj_desc->string.pointer, 394 ACPI_UINT8_MAX); 395 acpi_os_printf("\n"); 396 break; 397 398 case ACPI_EXD_BUFFER: 399 400 ACPI_DUMP_BUFFER(obj_desc->buffer.pointer, 401 obj_desc->buffer.length); 402 break; 403 404 case ACPI_EXD_PACKAGE: 405 406 /* Dump the package contents */ 407 408 acpi_os_printf("\nPackage Contents:\n"); 409 acpi_ex_dump_package_obj(obj_desc, 0, 0); 410 break; 411 412 case ACPI_EXD_FIELD: 413 414 acpi_ex_dump_object(obj_desc, 415 acpi_ex_dump_field_common); 416 break; 417 418 case ACPI_EXD_REFERENCE: 419 420 acpi_ex_out_string("Class Name", 421 ACPI_CAST_PTR(char, 422 acpi_ut_get_reference_name 423 (obj_desc))); 424 acpi_ex_dump_reference_obj(obj_desc); 425 break; 426 427 default: 428 429 acpi_os_printf("**** Invalid table opcode [%X] ****\n", 430 info->opcode); 431 return; 432 } 433 434 info++; 435 count--; 436 } 437} 438 439/******************************************************************************* 440 * 441 * FUNCTION: acpi_ex_dump_operand 442 * 443 * PARAMETERS: *obj_desc - Pointer to entry to be dumped 444 * Depth - Current nesting depth 445 * 446 * RETURN: None 447 * 448 * DESCRIPTION: Dump an operand object 449 * 450 ******************************************************************************/ 451 452void acpi_ex_dump_operand(union acpi_operand_object *obj_desc, u32 depth) 453{ 454 u32 length; 455 u32 index; 456 457 ACPI_FUNCTION_NAME(ex_dump_operand) 458 459 if (!((ACPI_LV_EXEC & acpi_dbg_level) 460 && (_COMPONENT & acpi_dbg_layer))) { 461 return; 462 } 463 464 if (!obj_desc) { 465 466 /* This could be a null element of a package */ 467 468 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Null Object Descriptor\n")); 469 return; 470 } 471 472 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == ACPI_DESC_TYPE_NAMED) { 473 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%p Namespace Node: ", 474 obj_desc)); 475 ACPI_DUMP_ENTRY(obj_desc, ACPI_LV_EXEC); 476 return; 477 } 478 479 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) { 480 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 481 "%p is not a node or operand object: [%s]\n", 482 obj_desc, 483 acpi_ut_get_descriptor_name(obj_desc))); 484 ACPI_DUMP_BUFFER(obj_desc, sizeof(union acpi_operand_object)); 485 return; 486 } 487 488 /* obj_desc is a valid object */ 489 490 if (depth > 0) { 491 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%*s[%u] %p ", 492 depth, " ", depth, obj_desc)); 493 } else { 494 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%p ", obj_desc)); 495 } 496 497 /* Decode object type */ 498 499 switch (obj_desc->common.type) { 500 case ACPI_TYPE_LOCAL_REFERENCE: 501 502 acpi_os_printf("Reference: [%s] ", 503 acpi_ut_get_reference_name(obj_desc)); 504 505 switch (obj_desc->reference.class) { 506 case ACPI_REFCLASS_DEBUG: 507 508 acpi_os_printf("\n"); 509 break; 510 511 case ACPI_REFCLASS_INDEX: 512 513 acpi_os_printf("%p\n", obj_desc->reference.object); 514 break; 515 516 case ACPI_REFCLASS_TABLE: 517 518 acpi_os_printf("Table Index %X\n", 519 obj_desc->reference.value); 520 break; 521 522 case ACPI_REFCLASS_REFOF: 523 524 acpi_os_printf("%p [%s]\n", obj_desc->reference.object, 525 acpi_ut_get_type_name(((union 526 acpi_operand_object 527 *) 528 obj_desc-> 529 reference. 530 object)->common. 531 type)); 532 break; 533 534 case ACPI_REFCLASS_NAME: 535 536 acpi_os_printf("- [%4.4s]\n", 537 obj_desc->reference.node->name.ascii); 538 break; 539 540 case ACPI_REFCLASS_ARG: 541 case ACPI_REFCLASS_LOCAL: 542 543 acpi_os_printf("%X\n", obj_desc->reference.value); 544 break; 545 546 default: /* Unknown reference class */ 547 548 acpi_os_printf("%2.2X\n", obj_desc->reference.class); 549 break; 550 } 551 break; 552 553 case ACPI_TYPE_BUFFER: 554 555 acpi_os_printf("Buffer length %.2X @ %p\n", 556 obj_desc->buffer.length, 557 obj_desc->buffer.pointer); 558 559 /* Debug only -- dump the buffer contents */ 560 561 if (obj_desc->buffer.pointer) { 562 length = obj_desc->buffer.length; 563 if (length > 128) { 564 length = 128; 565 } 566 567 acpi_os_printf 568 ("Buffer Contents: (displaying length 0x%.2X)\n", 569 length); 570 ACPI_DUMP_BUFFER(obj_desc->buffer.pointer, length); 571 } 572 break; 573 574 case ACPI_TYPE_INTEGER: 575 576 acpi_os_printf("Integer %8.8X%8.8X\n", 577 ACPI_FORMAT_UINT64(obj_desc->integer.value)); 578 break; 579 580 case ACPI_TYPE_PACKAGE: 581 582 acpi_os_printf("Package [Len %X] ElementArray %p\n", 583 obj_desc->package.count, 584 obj_desc->package.elements); 585 586 /* 587 * If elements exist, package element pointer is valid, 588 * and debug_level exceeds 1, dump package's elements. 589 */ 590 if (obj_desc->package.count && 591 obj_desc->package.elements && acpi_dbg_level > 1) { 592 for (index = 0; index < obj_desc->package.count; 593 index++) { 594 acpi_ex_dump_operand(obj_desc->package. 595 elements[index], 596 depth + 1); 597 } 598 } 599 break; 600 601 case ACPI_TYPE_REGION: 602 603 acpi_os_printf("Region %s (%X)", 604 acpi_ut_get_region_name(obj_desc->region. 605 space_id), 606 obj_desc->region.space_id); 607 608 /* 609 * If the address and length have not been evaluated, 610 * don't print them. 611 */ 612 if (!(obj_desc->region.flags & AOPOBJ_DATA_VALID)) { 613 acpi_os_printf("\n"); 614 } else { 615 acpi_os_printf(" base %8.8X%8.8X Length %X\n", 616 ACPI_FORMAT_NATIVE_UINT(obj_desc->region. 617 address), 618 obj_desc->region.length); 619 } 620 break; 621 622 case ACPI_TYPE_STRING: 623 624 acpi_os_printf("String length %X @ %p ", 625 obj_desc->string.length, 626 obj_desc->string.pointer); 627 628 acpi_ut_print_string(obj_desc->string.pointer, ACPI_UINT8_MAX); 629 acpi_os_printf("\n"); 630 break; 631 632 case ACPI_TYPE_LOCAL_BANK_FIELD: 633 634 acpi_os_printf("BankField\n"); 635 break; 636 637 case ACPI_TYPE_LOCAL_REGION_FIELD: 638 639 acpi_os_printf 640 ("RegionField: Bits=%X AccWidth=%X Lock=%X Update=%X at " 641 "byte=%X bit=%X of below:\n", obj_desc->field.bit_length, 642 obj_desc->field.access_byte_width, 643 obj_desc->field.field_flags & AML_FIELD_LOCK_RULE_MASK, 644 obj_desc->field.field_flags & AML_FIELD_UPDATE_RULE_MASK, 645 obj_desc->field.base_byte_offset, 646 obj_desc->field.start_field_bit_offset); 647 648 acpi_ex_dump_operand(obj_desc->field.region_obj, depth + 1); 649 break; 650 651 case ACPI_TYPE_LOCAL_INDEX_FIELD: 652 653 acpi_os_printf("IndexField\n"); 654 break; 655 656 case ACPI_TYPE_BUFFER_FIELD: 657 658 acpi_os_printf("BufferField: %X bits at byte %X bit %X of\n", 659 obj_desc->buffer_field.bit_length, 660 obj_desc->buffer_field.base_byte_offset, 661 obj_desc->buffer_field.start_field_bit_offset); 662 663 if (!obj_desc->buffer_field.buffer_obj) { 664 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "*NULL*\n")); 665 } else if ((obj_desc->buffer_field.buffer_obj)->common.type != 666 ACPI_TYPE_BUFFER) { 667 acpi_os_printf("*not a Buffer*\n"); 668 } else { 669 acpi_ex_dump_operand(obj_desc->buffer_field.buffer_obj, 670 depth + 1); 671 } 672 break; 673 674 case ACPI_TYPE_EVENT: 675 676 acpi_os_printf("Event\n"); 677 break; 678 679 case ACPI_TYPE_METHOD: 680 681 acpi_os_printf("Method(%X) @ %p:%X\n", 682 obj_desc->method.param_count, 683 obj_desc->method.aml_start, 684 obj_desc->method.aml_length); 685 break; 686 687 case ACPI_TYPE_MUTEX: 688 689 acpi_os_printf("Mutex\n"); 690 break; 691 692 case ACPI_TYPE_DEVICE: 693 694 acpi_os_printf("Device\n"); 695 break; 696 697 case ACPI_TYPE_POWER: 698 699 acpi_os_printf("Power\n"); 700 break; 701 702 case ACPI_TYPE_PROCESSOR: 703 704 acpi_os_printf("Processor\n"); 705 break; 706 707 case ACPI_TYPE_THERMAL: 708 709 acpi_os_printf("Thermal\n"); 710 break; 711 712 default: 713 /* Unknown Type */ 714 715 acpi_os_printf("Unknown Type %X\n", obj_desc->common.type); 716 break; 717 } 718 719 return; 720} 721 722/******************************************************************************* 723 * 724 * FUNCTION: acpi_ex_dump_operands 725 * 726 * PARAMETERS: Operands - A list of Operand objects 727 * opcode_name - AML opcode name 728 * num_operands - Operand count for this opcode 729 * 730 * DESCRIPTION: Dump the operands associated with the opcode 731 * 732 ******************************************************************************/ 733 734void 735acpi_ex_dump_operands(union acpi_operand_object **operands, 736 const char *opcode_name, u32 num_operands) 737{ 738 ACPI_FUNCTION_NAME(ex_dump_operands); 739 740 if (!opcode_name) { 741 opcode_name = "UNKNOWN"; 742 } 743 744 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 745 "**** Start operand dump for opcode [%s], %u operands\n", 746 opcode_name, num_operands)); 747 748 if (num_operands == 0) { 749 num_operands = 1; 750 } 751 752 /* Dump the individual operands */ 753 754 while (num_operands) { 755 acpi_ex_dump_operand(*operands, 0); 756 operands++; 757 num_operands--; 758 } 759 760 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 761 "**** End operand dump for [%s]\n", opcode_name)); 762 return; 763} 764 765/******************************************************************************* 766 * 767 * FUNCTION: acpi_ex_out* functions 768 * 769 * PARAMETERS: Title - Descriptive text 770 * Value - Value to be displayed 771 * 772 * DESCRIPTION: Object dump output formatting functions. These functions 773 * reduce the number of format strings required and keeps them 774 * all in one place for easy modification. 775 * 776 ******************************************************************************/ 777 778static void acpi_ex_out_string(char *title, char *value) 779{ 780 acpi_os_printf("%20s : %s\n", title, value); 781} 782 783static void acpi_ex_out_pointer(char *title, void *value) 784{ 785 acpi_os_printf("%20s : %p\n", title, value); 786} 787 788/******************************************************************************* 789 * 790 * FUNCTION: acpi_ex_dump_namespace_node 791 * 792 * PARAMETERS: Node - Descriptor to dump 793 * Flags - Force display if TRUE 794 * 795 * DESCRIPTION: Dumps the members of the given.Node 796 * 797 ******************************************************************************/ 798 799void acpi_ex_dump_namespace_node(struct acpi_namespace_node *node, u32 flags) 800{ 801 802 ACPI_FUNCTION_ENTRY(); 803 804 if (!flags) { 805 if (!((ACPI_LV_OBJECTS & acpi_dbg_level) 806 && (_COMPONENT & acpi_dbg_layer))) { 807 return; 808 } 809 } 810 811 acpi_os_printf("%20s : %4.4s\n", "Name", acpi_ut_get_node_name(node)); 812 acpi_ex_out_string("Type", acpi_ut_get_type_name(node->type)); 813 acpi_ex_out_pointer("Attached Object", 814 acpi_ns_get_attached_object(node)); 815 acpi_ex_out_pointer("Parent", node->parent); 816 817 acpi_ex_dump_object(ACPI_CAST_PTR(union acpi_operand_object, node), 818 acpi_ex_dump_node); 819} 820 821/******************************************************************************* 822 * 823 * FUNCTION: acpi_ex_dump_reference_obj 824 * 825 * PARAMETERS: Object - Descriptor to dump 826 * 827 * DESCRIPTION: Dumps a reference object 828 * 829 ******************************************************************************/ 830 831static void acpi_ex_dump_reference_obj(union acpi_operand_object *obj_desc) 832{ 833 struct acpi_buffer ret_buf; 834 acpi_status status; 835 836 ret_buf.length = ACPI_ALLOCATE_LOCAL_BUFFER; 837 838 if (obj_desc->reference.class == ACPI_REFCLASS_NAME) { 839 acpi_os_printf(" %p ", obj_desc->reference.node); 840 841 status = 842 acpi_ns_handle_to_pathname(obj_desc->reference.node, 843 &ret_buf); 844 if (ACPI_FAILURE(status)) { 845 acpi_os_printf(" Could not convert name to pathname\n"); 846 } else { 847 acpi_os_printf("%s\n", (char *)ret_buf.pointer); 848 ACPI_FREE(ret_buf.pointer); 849 } 850 } else if (obj_desc->reference.object) { 851 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == 852 ACPI_DESC_TYPE_OPERAND) { 853 acpi_os_printf(" Target: %p", 854 obj_desc->reference.object); 855 if (obj_desc->reference.class == ACPI_REFCLASS_TABLE) { 856 acpi_os_printf(" Table Index: %X\n", 857 obj_desc->reference.value); 858 } else { 859 acpi_os_printf(" Target: %p [%s]\n", 860 obj_desc->reference.object, 861 acpi_ut_get_type_name(((union 862 acpi_operand_object 863 *) 864 obj_desc-> 865 reference. 866 object)-> 867 common. 868 type)); 869 } 870 } else { 871 acpi_os_printf(" Target: %p\n", 872 obj_desc->reference.object); 873 } 874 } 875} 876 877/******************************************************************************* 878 * 879 * FUNCTION: acpi_ex_dump_package_obj 880 * 881 * PARAMETERS: obj_desc - Descriptor to dump 882 * Level - Indentation Level 883 * Index - Package index for this object 884 * 885 * DESCRIPTION: Dumps the elements of the package 886 * 887 ******************************************************************************/ 888 889static void 890acpi_ex_dump_package_obj(union acpi_operand_object *obj_desc, 891 u32 level, u32 index) 892{ 893 u32 i; 894 895 /* Indentation and index output */ 896 897 if (level > 0) { 898 for (i = 0; i < level; i++) { 899 acpi_os_printf(" "); 900 } 901 902 acpi_os_printf("[%.2d] ", index); 903 } 904 905 acpi_os_printf("%p ", obj_desc); 906 907 /* Null package elements are allowed */ 908 909 if (!obj_desc) { 910 acpi_os_printf("[Null Object]\n"); 911 return; 912 } 913 914 /* Packages may only contain a few object types */ 915 916 switch (obj_desc->common.type) { 917 case ACPI_TYPE_INTEGER: 918 919 acpi_os_printf("[Integer] = %8.8X%8.8X\n", 920 ACPI_FORMAT_UINT64(obj_desc->integer.value)); 921 break; 922 923 case ACPI_TYPE_STRING: 924 925 acpi_os_printf("[String] Value: "); 926 for (i = 0; i < obj_desc->string.length; i++) { 927 acpi_os_printf("%c", obj_desc->string.pointer[i]); 928 } 929 acpi_os_printf("\n"); 930 break; 931 932 case ACPI_TYPE_BUFFER: 933 934 acpi_os_printf("[Buffer] Length %.2X = ", 935 obj_desc->buffer.length); 936 if (obj_desc->buffer.length) { 937 acpi_ut_dump_buffer(ACPI_CAST_PTR 938 (u8, obj_desc->buffer.pointer), 939 obj_desc->buffer.length, 940 DB_DWORD_DISPLAY, _COMPONENT); 941 } else { 942 acpi_os_printf("\n"); 943 } 944 break; 945 946 case ACPI_TYPE_PACKAGE: 947 948 acpi_os_printf("[Package] Contains %u Elements:\n", 949 obj_desc->package.count); 950 951 for (i = 0; i < obj_desc->package.count; i++) { 952 acpi_ex_dump_package_obj(obj_desc->package.elements[i], 953 level + 1, i); 954 } 955 break; 956 957 case ACPI_TYPE_LOCAL_REFERENCE: 958 959 acpi_os_printf("[Object Reference] Type [%s] %2.2X", 960 acpi_ut_get_reference_name(obj_desc), 961 obj_desc->reference.class); 962 acpi_ex_dump_reference_obj(obj_desc); 963 break; 964 965 default: 966 967 acpi_os_printf("[Unknown Type] %X\n", obj_desc->common.type); 968 break; 969 } 970} 971 972/******************************************************************************* 973 * 974 * FUNCTION: acpi_ex_dump_object_descriptor 975 * 976 * PARAMETERS: obj_desc - Descriptor to dump 977 * Flags - Force display if TRUE 978 * 979 * DESCRIPTION: Dumps the members of the object descriptor given. 980 * 981 ******************************************************************************/ 982 983void 984acpi_ex_dump_object_descriptor(union acpi_operand_object *obj_desc, u32 flags) 985{ 986 ACPI_FUNCTION_TRACE(ex_dump_object_descriptor); 987 988 if (!obj_desc) { 989 return_VOID; 990 } 991 992 if (!flags) { 993 if (!((ACPI_LV_OBJECTS & acpi_dbg_level) 994 && (_COMPONENT & acpi_dbg_layer))) { 995 return_VOID; 996 } 997 } 998 999 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == ACPI_DESC_TYPE_NAMED) { 1000 acpi_ex_dump_namespace_node((struct acpi_namespace_node *) 1001 obj_desc, flags); 1002 1003 acpi_os_printf("\nAttached Object (%p):\n", 1004 ((struct acpi_namespace_node *)obj_desc)-> 1005 object); 1006 1007 acpi_ex_dump_object_descriptor(((struct acpi_namespace_node *) 1008 obj_desc)->object, flags); 1009 return_VOID; 1010 } 1011 1012 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) { 1013 acpi_os_printf 1014 ("ExDumpObjectDescriptor: %p is not an ACPI operand object: [%s]\n", 1015 obj_desc, acpi_ut_get_descriptor_name(obj_desc)); 1016 return_VOID; 1017 } 1018 1019 if (obj_desc->common.type > ACPI_TYPE_NS_NODE_MAX) { 1020 return_VOID; 1021 } 1022 1023 /* Common Fields */ 1024 1025 acpi_ex_dump_object(obj_desc, acpi_ex_dump_common); 1026 1027 /* Object-specific fields */ 1028 1029 acpi_ex_dump_object(obj_desc, acpi_ex_dump_info[obj_desc->common.type]); 1030 return_VOID; 1031} 1032 1033#endif 1034