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