drivers/acpi/acpica/dbdisply.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbdisply - debug display commands
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, 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) 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):\n", 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                 acpi_ut_debug_dump_buffer((void *)obj_desc,
 339                                           sizeof(union acpi_operand_object),
 340                                           display, ACPI_UINT32_MAX);
 341                 acpi_ex_dump_object_descriptor(obj_desc, 1);
 342         }
 343 }
 344
 345 /*******************************************************************************
 346  *
 347  * FUNCTION:    acpi_db_display_method_info
 348  *
 349  * PARAMETERS:  start_op        - Root of the control method parse tree
 350  *
 351  * RETURN:      None
 352  *
 353  * DESCRIPTION: Display information about the current method
 354  *
 355  ******************************************************************************/
 356
 357 void acpi_db_display_method_info(union acpi_parse_object *start_op)
 358 {
 359         struct acpi_walk_state *walk_state;
 360         union acpi_operand_object *obj_desc;
 361         struct acpi_namespace_node *node;
 362         union acpi_parse_object *root_op;
 363         union acpi_parse_object *op;
 364         const struct acpi_opcode_info *op_info;
 365         u32 num_ops = 0;
 366         u32 num_operands = 0;
 367         u32 num_operators = 0;
 368         u32 num_remaining_ops = 0;
 369         u32 num_remaining_operands = 0;
 370         u32 num_remaining_operators = 0;
 371         u8 count_remaining = FALSE;
 372
 373         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 374         if (!walk_state) {
 375                 acpi_os_printf("There is no method currently executing\n");
 376                 return;
 377         }
 378
 379         obj_desc = walk_state->method_desc;
 380         node = walk_state->method_node;
 381
 382         acpi_os_printf("Currently executing control method is [%4.4s]\n",
 383                        acpi_ut_get_node_name(node));
 384         acpi_os_printf("%X Arguments, SyncLevel = %X\n",
 385                        (u32)obj_desc->method.param_count,
 386                        (u32)obj_desc->method.sync_level);
 387
 388         root_op = start_op;
 389         while (root_op->common.parent) {
 390                 root_op = root_op->common.parent;
 391         }
 392
 393         op = root_op;
 394
 395         while (op) {
 396                 if (op == start_op) {
 397                         count_remaining = TRUE;
 398                 }
 399
 400                 num_ops++;
 401                 if (count_remaining) {
 402                         num_remaining_ops++;
 403                 }
 404
 405                 /* Decode the opcode */
 406
 407                 op_info = acpi_ps_get_opcode_info(op->common.aml_opcode);
 408                 switch (op_info->class) {
 409                 case AML_CLASS_ARGUMENT:
 410
 411                         if (count_remaining) {
 412                                 num_remaining_operands++;
 413                         }
 414
 415                         num_operands++;
 416                         break;
 417
 418                 case AML_CLASS_UNKNOWN:
 419
 420                         /* Bad opcode or ASCII character */
 421
 422                         continue;
 423
 424                 default:
 425
 426                         if (count_remaining) {
 427                                 num_remaining_operators++;
 428                         }
 429
 430                         num_operators++;
 431                         break;
 432                 }
 433
 434                 op = acpi_ps_get_depth_next(start_op, op);
 435         }
 436
 437         acpi_os_printf
 438             ("Method contains:       %X AML Opcodes - %X Operators, %X Operands\n",
 439              num_ops, num_operators, num_operands);
 440
 441         acpi_os_printf
 442             ("Remaining to execute:  %X AML Opcodes - %X Operators, %X Operands\n",
 443              num_remaining_ops, num_remaining_operators,
 444              num_remaining_operands);
 445 }
 446
 447 /*******************************************************************************
 448  *
 449  * FUNCTION:    acpi_db_display_locals
 450  *
 451  * PARAMETERS:  None
 452  *
 453  * RETURN:      None
 454  *
 455  * DESCRIPTION: Display all locals for the currently running control method
 456  *
 457  ******************************************************************************/
 458
 459 void acpi_db_display_locals(void)
 460 {
 461         struct acpi_walk_state *walk_state;
 462
 463         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 464         if (!walk_state) {
 465                 acpi_os_printf("There is no method currently executing\n");
 466                 return;
 467         }
 468
 469         acpi_db_decode_locals(walk_state);
 470 }
 471
 472 /*******************************************************************************
 473  *
 474  * FUNCTION:    acpi_db_display_arguments
 475  *
 476  * PARAMETERS:  None
 477  *
 478  * RETURN:      None
 479  *
 480  * DESCRIPTION: Display all arguments for the currently running control method
 481  *
 482  ******************************************************************************/
 483
 484 void acpi_db_display_arguments(void)
 485 {
 486         struct acpi_walk_state *walk_state;
 487
 488         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 489         if (!walk_state) {
 490                 acpi_os_printf("There is no method currently executing\n");
 491                 return;
 492         }
 493
 494         acpi_db_decode_arguments(walk_state);
 495 }
 496
 497 /*******************************************************************************
 498  *
 499  * FUNCTION:    acpi_db_display_results
 500  *
 501  * PARAMETERS:  None
 502  *
 503  * RETURN:      None
 504  *
 505  * DESCRIPTION: Display current contents of a method result stack
 506  *
 507  ******************************************************************************/
 508
 509 void acpi_db_display_results(void)
 510 {
 511         u32 i;
 512         struct acpi_walk_state *walk_state;
 513         union acpi_operand_object *obj_desc;
 514         u32 result_count = 0;
 515         struct acpi_namespace_node *node;
 516         union acpi_generic_state *frame;
 517         u32 index;              /* Index onto current frame */
 518
 519         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 520         if (!walk_state) {
 521                 acpi_os_printf("There is no method currently executing\n");
 522                 return;
 523         }
 524
 525         obj_desc = walk_state->method_desc;
 526         node = walk_state->method_node;
 527
 528         if (walk_state->results) {
 529                 result_count = walk_state->result_count;
 530         }
 531
 532         acpi_os_printf("Method [%4.4s] has %X stacked result objects\n",
 533                        acpi_ut_get_node_name(node), result_count);
 534
 535         /* From the top element of result stack */
 536
 537         frame = walk_state->results;
 538         index = (result_count - 1) % ACPI_RESULTS_FRAME_OBJ_NUM;
 539
 540         for (i = 0; i < result_count; i++) {
 541                 obj_desc = frame->results.obj_desc[index];
 542                 acpi_os_printf("Result%u: ", i);
 543                 acpi_db_display_internal_object(obj_desc, walk_state);
 544
 545                 if (index == 0) {
 546                         frame = frame->results.next;
 547                         index = ACPI_RESULTS_FRAME_OBJ_NUM;
 548                 }
 549
 550                 index--;
 551         }
 552 }
 553
 554 /*******************************************************************************
 555  *
 556  * FUNCTION:    acpi_db_display_calling_tree
 557  *
 558  * PARAMETERS:  None
 559  *
 560  * RETURN:      None
 561  *
 562  * DESCRIPTION: Display current calling tree of nested control methods
 563  *
 564  ******************************************************************************/
 565
 566 void acpi_db_display_calling_tree(void)
 567 {
 568         struct acpi_walk_state *walk_state;
 569         struct acpi_namespace_node *node;
 570
 571         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 572         if (!walk_state) {
 573                 acpi_os_printf("There is no method currently executing\n");
 574                 return;
 575         }
 576
 577         node = walk_state->method_node;
 578         acpi_os_printf("Current Control Method Call Tree\n");
 579
 580         while (walk_state) {
 581                 node = walk_state->method_node;
 582                 acpi_os_printf("  [%4.4s]\n", acpi_ut_get_node_name(node));
 583
 584                 walk_state = walk_state->next;
 585         }
 586 }
 587
 588 /*******************************************************************************
 589  *
 590  * FUNCTION:    acpi_db_display_object_type
 591  *
 592  * PARAMETERS:  object_arg      - User entered NS node handle
 593  *
 594  * RETURN:      None
 595  *
 596  * DESCRIPTION: Display type of an arbitrary NS node
 597  *
 598  ******************************************************************************/
 599
 600 void acpi_db_display_object_type(char *object_arg)
 601 {
 602         acpi_size arg;
 603         acpi_handle handle;
 604         struct acpi_device_info *info;
 605         acpi_status status;
 606         u32 i;
 607
 608         arg = strtoul(object_arg, NULL, 16);
 609         handle = ACPI_TO_POINTER(arg);
 610
 611         status = acpi_get_object_info(handle, &info);
 612         if (ACPI_FAILURE(status)) {
 613                 acpi_os_printf("Could not get object info, %s\n",
 614                                acpi_format_exception(status));
 615                 return;
 616         }
 617
 618         acpi_os_printf("ADR: %8.8X%8.8X, STA: %8.8X, Flags: %X\n",
 619                        ACPI_FORMAT_UINT64(info->address),
 620                        info->current_status, info->flags);
 621
 622         acpi_os_printf("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n",
 623                        info->highest_dstates[0], info->highest_dstates[1],
 624                        info->highest_dstates[2], info->highest_dstates[3]);
 625
 626         acpi_os_printf("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n",
 627                        info->lowest_dstates[0], info->lowest_dstates[1],
 628                        info->lowest_dstates[2], info->lowest_dstates[3],
 629                        info->lowest_dstates[4]);
 630
 631         if (info->valid & ACPI_VALID_HID) {
 632                 acpi_os_printf("HID: %s\n", info->hardware_id.string);
 633         }
 634
 635         if (info->valid & ACPI_VALID_UID) {
 636                 acpi_os_printf("UID: %s\n", info->unique_id.string);
 637         }
 638
 639         if (info->valid & ACPI_VALID_CID) {
 640                 for (i = 0; i < info->compatible_id_list.count; i++) {
 641                         acpi_os_printf("CID %u: %s\n", i,
 642                                        info->compatible_id_list.ids[i].string);
 643                 }
 644         }
 645
 646         ACPI_FREE(info);
 647 }
 648
 649 /*******************************************************************************
 650  *
 651  * FUNCTION:    acpi_db_display_result_object
 652  *
 653  * PARAMETERS:  obj_desc        - Object to be displayed
 654  *              walk_state      - Current walk state
 655  *
 656  * RETURN:      None
 657  *
 658  * DESCRIPTION: Display the result of an AML opcode
 659  *
 660  * Note: Curently only displays the result object if we are single stepping.
 661  * However, this output may be useful in other contexts and could be enabled
 662  * to do so if needed.
 663  *
 664  ******************************************************************************/
 665
 666 void
 667 acpi_db_display_result_object(union acpi_operand_object *obj_desc,
 668                               struct acpi_walk_state *walk_state)
 669 {
 670
 671 #ifndef ACPI_APPLICATION
 672         if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
 673                 return;
 674         }
 675 #endif
 676
 677         /* Only display if single stepping */
 678
 679         if (!acpi_gbl_cm_single_step) {
 680                 return;
 681         }
 682
 683         acpi_os_printf("ResultObj: ");
 684         acpi_db_display_internal_object(obj_desc, walk_state);
 685         acpi_os_printf("\n");
 686 }
 687
 688 /*******************************************************************************
 689  *
 690  * FUNCTION:    acpi_db_display_argument_object
 691  *
 692  * PARAMETERS:  obj_desc        - Object to be displayed
 693  *              walk_state      - Current walk state
 694  *
 695  * RETURN:      None
 696  *
 697  * DESCRIPTION: Display the result of an AML opcode
 698  *
 699  ******************************************************************************/
 700
 701 void
 702 acpi_db_display_argument_object(union acpi_operand_object *obj_desc,
 703                                 struct acpi_walk_state *walk_state)
 704 {
 705
 706 #ifndef ACPI_APPLICATION
 707         if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
 708                 return;
 709         }
 710 #endif
 711
 712         if (!acpi_gbl_cm_single_step) {
 713                 return;
 714         }
 715
 716         acpi_os_printf("ArgObj:  ");
 717         acpi_db_display_internal_object(obj_desc, walk_state);
 718 }
 719
 720 #if (!ACPI_REDUCED_HARDWARE)
 721 /*******************************************************************************
 722  *
 723  * FUNCTION:    acpi_db_display_gpes
 724  *
 725  * PARAMETERS:  None
 726  *
 727  * RETURN:      None
 728  *
 729  * DESCRIPTION: Display the current GPE structures
 730  *
 731  ******************************************************************************/
 732
 733 void acpi_db_display_gpes(void)
 734 {
 735         struct acpi_gpe_block_info *gpe_block;
 736         struct acpi_gpe_xrupt_info *gpe_xrupt_info;
 737         struct acpi_gpe_event_info *gpe_event_info;
 738         struct acpi_gpe_register_info *gpe_register_info;
 739         char *gpe_type;
 740         struct acpi_gpe_notify_info *notify;
 741         u32 gpe_index;
 742         u32 block = 0;
 743         u32 i;
 744         u32 j;
 745         u32 count;
 746         char buffer[80];
 747         struct acpi_buffer ret_buf;
 748         acpi_status status;
 749
 750         ret_buf.length = sizeof(buffer);
 751         ret_buf.pointer = buffer;
 752
 753         block = 0;
 754
 755         /* Walk the GPE lists */
 756
 757         gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
 758         while (gpe_xrupt_info) {
 759                 gpe_block = gpe_xrupt_info->gpe_block_list_head;
 760                 while (gpe_block) {
 761                         status = acpi_get_name(gpe_block->node,
 762                                                ACPI_FULL_PATHNAME_NO_TRAILING,
 763                                                &ret_buf);
 764                         if (ACPI_FAILURE(status)) {
 765                                 acpi_os_printf
 766                                     ("Could not convert name to pathname\n");
 767                         }
 768
 769                         if (gpe_block->node == acpi_gbl_fadt_gpe_device) {
 770                                 gpe_type = "FADT-defined GPE block";
 771                         } else {
 772                                 gpe_type = "GPE Block Device";
 773                         }
 774
 775                         acpi_os_printf
 776                             ("\nBlock %u - Info %p  DeviceNode %p [%s] - %s\n",
 777                              block, gpe_block, gpe_block->node, buffer,
 778                              gpe_type);
 779
 780                         acpi_os_printf("    Registers:    %u (%u GPEs)\n",
 781                                        gpe_block->register_count,
 782                                        gpe_block->gpe_count);
 783
 784                         acpi_os_printf
 785                             ("    GPE range:    0x%X to 0x%X on interrupt %u\n",
 786                              gpe_block->block_base_number,
 787                              gpe_block->block_base_number +
 788                              (gpe_block->gpe_count - 1),
 789                              gpe_xrupt_info->interrupt_number);
 790
 791                         acpi_os_printf
 792                             ("    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 793                              gpe_block->register_info,
 794                              ACPI_FORMAT_UINT64(gpe_block->register_info->
 795                                                 status_address.address),
 796                              ACPI_FORMAT_UINT64(gpe_block->register_info->
 797                                                 enable_address.address));
 798
 799                         acpi_os_printf("  EventInfo:    %p\n",
 800                                        gpe_block->event_info);
 801
 802                         /* Examine each GPE Register within the block */
 803
 804                         for (i = 0; i < gpe_block->register_count; i++) {
 805                                 gpe_register_info =
 806                                     &gpe_block->register_info[i];
 807
 808                                 acpi_os_printf("    Reg %u: (GPE %.2X-%.2X)  "
 809                                                "RunEnable %2.2X WakeEnable %2.2X"
 810                                                " Status %8.8X%8.8X Enable %8.8X%8.8X\n",
 811                                                i,
 812                                                gpe_register_info->
 813                                                base_gpe_number,
 814                                                gpe_register_info->
 815                                                base_gpe_number +
 816                                                (ACPI_GPE_REGISTER_WIDTH - 1),
 817                                                gpe_register_info->
 818                                                enable_for_run,
 819                                                gpe_register_info->
 820                                                enable_for_wake,
 821                                                ACPI_FORMAT_UINT64
 822                                                (gpe_register_info->
 823                                                 status_address.address),
 824                                                ACPI_FORMAT_UINT64
 825                                                (gpe_register_info->
 826                                                 enable_address.address));
 827
 828                                 /* Now look at the individual GPEs in this byte register */
 829
 830                                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 831                                         gpe_index =
 832                                             (i * ACPI_GPE_REGISTER_WIDTH) + j;
 833                                         gpe_event_info =
 834                                             &gpe_block->event_info[gpe_index];
 835
 836                                         if (ACPI_GPE_DISPATCH_TYPE
 837                                             (gpe_event_info->flags) ==
 838                                             ACPI_GPE_DISPATCH_NONE) {
 839
 840                                                 /* This GPE is not used (no method or handler), ignore it */
 841
 842                                                 continue;
 843                                         }
 844
 845                                         acpi_os_printf
 846                                             ("        GPE %.2X: %p  RunRefs %2.2X Flags %2.2X (",
 847                                              gpe_block->block_base_number +
 848                                              gpe_index, gpe_event_info,
 849                                              gpe_event_info->runtime_count,
 850                                              gpe_event_info->flags);
 851
 852                                         /* Decode the flags byte */
 853
 854                                         if (gpe_event_info->
 855                                             flags & ACPI_GPE_LEVEL_TRIGGERED) {
 856                                                 acpi_os_printf("Level, ");
 857                                         } else {
 858                                                 acpi_os_printf("Edge, ");
 859                                         }
 860
 861                                         if (gpe_event_info->
 862                                             flags & ACPI_GPE_CAN_WAKE) {
 863                                                 acpi_os_printf("CanWake, ");
 864                                         } else {
 865                                                 acpi_os_printf("RunOnly, ");
 866                                         }
 867
 868                                         switch (ACPI_GPE_DISPATCH_TYPE
 869                                                 (gpe_event_info->flags)) {
 870                                         case ACPI_GPE_DISPATCH_NONE:
 871
 872                                                 acpi_os_printf("NotUsed");
 873                                                 break;
 874
 875                                         case ACPI_GPE_DISPATCH_METHOD:
 876
 877                                                 acpi_os_printf("Method");
 878                                                 break;
 879
 880                                         case ACPI_GPE_DISPATCH_HANDLER:
 881
 882                                                 acpi_os_printf("Handler");
 883                                                 break;
 884
 885                                         case ACPI_GPE_DISPATCH_NOTIFY:
 886
 887                                                 count = 0;
 888                                                 notify =
 889                                                     gpe_event_info->dispatch.
 890                                                     notify_list;
 891                                                 while (notify) {
 892                                                         count++;
 893                                                         notify = notify->next;
 894                                                 }
 895
 896                                                 acpi_os_printf
 897                                                     ("Implicit Notify on %u devices",
 898                                                      count);
 899                                                 break;
 900
 901                                         case ACPI_GPE_DISPATCH_RAW_HANDLER:
 902
 903                                                 acpi_os_printf("RawHandler");
 904                                                 break;
 905
 906                                         default:
 907
 908                                                 acpi_os_printf("UNKNOWN: %X",
 909                                                                ACPI_GPE_DISPATCH_TYPE
 910                                                                (gpe_event_info->
 911                                                                 flags));
 912                                                 break;
 913                                         }
 914
 915                                         acpi_os_printf(")\n");
 916                                 }
 917                         }
 918
 919                         block++;
 920                         gpe_block = gpe_block->next;
 921                 }
 922
 923                 gpe_xrupt_info = gpe_xrupt_info->next;
 924         }
 925 }
 926 #endif                          /* !ACPI_REDUCED_HARDWARE */
 927
 928 /*******************************************************************************
 929  *
 930  * FUNCTION:    acpi_db_display_handlers
 931  *
 932  * PARAMETERS:  None
 933  *
 934  * RETURN:      None
 935  *
 936  * DESCRIPTION: Display the currently installed global handlers
 937  *
 938  ******************************************************************************/
 939
 940 void acpi_db_display_handlers(void)
 941 {
 942         union acpi_operand_object *obj_desc;
 943         union acpi_operand_object *handler_obj;
 944         acpi_adr_space_type space_id;
 945         u32 i;
 946
 947         /* Operation region handlers */
 948
 949         acpi_os_printf("\nOperation Region Handlers at the namespace root:\n");
 950
 951         obj_desc = acpi_ns_get_attached_object(acpi_gbl_root_node);
 952         if (obj_desc) {
 953                 for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_space_id_list); i++) {
 954                         space_id = acpi_gbl_space_id_list[i];
 955
 956                         acpi_os_printf(ACPI_PREDEFINED_PREFIX,
 957                                        acpi_ut_get_region_name((u8)space_id),
 958                                        space_id);
 959
 960                         handler_obj =
 961                             acpi_ev_find_region_handler(space_id,
 962                                                         obj_desc->common_notify.
 963                                                         handler);
 964                         if (handler_obj) {
 965                                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING,
 966                                                (handler_obj->address_space.
 967                                                 handler_flags &
 968                                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
 969                                                ? "Default" : "User",
 970                                                handler_obj->address_space.
 971                                                handler);
 972
 973                                 goto found_handler;
 974                         }
 975
 976                         /* There is no handler for this space_id */
 977
 978                         acpi_os_printf("None\n");
 979
 980 found_handler:          ;
 981                 }
 982
 983                 /* Find all handlers for user-defined space_IDs */
 984
 985                 handler_obj = obj_desc->common_notify.handler;
 986                 while (handler_obj) {
 987                         if (handler_obj->address_space.space_id >=
 988                             ACPI_USER_REGION_BEGIN) {
 989                                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
 990                                                "User-defined ID",
 991                                                handler_obj->address_space.
 992                                                space_id);
 993                                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING,
 994                                                (handler_obj->address_space.
 995                                                 handler_flags &
 996                                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
 997                                                ? "Default" : "User",
 998                                                handler_obj->address_space.
 999                                                handler);
1000                         }
1001
1002                         handler_obj = handler_obj->address_space.next;
1003                 }
1004         }
1005 #if (!ACPI_REDUCED_HARDWARE)
1006
1007         /* Fixed event handlers */
1008
1009         acpi_os_printf("\nFixed Event Handlers:\n");
1010
1011         for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
1012                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
1013                                acpi_ut_get_event_name(i), i);
1014                 if (acpi_gbl_fixed_event_handlers[i].handler) {
1015                         acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User",
1016                                        acpi_gbl_fixed_event_handlers[i].
1017                                        handler);
1018                 } else {
1019                         acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1020                 }
1021         }
1022
1023 #endif                          /* !ACPI_REDUCED_HARDWARE */
1024
1025         /* Miscellaneous global handlers */
1026
1027         acpi_os_printf("\nMiscellaneous Global Handlers:\n");
1028
1029         for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_handler_list); i++) {
1030                 acpi_os_printf(ACPI_HANDLER_NAME_STRING,
1031                                acpi_gbl_handler_list[i].name);
1032
1033                 if (acpi_gbl_handler_list[i].handler) {
1034                         acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User",
1035                                        acpi_gbl_handler_list[i].handler);
1036                 } else {
1037                         acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None");
1038                 }
1039         }
1040
1041         /* Other handlers that are installed throughout the namespace */
1042
1043         acpi_os_printf("\nOperation Region Handlers for specific devices:\n");
1044
1045         (void)acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1046                                   ACPI_UINT32_MAX,
1047                                   acpi_db_display_non_root_handlers, NULL, NULL,
1048                                   NULL);
1049 }
1050
1051 /*******************************************************************************
1052  *
1053  * FUNCTION:    acpi_db_display_non_root_handlers
1054  *
1055  * PARAMETERS:  acpi_walk_callback
1056  *
1057  * RETURN:      Status
1058  *
1059  * DESCRIPTION: Display information about all handlers installed for a
1060  *              device object.
1061  *
1062  ******************************************************************************/
1063
1064 static acpi_status
1065 acpi_db_display_non_root_handlers(acpi_handle obj_handle,
1066                                   u32 nesting_level,
1067                                   void *context, void **return_value)
1068 {
1069         struct acpi_namespace_node *node =
1070             ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
1071         union acpi_operand_object *obj_desc;
1072         union acpi_operand_object *handler_obj;
1073         char *pathname;
1074
1075         obj_desc = acpi_ns_get_attached_object(node);
1076         if (!obj_desc) {
1077                 return (AE_OK);
1078         }
1079
1080         pathname = acpi_ns_get_normalized_pathname(node, TRUE);
1081         if (!pathname) {
1082                 return (AE_OK);
1083         }
1084
1085         /* Display all handlers associated with this device */
1086
1087         handler_obj = obj_desc->common_notify.handler;
1088         while (handler_obj) {
1089                 acpi_os_printf(ACPI_PREDEFINED_PREFIX,
1090                                acpi_ut_get_region_name((u8)handler_obj->
1091                                                        address_space.space_id),
1092                                handler_obj->address_space.space_id);
1093
1094                 acpi_os_printf(ACPI_HANDLER_PRESENT_STRING2,
1095                                (handler_obj->address_space.handler_flags &
1096                                 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default"
1097                                : "User", handler_obj->address_space.handler);
1098
1099                 acpi_os_printf(" Device Name: %s (%p)\n", pathname, node);
1100
1101                 handler_obj = handler_obj->address_space.next;
1102         }
1103
1104         ACPI_FREE(pathname);
1105         return (AE_OK);
1106 }