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