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