drivers/acpi/acpica/dbdisply.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbdisply - debug display commands
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2017, 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 "amlcode.h"
  47 #include "acdispat.h"
  48 #include "acnamesp.h"
  49 #include "acparser.h"
  50 #include "acinterp.h"
  51 #include "acevents.h"
  52 #include "acdebug.h"
  53
  54 #define _COMPONENT          ACPI_CA_DEBUGGER
  55 ACPI_MODULE_NAME("dbdisply")
  56
  57 /* Local prototypes */
  58 static void acpi_db_dump_parser_descriptor(union acpi_parse_object *op);
  59
  60 static void *acpi_db_get_pointer(void *target);
  61
  62 static acpi_status
  63 acpi_db_display_non_root_handlers(acpi_handle obj_handle,
  64                                   u32 nesting_level,
  65                                   void *context, void **return_value);
  66
  67 /*
  68  * System handler information.
  69  * Used for Handlers command, in acpi_db_display_handlers.
  70  */
  71 #define ACPI_PREDEFINED_PREFIX          "%25s (%.2X) : "
  72 #define ACPI_HANDLER_NAME_STRING               "%30s : "
  73 #define ACPI_HANDLER_PRESENT_STRING                    "%-9s (%p)\n"
  74 #define ACPI_HANDLER_PRESENT_STRING2                   "%-9s (%p)"
  75 #define ACPI_HANDLER_NOT_PRESENT_STRING                "%-9s\n"
  76
  77 /* All predefined Address Space IDs */
  78
  79 static acpi_adr_space_type acpi_gbl_space_id_list[] = {
  80         ACPI_ADR_SPACE_SYSTEM_MEMORY,
  81         ACPI_ADR_SPACE_SYSTEM_IO,
  82         ACPI_ADR_SPACE_PCI_CONFIG,
  83         ACPI_ADR_SPACE_EC,
  84         ACPI_ADR_SPACE_SMBUS,
  85         ACPI_ADR_SPACE_CMOS,
  86         ACPI_ADR_SPACE_PCI_BAR_TARGET,
  87         ACPI_ADR_SPACE_IPMI,
  88         ACPI_ADR_SPACE_GPIO,
  89         ACPI_ADR_SPACE_GSBUS,
  90         ACPI_ADR_SPACE_DATA_TABLE,
  91         ACPI_ADR_SPACE_FIXED_HARDWARE
  92 };
  93
  94 /* Global handler information */
  95
  96 typedef struct acpi_handler_info {
  97         void *handler;
  98         char *name;
  99
 100 } acpi_handler_info;
 101
 102 static struct acpi_handler_info acpi_gbl_handler_list[] = {
 103         {&acpi_gbl_global_notify[0].handler, "System Notifications"},
 104         {&acpi_gbl_global_notify[1].handler, "Device Notifications"},
 105         {&acpi_gbl_table_handler, "ACPI Table Events"},
 106         {&acpi_gbl_exception_handler, "Control Method Exceptions"},
 107         {&acpi_gbl_interface_handler, "OSI Invocations"}
 108 };
 109
 110 /*******************************************************************************
 111  *
 112  * FUNCTION:    acpi_db_get_pointer
 113  *
 114  * PARAMETERS:  target          - Pointer to string to be converted
 115  *
 116  * RETURN:      Converted pointer
 117  *
 118  * DESCRIPTION: Convert an ascii pointer value to a real value
 119  *
 120  ******************************************************************************/
 121
 122 static void *acpi_db_get_pointer(void *target)
 123 {
 124         void *obj_ptr;
 125         acpi_size address;
 126
 127         address = strtoul(target, NULL, 16);
 128         obj_ptr = ACPI_TO_POINTER(address);
 129         return (obj_ptr);
 130 }
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    acpi_db_dump_parser_descriptor
 135  *
 136  * PARAMETERS:  op              - A parser Op descriptor
 137  *
 138  * RETURN:      None
 139  *
 140  * DESCRIPTION: Display a formatted parser object
 141  *
 142  ******************************************************************************/
 143
 144 static void acpi_db_dump_parser_descriptor(union acpi_parse_object *op)
 145 {
 146         const struct acpi_opcode_info *info;
 147
 148         info = acpi_ps_get_opcode_info(op->common.aml_opcode);
 149
 150         acpi_os_printf("Parser Op Descriptor:\n");
 151         acpi_os_printf("%20.20s : %4.4X\n", "Opcode", op->common.aml_opcode);
 152
 153         ACPI_DEBUG_ONLY_MEMBERS(acpi_os_printf("%20.20s : %s\n", "Opcode Name",
 154                                                info->name));
 155
 156         acpi_os_printf("%20.20s : %p\n", "Value/ArgList", op->common.value.arg);
 157         acpi_os_printf("%20.20s : %p\n", "Parent", op->common.parent);
 158         acpi_os_printf("%20.20s : %p\n", "NextOp", op->common.next);
 159 }
 160
 161 /*******************************************************************************
 162  *
 163  * FUNCTION:    acpi_db_decode_and_display_object
 164  *
 165  * PARAMETERS:  target          - String with object to be displayed. Names
 166  *                                and hex pointers are supported.
 167  *              output_type     - Byte, Word, Dword, or Qword (B|W|D|Q)
 168  *
 169  * RETURN:      None
 170  *
 171  * DESCRIPTION: Display a formatted ACPI object
 172  *
 173  ******************************************************************************/
 174
 175 void acpi_db_decode_and_display_object(char *target, char *output_type)
 176 {
 177         void *obj_ptr;
 178         struct acpi_namespace_node *node;
 179         union acpi_operand_object *obj_desc;
 180         u32 display = DB_BYTE_DISPLAY;
 181         char buffer[80];
 182         struct acpi_buffer ret_buf;
 183         acpi_status status;
 184         u32 size;
 185
 186         if (!target) {
 187                 return;
 188         }
 189
 190         /* Decode the output type */
 191
 192         if (output_type) {
 193                 acpi_ut_strupr(output_type);
 194                 if (output_type[0] == 'W') {
 195                         display = DB_WORD_DISPLAY;
 196                 } else if (output_type[0] == 'D') {
 197                         display = DB_DWORD_DISPLAY;
 198                 } else if (output_type[0] == 'Q') {
 199                         display = DB_QWORD_DISPLAY;
 200                 }
 201         }
 202
 203         ret_buf.length = sizeof(buffer);
 204         ret_buf.pointer = buffer;
 205
 206         /* Differentiate between a number and a name */
 207
 208         if ((target[0] >= 0x30) && (target[0] <= 0x39)) {
 209                 obj_ptr = acpi_db_get_pointer(target);
 210                 if (!acpi_os_readable(obj_ptr, 16)) {
 211                         acpi_os_printf
 212                             ("Address %p is invalid in this address space\n",
 213                              obj_ptr);
 214                         return;
 215                 }
 216
 217                 /* Decode the object type */
 218
 219                 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_ptr)) {
 220                 case ACPI_DESC_TYPE_NAMED:
 221
 222                         /* This is a namespace Node */
 223
 224                         if (!acpi_os_readable
 225                             (obj_ptr, sizeof(struct acpi_namespace_node))) {
 226                                 acpi_os_printf
 227                                     ("Cannot read entire Named object at address %p\n",
 228                                      obj_ptr);
 229                                 return;
 230                         }
 231
 232                         node = obj_ptr;
 233                         goto dump_node;
 234
 235                 case ACPI_DESC_TYPE_OPERAND:
 236
 237                         /* This is a ACPI OPERAND OBJECT */
 238
 239                         if (!acpi_os_readable
 240                             (obj_ptr, sizeof(union acpi_operand_object))) {
 241                                 acpi_os_printf
 242                                     ("Cannot read entire ACPI object at address %p\n",
 243                                      obj_ptr);
 244                                 return;
 245                         }
 246
 247                         acpi_ut_debug_dump_buffer(obj_ptr,
 248                                                   sizeof(union
 249                                                          acpi_operand_object),
 250                                                   display, ACPI_UINT32_MAX);
 251                         acpi_ex_dump_object_descriptor(obj_ptr, 1);
 252                         break;
 253
 254                 case ACPI_DESC_TYPE_PARSER:
 255
 256                         /* This is a Parser Op object */
 257
 258                         if (!acpi_os_readable
 259                             (obj_ptr, sizeof(union acpi_parse_object))) {
 260                                 acpi_os_printf
 261                                     ("Cannot read entire Parser object at address %p\n",
 262                                      obj_ptr);
 263                                 return;
 264                         }
 265
 266                         acpi_ut_debug_dump_buffer(obj_ptr,
 267                                                   sizeof(union
 268                                                          acpi_parse_object),
 269                                                   display, ACPI_UINT32_MAX);
 270                         acpi_db_dump_parser_descriptor((union acpi_parse_object
 271                                                         *)obj_ptr);
 272                         break;
 273
 274                 default:
 275
 276                         /* Is not a recognizeable object */
 277
 278                         acpi_os_printf
 279                             ("Not a known ACPI internal object, descriptor type %2.2X\n",
 280                              ACPI_GET_DESCRIPTOR_TYPE(obj_ptr));
 281
 282                         size = 16;
 283                         if (acpi_os_readable(obj_ptr, 64)) {
 284                                 size = 64;
 285                         }
 286
 287                         /* Just dump some memory */
 288
 289                         acpi_ut_debug_dump_buffer(obj_ptr, size, display,
 290                                                   ACPI_UINT32_MAX);
 291                         break;
 292                 }
 293
 294                 return;
 295         }
 296
 297         /* The parameter is a name string that must be resolved to a Named obj */
 298
 299         node = acpi_db_local_ns_lookup(target);
 300         if (!node) {
 301                 return;
 302         }
 303
 304 dump_node:
 305         /* Now dump the NS node */
 306
 307         status = acpi_get_name(node, ACPI_FULL_PATHNAME_NO_TRAILING, &ret_buf);
 308         if (ACPI_FAILURE(status)) {
 309                 acpi_os_printf("Could not convert name to pathname\n");
 310         }
 311
 312         else {
 313                 acpi_os_printf("Object %p: Namespace Node - Pathname: %s\n",
 314                                node, (char *)ret_buf.pointer);
 315         }
 316
 317         if (!acpi_os_readable(node, sizeof(struct acpi_namespace_node))) {
 318                 acpi_os_printf("Invalid Named object at address %p\n", node);
 319                 return;
 320         }
 321
 322         acpi_ut_debug_dump_buffer((void *)node,
 323                                   sizeof(struct acpi_namespace_node), display,
 324                                   ACPI_UINT32_MAX);
 325         acpi_ex_dump_namespace_node(node, 1);
 326
 327         obj_desc = acpi_ns_get_attached_object(node);
 328         if (obj_desc) {
 329                 acpi_os_printf("\nAttached Object %p:", obj_desc);
 330                 if (!acpi_os_readable
 331                     (obj_desc, sizeof(union acpi_operand_object))) {
 332                         acpi_os_printf
 333                             ("Invalid internal ACPI Object at address %p\n",
 334                              obj_desc);
 335                         return;
 336                 }
 337
 338                 if (ACPI_GET_DESCRIPTOR_TYPE(((struct acpi_namespace_node *)
 339                                               obj_desc)) ==
 340                     ACPI_DESC_TYPE_NAMED) {
 341                         acpi_os_printf(" Namespace Node - ");
 342                         status =
 343                             acpi_get_name((struct acpi_namespace_node *)
 344                                           obj_desc,
 345                                           ACPI_FULL_PATHNAME_NO_TRAILING,
 346                                           &ret_buf);
 347                         if (ACPI_FAILURE(status)) {
 348                                 acpi_os_printf
 349                                     ("Could not convert name to pathname\n");
 350                         } else {
 351                                 acpi_os_printf("Pathname: %s",
 352                                                (char *)ret_buf.pointer);
 353                         }
 354
 355                         acpi_os_printf("\n");
 356                         acpi_ut_debug_dump_buffer((void *)obj_desc,
 357                                                   sizeof(struct
 358                                                          acpi_namespace_node),
 359                                                   display, ACPI_UINT32_MAX);
 360                 } else {
 361                         acpi_os_printf("\n");
 362                         acpi_ut_debug_dump_buffer((void *)obj_desc,
 363                                                   sizeof(union
 364                                                          acpi_operand_object),
 365                                                   display, ACPI_UINT32_MAX);
 366                 }
 367
 368                 acpi_ex_dump_object_descriptor(obj_desc, 1);
 369         }
 370 }
 371
 372 /*******************************************************************************
 373  *
 374  * FUNCTION:    acpi_db_display_method_info
 375  *
 376  * PARAMETERS:  start_op        - Root of the control method parse tree
 377  *
 378  * RETURN:      None
 379  *
 380  * DESCRIPTION: Display information about the current method
 381  *
 382  ******************************************************************************/
 383
 384 void acpi_db_display_method_info(union acpi_parse_object *start_op)
 385 {
 386         struct acpi_walk_state *walk_state;
 387         union acpi_operand_object *obj_desc;
 388         struct acpi_namespace_node *node;
 389         union acpi_parse_object *root_op;
 390         union acpi_parse_object *op;
 391         const struct acpi_opcode_info *op_info;
 392         u32 num_ops = 0;
 393         u32 num_operands = 0;
 394         u32 num_operators = 0;
 395         u32 num_remaining_ops = 0;
 396         u32 num_remaining_operands = 0;
 397         u32 num_remaining_operators = 0;
 398         u8 count_remaining = FALSE;
 399
 400         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 401         if (!walk_state) {
 402                 acpi_os_printf("There is no method currently executing\n");
 403                 return;
 404         }
 405
 406         obj_desc = walk_state->method_desc;
 407         node = walk_state->method_node;
 408
 409         acpi_os_printf("Currently executing control method is [%4.4s]\n",
 410                        acpi_ut_get_node_name(node));
 411         acpi_os_printf("%X Arguments, SyncLevel = %X\n",
 412                        (u32)obj_desc->method.param_count,
 413                        (u32)obj_desc->method.sync_level);
 414
 415         root_op = start_op;
 416         while (root_op->common.parent) {
 417                 root_op = root_op->common.parent;
 418         }
 419
 420         op = root_op;
 421
 422         while (op) {
 423                 if (op == start_op) {
 424                         count_remaining = TRUE;
 425                 }
 426
 427                 num_ops++;
 428                 if (count_remaining) {
 429                         num_remaining_ops++;
 430                 }
 431
 432                 /* Decode the opcode */
 433
 434                 op_info = acpi_ps_get_opcode_info(op->common.aml_opcode);
 435                 switch (op_info->class) {
 436                 case AML_CLASS_ARGUMENT:
 437
 438                         if (count_remaining) {
 439                                 num_remaining_operands++;
 440                         }
 441
 442                         num_operands++;
 443                         break;
 444
 445                 case AML_CLASS_UNKNOWN:
 446
 447                         /* Bad opcode or ASCII character */
 448
 449                         continue;
 450
 451                 default:
 452
 453                         if (count_remaining) {
 454                                 num_remaining_operators++;
 455                         }
 456
 457                         num_operators++;
 458                         break;
 459                 }
 460
 461                 op = acpi_ps_get_depth_next(start_op, op);
 462         }
 463
 464         acpi_os_printf
 465             ("Method contains:       %X AML Opcodes - %X Operators, %X Operands\n",
 466              num_ops, num_operators, num_operands);
 467
 468         acpi_os_printf
 469             ("Remaining to execute:  %X AML Opcodes - %X Operators, %X Operands\n",
 470              num_remaining_ops, num_remaining_operators,
 471              num_remaining_operands);
 472 }
 473
 474 /*******************************************************************************
 475  *
 476  * FUNCTION:    acpi_db_display_locals
 477  *
 478  * PARAMETERS:  None
 479  *
 480  * RETURN:      None
 481  *
 482  * DESCRIPTION: Display all locals for the currently running control method
 483  *
 484  ******************************************************************************/
 485
 486 void acpi_db_display_locals(void)
 487 {
 488         struct acpi_walk_state *walk_state;
 489
 490         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 491         if (!walk_state) {
 492                 acpi_os_printf("There is no method currently executing\n");
 493                 return;
 494         }
 495
 496         acpi_db_decode_locals(walk_state);
 497 }
 498
 499 /*******************************************************************************
 500  *
 501  * FUNCTION:    acpi_db_display_arguments
 502  *
 503  * PARAMETERS:  None
 504  *
 505  * RETURN:      None
 506  *
 507  * DESCRIPTION: Display all arguments for the currently running control method
 508  *
 509  ******************************************************************************/
 510
 511 void acpi_db_display_arguments(void)
 512 {
 513         struct acpi_walk_state *walk_state;
 514
 515         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 516         if (!walk_state) {
 517                 acpi_os_printf("There is no method currently executing\n");
 518                 return;
 519         }
 520
 521         acpi_db_decode_arguments(walk_state);
 522 }
 523
 524 /*******************************************************************************
 525  *
 526  * FUNCTION:    acpi_db_display_results
 527  *
 528  * PARAMETERS:  None
 529  *
 530  * RETURN:      None
 531  *
 532  * DESCRIPTION: Display current contents of a method result stack
 533  *
 534  ******************************************************************************/
 535
 536 void acpi_db_display_results(void)
 537 {
 538         u32 i;
 539         struct acpi_walk_state *walk_state;
 540         union acpi_operand_object *obj_desc;
 541         u32 result_count = 0;
 542         struct acpi_namespace_node *node;
 543         union acpi_generic_state *frame;
 544         u32 index;              /* Index onto current frame */
 545
 546         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 547         if (!walk_state) {
 548                 acpi_os_printf("There is no method currently executing\n");
 549                 return;
 550         }
 551
 552         obj_desc = walk_state->method_desc;
 553         node = walk_state->method_node;
 554
 555         if (walk_state->results) {
 556                 result_count = walk_state->result_count;
 557         }
 558
 559         acpi_os_printf("Method [%4.4s] has %X stacked result objects\n",
 560                        acpi_ut_get_node_name(node), result_count);
 561
 562         /* From the top element of result stack */
 563
 564         frame = walk_state->results;
 565         index = (result_count - 1) % ACPI_RESULTS_FRAME_OBJ_NUM;
 566
 567         for (i = 0; i < result_count; i++) {
 568                 obj_desc = frame->results.obj_desc[index];
 569                 acpi_os_printf("Result%u: ", i);
 570                 acpi_db_display_internal_object(obj_desc, walk_state);
 571
 572                 if (index == 0) {
 573                         frame = frame->results.next;
 574                         index = ACPI_RESULTS_FRAME_OBJ_NUM;
 575                 }
 576
 577                 index--;
 578         }
 579 }
 580
 581 /*******************************************************************************
 582  *
 583  * FUNCTION:    acpi_db_display_calling_tree
 584  *
 585  * PARAMETERS:  None
 586  *
 587  * RETURN:      None
 588  *
 589  * DESCRIPTION: Display current calling tree of nested control methods
 590  *
 591  ******************************************************************************/
 592
 593 void acpi_db_display_calling_tree(void)
 594 {
 595         struct acpi_walk_state *walk_state;
 596         struct acpi_namespace_node *node;
 597
 598         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 599         if (!walk_state) {
 600                 acpi_os_printf("There is no method currently executing\n");
 601                 return;
 602         }
 603
 604         node = walk_state->method_node;
 605         acpi_os_printf("Current Control Method Call Tree\n");
 606
 607         while (walk_state) {
 608                 node = walk_state->method_node;
 609                 acpi_os_printf("  [%4.4s]\n", acpi_ut_get_node_name(node));
 610
 611                 walk_state = walk_state->next;
 612         }
 613 }
 614
 615 /*******************************************************************************
 616  *
 617  * FUNCTION:    acpi_db_display_object_type
 618  *
 619  * PARAMETERS:  object_arg      - User entered NS node handle
 620  *
 621  * RETURN:      None
 622  *
 623  * DESCRIPTION: Display type of an arbitrary NS node
 624  *
 625  ******************************************************************************/
 626
 627 void acpi_db_display_object_type(char *object_arg)
 628 {
 629         acpi_size arg;
 630         acpi_handle handle;
 631         struct acpi_device_info *info;
 632         acpi_status status;
 633         u32 i;
 634
 635         arg = strtoul(object_arg, NULL, 16);
 636         handle = ACPI_TO_POINTER(arg);
 637
 638         status = acpi_get_object_info(handle, &info);
 639         if (ACPI_FAILURE(status)) {
 640                 acpi_os_printf("Could not get object info, %s\n",
 641                                acpi_format_exception(status));
 642                 return;
 643         }
 644
 645         acpi_os_printf("ADR: %8.8X%8.8X, STA: %8.8X, Flags: %X\n",
 646                        ACPI_FORMAT_UINT64(info->address),
 647                        info->current_status, info->flags);
 648
 649         acpi_os_printf("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n",
 650                        info->highest_dstates[0], info->highest_dstates[1],
 651                        info->highest_dstates[2], info->highest_dstates[3]);
 652
 653         acpi_os_printf("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n",
 654                        info->lowest_dstates[0], info->lowest_dstates[1],
 655                        info->lowest_dstates[2], info->lowest_dstates[3],
 656                        info->lowest_dstates[4]);
 657
 658         if (info->valid & ACPI_VALID_HID) {
 659                 acpi_os_printf("HID: %s\n", info->hardware_id.string);
 660         }
 661
 662         if (info->valid & ACPI_VALID_UID) {
 663                 acpi_os_printf("UID: %s\n", info->unique_id.string);
 664         }
 665
 666         if (info->valid & ACPI_VALID_CID) {
 667                 for (i = 0; i < info->compatible_id_list.count; i++) {
 668                         acpi_os_printf("CID %u: %s\n", i,
 669                                        info->compatible_id_list.ids[i].string);
 670                 }
 671         }
 672
 673         ACPI_FREE(info);
 674 }
 675
 676 /*******************************************************************************
 677  *
 678  * FUNCTION:    acpi_db_display_result_object
 679  *
 680  * PARAMETERS:  obj_desc        - Object to be displayed
 681  *              walk_state      - Current walk state
 682  *
 683  * RETURN:      None
 684  *
 685  * DESCRIPTION: Display the result of an AML opcode
 686  *
 687  * Note: Curently only displays the result object if we are single stepping.
 688  * However, this output may be useful in other contexts and could be enabled
 689  * to do so if needed.
 690  *
 691  ******************************************************************************/
 692
 693 void
 694 acpi_db_display_result_object(union acpi_operand_object *obj_desc,
 695                               struct acpi_walk_state *walk_state)
 696 {
 697
 698 #ifndef ACPI_APPLICATION
 699         if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
 700                 return;
 701         }
 702 #endif
 703
 704         /* Only display if single stepping */
 705
 706         if (!acpi_gbl_cm_single_step) {
 707                 return;
 708         }
 709
 710         acpi_os_printf("ResultObj: ");
 711         acpi_db_display_internal_object(obj_desc, walk_state);
 712         acpi_os_printf("\n");
 713 }
 714
 715 /*******************************************************************************
 716  *
 717  * FUNCTION:    acpi_db_display_argument_object
 718  *
 719  * PARAMETERS:  obj_desc        - Object to be displayed
 720  *              walk_state      - Current walk state
 721  *
 722  * RETURN:      None
 723  *
 724  * DESCRIPTION: Display the result of an AML opcode
 725  *
 726  ******************************************************************************/
 727
 728 void
 729 acpi_db_display_argument_object(union acpi_operand_object *obj_desc,
 730                                 struct acpi_walk_state *walk_state)
 731 {
 732
 733 #ifndef ACPI_APPLICATION
 734         if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
 735                 return;
 736         }
 737 #endif
 738
 739         if (!acpi_gbl_cm_single_step) {
 740                 return;
 741         }
 742
 743         acpi_os_printf("ArgObj:  ");
 744         acpi_db_display_internal_object(obj_desc, walk_state);
 745 }
 746
 747 #if (!ACPI_REDUCED_HARDWARE)
 748 /*******************************************************************************
 749  *
 750  * FUNCTION:    acpi_db_display_gpes
 751  *
 752  * PARAMETERS:  None
 753  *
 754  * RETURN:      None
 755  *
 756  * DESCRIPTION: Display the current GPE structures
 757  *
 758  ******************************************************************************/
 759
 760 void acpi_db_display_gpes(void)
 761 {
 762         struct acpi_gpe_block_info *gpe_block;
 763         struct acpi_gpe_xrupt_info *gpe_xrupt_info;
 764         struct acpi_gpe_event_info *gpe_event_info;
 765         struct acpi_gpe_register_info *gpe_register_info;
 766         char *gpe_type;
 767         struct acpi_gpe_notify_info *notify;
 768         u32 gpe_index;
 769         u32 block = 0;
 770         u32 i;
 771         u32 j;
 772         u32 count;
 773         char buffer[80];
 774         struct acpi_buffer ret_buf;
 775         acpi_status status;
 776
 777         ret_buf.length = sizeof(buffer);
 778         ret_buf.pointer = buffer;
 779
 780         block = 0;
 781
 782         /* Walk the GPE lists */
 783
 784         gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
 785         while (gpe_xrupt_info) {
 786                 gpe_block = gpe_xrupt_info->gpe_block_list_head;
 787                 while (gpe_block) {
 788                         status = acpi_get_name(gpe_block->node,
 789                                                ACPI_FULL_PATHNAME_NO_TRAILING,
 790                                                &ret_buf);
 791                         if (ACPI_FAILURE(status)) {
 792                                 acpi_os_printf
 793                                     ("Could not convert name to pathname\n");
 794                         }
 795
 796                         if (gpe_block->node == acpi_gbl_fadt_gpe_device) {
 797                                 gpe_type = "FADT-defined GPE block";
 798                         } else {
 799                                 gpe_type = "GPE Block Device";
 800                         }
 801
 802                         acpi_os_printf
 803                             ("\nBlock %u - Info %p  DeviceNode %p [%s] - %s\n",
 804                              block, gpe_block, gpe_block->node, buffer,
 805                              gpe_type);
 806
 807                         acpi_os_printf("    Registers:    %u (%u GPEs)\n",
 808                                        gpe_block->register_count,
 809                                        gpe_block->gpe_count);
 810
 811                         acpi_os_printf
 812                             ("    GPE range:    0x%X to 0x%X on interrupt %u\n",
 813                              gpe_block->block_base_number,
 814                              gpe_block->block_base_number +
 815                              (gpe_block->gpe_count - 1),
 816                              gpe_xrupt_info->interrupt_number);
 817
 818                         acpi_os_printf
 819                             ("    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 820                              gpe_block->register_info,
 821                              ACPI_FORMAT_UINT64(gpe_block->register_info->
 822                                                 status_address.address),
 823                              ACPI_FORMAT_UINT64(gpe_block->register_info->
 824                                                 enable_address.address));
 825
 826                         acpi_os_printf("  EventInfo:    %p\n",
 827                                        gpe_block->event_info);
 828
 829                         /* Examine each GPE Register within the block */
 830
 831                         for (i = 0; i < gpe_block->register_count; i++) {
 832                                 gpe_register_info =
 833                                     &gpe_block->register_info[i];
 834
 835                                 acpi_os_printf("    Reg %u: (GPE %.2X-%.2X)  "
 836                                                "RunEnable %2.2X WakeEnable %2.2X"
 837                                                " Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 838                                                i,
 839                                                gpe_register_info->
 840                                                base_gpe_number,
 841                                                gpe_register_info->
 842                                                base_gpe_number +
 843                                                (ACPI_GPE_REGISTER_WIDTH - 1),
 844                                                gpe_register_info->
 845                                                enable_for_run,
 846                                                gpe_register_info->
 847                                                enable_for_wake,
 848                                                ACPI_FORMAT_UINT64
 849                                                (gpe_register_info->
 850                                                 status_address.address),
 851                                                ACPI_FORMAT_UINT64
 852                                                (gpe_register_info->
 853                                                 enable_address.address));
 854
 855                                 /* Now look at the individual GPEs in this byte register */
 856
 857                                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 858                                         gpe_index =
 859                                             (i * ACPI_GPE_REGISTER_WIDTH) + j;
 860                                         gpe_event_info =
 861                                             &gpe_block->event_info[gpe_index];
 862
 863                                         if (ACPI_GPE_DISPATCH_TYPE
 864                                             (gpe_event_info->flags) ==
 865                                             ACPI_GPE_DISPATCH_NONE) {
 866
 867                                                 /* This GPE is not used (no method or handler), ignore it */
 868
 869                                                 continue;
 870                                         }
 871
 872                                         acpi_os_printf
 873                                             ("        GPE %.2X: %p  RunRefs %2.2X Flags %2.2X (",
 874                                              gpe_block->block_base_number +
 875                                              gpe_index, gpe_event_info,
 876                                              gpe_event_info->runtime_count,
 877                                              gpe_event_info->flags);
 878
 879                                         /* Decode the flags byte */
 880
 881                                         if (gpe_event_info->
 882                                             flags & ACPI_GPE_LEVEL_TRIGGERED) {
 883                                                 acpi_os_printf("Level, ");
 884                                         } else {
 885                                                 acpi_os_printf("Edge, ");
 886                                         }
 887
 888                                         if (gpe_event_info->
 889                                             flags & ACPI_GPE_CAN_WAKE) {
 890                                                 acpi_os_printf("CanWake, ");
 891                                         } else {
 892                                                 acpi_os_printf("RunOnly, ");
 893                                         }
 894
 895                                         switch (ACPI_GPE_DISPATCH_TYPE
 896                                                 (gpe_event_info->flags)) {
 897                                         case ACPI_GPE_DISPATCH_NONE:
 898
 899                                                 acpi_os_printf("NotUsed");
 900                                                 break;
 901
 902                                         case ACPI_GPE_DISPATCH_METHOD:
 903
 904                                                 acpi_os_printf("Method");
 905                                                 break;
 906
 907                                         case ACPI_GPE_DISPATCH_HANDLER:
 908
 909                                                 acpi_os_printf("Handler");
 910                                                 break;
 911
 912                                         case ACPI_GPE_DISPATCH_NOTIFY:
 913
 914                                                 count = 0;
 915                                                 notify =
 916                                                     gpe_event_info->dispatch.
 917                                                     notify_list;
 918                                                 while (notify) {
 919                                                         count++;
 920                                                         notify = notify->next;
 921                                                 }
 922
 923                                                 acpi_os_printf
 924                                                     ("Implicit Notify on %u devices",
 925                                                      count);
 926                                                 break;
 927
 928                                         case ACPI_GPE_DISPATCH_RAW_HANDLER:
 929
 930                                                 acpi_os_printf("RawHandler");
 931                                                 break;
 932
 933                                         default:
 934
 935                                                 acpi_os_printf("UNKNOWN: %X",
 936                                                                ACPI_GPE_DISPATCH_TYPE
 937                                                                (gpe_event_info->
 938                                                                 flags));
 939                                                 break;
 940                                         }
 941
 942                                         acpi_os_printf(")\n");
 943                                 }
 944                         }
 945
 946                         block++;
 947                         gpe_block = gpe_block->next;
 948                 }
 949
 950                 gpe_xrupt_info = gpe_xrupt_info->next;
 951         }
 952 }
 953 #endif                          /* !ACPI_REDUCED_HARDWARE */
 954
 955 /*******************************************************************************
 956  *
 957  * FUNCTION:    acpi_db_display_handlers
 958  *
 959  * PARAMETERS:  None
 960  *
 961  * RETURN:      None
 962  *
 963  * DESCRIPTION: Display the currently installed global handlers
 964  *
 965  ******************************************************************************/
 966
 967 void acpi_db_display_handlers(void)
 968 {
 969         union acpi_operand_object *obj_desc;
 970         union acpi_operand_object *handler_obj;
 971         acpi_adr_space_type space_id;
 972         u32 i;
 973
 974         /* Operation region handlers */
 975
 976         acpi_os_printf("\nOperation Region Handlers at the namespace root:\n");
 977
 978         obj_desc = acpi_ns_get_attached_object(acpi_gbl_root_node);
 979         if (obj_desc) {
 980                 for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_space_id_list); i++) {
 981                         space_id = acpi_gbl_space_id_list[i];
 982
 983                         acpi_os_printf(ACPI_PREDEFINED_PREFIX,
 984                                        acpi_ut_get_region_name((u8)space_id),
 985                                        space_id);
 986
 987                         handler_obj =
 988                             acpi_ev_find_region_handler(space_id,
 989                                                         obj_desc->common_notify.
 990                                                         handler);
 991                         if (handler_obj) {
 992                                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING,
 993                                                (handler_obj->address_space.
 994                                                 handler_flags &
 995                                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
 996                                                ? "Default" : "User",
 997                                                handler_obj->address_space.
 998                                                handler);
 999
1000                                 goto found_handler;
1001                         }
1002
1003                         /* There is no handler for this space_id */
1004
1005                         acpi_os_printf("None\n");
1006
1007 found_handler:          ;
1008                 }
1009
1010                 /* Find all handlers for user-defined space_IDs */
1011
1012                 handler_obj = obj_desc->common_notify.handler;
1013                 while (handler_obj) {
1014                         if (handler_obj->address_space.space_id >=
1015                             ACPI_USER_REGION_BEGIN) {
1016                                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
1017                                                "User-defined ID",
1018                                                handler_obj->address_space.
1019                                                space_id);
1020                                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING,
1021                                                (handler_obj->address_space.
1022                                                 handler_flags &
1023                                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
1024                                                ? "Default" : "User",
1025                                                handler_obj->address_space.
1026                                                handler);
1027                         }
1028
1029                         handler_obj = handler_obj->address_space.next;
1030                 }
1031         }
1032 #if (!ACPI_REDUCED_HARDWARE)
1033
1034         /* Fixed event handlers */
1035
1036         acpi_os_printf("\nFixed Event Handlers:\n");
1037
1038         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
1039                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
1040                                acpi_ut_get_event_name(i), i);
1041                 if (acpi_gbl_fixed_event_handlers[i].handler) {
1042                         acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User",
1043                                        acpi_gbl_fixed_event_handlers[i].
1044                                        handler);
1045                 } else {
1046                         acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1047                 }
1048         }
1049
1050 #endif                          /* !ACPI_REDUCED_HARDWARE */
1051
1052         /* Miscellaneous global handlers */
1053
1054         acpi_os_printf("\nMiscellaneous Global Handlers:\n");
1055
1056         for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_handler_list); i++) {
1057                 acpi_os_printf(ACPI_HANDLER_NAME_STRING,
1058                                acpi_gbl_handler_list[i].name);
1059
1060                 if (acpi_gbl_handler_list[i].handler) {
1061                         acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User",
1062                                        acpi_gbl_handler_list[i].handler);
1063                 } else {
1064                         acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1065                 }
1066         }
1067
1068         /* Other handlers that are installed throughout the namespace */
1069
1070         acpi_os_printf("\nOperation Region Handlers for specific devices:\n");
1071
1072         (void)acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1073                                   ACPI_UINT32_MAX,
1074                                   acpi_db_display_non_root_handlers, NULL, NULL,
1075                                   NULL);
1076 }
1077
1078 /*******************************************************************************
1079  *
1080  * FUNCTION:    acpi_db_display_non_root_handlers
1081  *
1082  * PARAMETERS:  acpi_walk_callback
1083  *
1084  * RETURN:      Status
1085  *
1086  * DESCRIPTION: Display information about all handlers installed for a
1087  *              device object.
1088  *
1089  ******************************************************************************/
1090
1091 static acpi_status
1092 acpi_db_display_non_root_handlers(acpi_handle obj_handle,
1093                                   u32 nesting_level,
1094                                   void *context, void **return_value)
1095 {
1096         struct acpi_namespace_node *node =
1097             ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
1098         union acpi_operand_object *obj_desc;
1099         union acpi_operand_object *handler_obj;
1100         char *pathname;
1101
1102         obj_desc = acpi_ns_get_attached_object(node);
1103         if (!obj_desc) {
1104                 return (AE_OK);
1105         }
1106
1107         pathname = acpi_ns_get_normalized_pathname(node, TRUE);
1108         if (!pathname) {
1109                 return (AE_OK);
1110         }
1111
1112         /* Display all handlers associated with this device */
1113
1114         handler_obj = obj_desc->common_notify.handler;
1115         while (handler_obj) {
1116                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
1117                                acpi_ut_get_region_name((u8)handler_obj->
1118                                                        address_space.space_id),
1119                                handler_obj->address_space.space_id);
1120
1121                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING2,
1122                                (handler_obj->address_space.handler_flags &
1123                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default"
1124                                : "User", handler_obj->address_space.handler);
1125
1126                 acpi_os_printf(" Device Name: %s (%p)\n", pathname, node);
1127
1128                 handler_obj = handler_obj->address_space.next;
1129         }
1130
1131         ACPI_FREE(pathname);
1132         return (AE_OK);
1133 }