Pileus Git - ~andy/linux/blob - drivers/acpi/acpica/nsdump.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsdump - table dumping routines for debug
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 "acnamesp.h"
  47 #include <acpi/acoutput.h>
  48
  49 #define _COMPONENT          ACPI_NAMESPACE
  50 ACPI_MODULE_NAME("nsdump")
  51
  52 /* Local prototypes */
  53 #ifdef ACPI_OBSOLETE_FUNCTIONS
  54 void acpi_ns_dump_root_devices(void);
  55
  56 static acpi_status
  57 acpi_ns_dump_one_device(acpi_handle obj_handle,
  58                         u32 level, void *context, void **return_value);
  59 #endif
  60
  61 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
  62 /*******************************************************************************
  63  *
  64  * FUNCTION:    acpi_ns_print_pathname
  65  *
  66  * PARAMETERS:  num_segments        - Number of ACPI name segments
  67  *              pathname            - The compressed (internal) path
  68  *
  69  * RETURN:      None
  70  *
  71  * DESCRIPTION: Print an object's full namespace pathname
  72  *
  73  ******************************************************************************/
  74
  75 void acpi_ns_print_pathname(u32 num_segments, char *pathname)
  76 {
  77         u32 i;
  78
  79         ACPI_FUNCTION_NAME(ns_print_pathname);
  80
  81         /* Check if debug output enabled */
  82
  83         if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_NAMES, ACPI_NAMESPACE)) {
  84                 return;
  85         }
  86
  87         /* Print the entire name */
  88
  89         ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "["));
  90
  91         while (num_segments) {
  92                 for (i = 0; i < 4; i++) {
  93                         ACPI_IS_PRINT(pathname[i]) ?
  94                             acpi_os_printf("%c", pathname[i]) :
  95                             acpi_os_printf("?");
  96                 }
  97
  98                 pathname += ACPI_NAME_SIZE;
  99                 num_segments--;
 100                 if (num_segments) {
 101                         acpi_os_printf(".");
 102                 }
 103         }
 104
 105         acpi_os_printf("]\n");
 106 }
 107
 108 /*******************************************************************************
 109  *
 110  * FUNCTION:    acpi_ns_dump_pathname
 111  *
 112  * PARAMETERS:  handle              - Object
 113  *              msg                 - Prefix message
 114  *              level               - Desired debug level
 115  *              component           - Caller's component ID
 116  *
 117  * RETURN:      None
 118  *
 119  * DESCRIPTION: Print an object's full namespace pathname
 120  *              Manages allocation/freeing of a pathname buffer
 121  *
 122  ******************************************************************************/
 123
 124 void
 125 acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component)
 126 {
 127
 128         ACPI_FUNCTION_TRACE(ns_dump_pathname);
 129
 130         /* Do this only if the requested debug level and component are enabled */
 131
 132         if (!ACPI_IS_DEBUG_ENABLED(level, component)) {
 133                 return_VOID;
 134         }
 135
 136         /* Convert handle to a full pathname and print it (with supplied message) */
 137
 138         acpi_ns_print_node_pathname(handle, msg);
 139         acpi_os_printf("\n");
 140         return_VOID;
 141 }
 142
 143 /*******************************************************************************
 144  *
 145  * FUNCTION:    acpi_ns_dump_one_object
 146  *
 147  * PARAMETERS:  obj_handle          - Node to be dumped
 148  *              level               - Nesting level of the handle
 149  *              context             - Passed into walk_namespace
 150  *              return_value        - Not used
 151  *
 152  * RETURN:      Status
 153  *
 154  * DESCRIPTION: Dump a single Node
 155  *              This procedure is a user_function called by acpi_ns_walk_namespace.
 156  *
 157  ******************************************************************************/
 158
 159 acpi_status
 160 acpi_ns_dump_one_object(acpi_handle obj_handle,
 161                         u32 level, void *context, void **return_value)
 162 {
 163         struct acpi_walk_info *info = (struct acpi_walk_info *)context;
 164         struct acpi_namespace_node *this_node;
 165         union acpi_operand_object *obj_desc = NULL;
 166         acpi_object_type obj_type;
 167         acpi_object_type type;
 168         u32 bytes_to_dump;
 169         u32 dbg_level;
 170         u32 i;
 171
 172         ACPI_FUNCTION_NAME(ns_dump_one_object);
 173
 174         /* Is output enabled? */
 175
 176         if (!(acpi_dbg_level & info->debug_level)) {
 177                 return (AE_OK);
 178         }
 179
 180         if (!obj_handle) {
 181                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Null object handle\n"));
 182                 return (AE_OK);
 183         }
 184
 185         this_node = acpi_ns_validate_handle(obj_handle);
 186         if (!this_node) {
 187                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid object handle %p\n",
 188                                   obj_handle));
 189                 return (AE_OK);
 190         }
 191
 192         type = this_node->type;
 193
 194         /* Check if the owner matches */
 195
 196         if ((info->owner_id != ACPI_OWNER_ID_MAX) &&
 197             (info->owner_id != this_node->owner_id)) {
 198                 return (AE_OK);
 199         }
 200
 201         if (!(info->display_type & ACPI_DISPLAY_SHORT)) {
 202
 203                 /* Indent the object according to the level */
 204
 205                 acpi_os_printf("%2d%*s", (u32) level - 1, (int)level * 2, " ");
 206
 207                 /* Check the node type and name */
 208
 209                 if (type > ACPI_TYPE_LOCAL_MAX) {
 210                         ACPI_WARNING((AE_INFO,
 211                                       "Invalid ACPI Object Type 0x%08X", type));
 212                 }
 213
 214                 acpi_os_printf("%4.4s", acpi_ut_get_node_name(this_node));
 215         }
 216
 217         /* Now we can print out the pertinent information */
 218
 219         acpi_os_printf(" %-12s %p %2.2X ",
 220                        acpi_ut_get_type_name(type), this_node,
 221                        this_node->owner_id);
 222
 223         dbg_level = acpi_dbg_level;
 224         acpi_dbg_level = 0;
 225         obj_desc = acpi_ns_get_attached_object(this_node);
 226         acpi_dbg_level = dbg_level;
 227
 228         /* Temp nodes are those nodes created by a control method */
 229
 230         if (this_node->flags & ANOBJ_TEMPORARY) {
 231                 acpi_os_printf("(T) ");
 232         }
 233
 234         switch (info->display_type & ACPI_DISPLAY_MASK) {
 235         case ACPI_DISPLAY_SUMMARY:
 236
 237                 if (!obj_desc) {
 238
 239                         /* No attached object. Some types should always have an object */
 240
 241                         switch (type) {
 242                         case ACPI_TYPE_INTEGER:
 243                         case ACPI_TYPE_PACKAGE:
 244                         case ACPI_TYPE_BUFFER:
 245                         case ACPI_TYPE_STRING:
 246                         case ACPI_TYPE_METHOD:
 247                                 acpi_os_printf("<No attached object>");
 248                                 break;
 249
 250                         default:
 251                                 break;
 252                         }
 253
 254                         acpi_os_printf("\n");
 255                         return (AE_OK);
 256                 }
 257
 258                 switch (type) {
 259                 case ACPI_TYPE_PROCESSOR:
 260
 261                         acpi_os_printf("ID %02X Len %02X Addr %p\n",
 262                                        obj_desc->processor.proc_id,
 263                                        obj_desc->processor.length,
 264                                        ACPI_CAST_PTR(void,
 265                                                      obj_desc->processor.
 266                                                      address));
 267                         break;
 268
 269                 case ACPI_TYPE_DEVICE:
 270
 271                         acpi_os_printf("Notify Object: %p\n", obj_desc);
 272                         break;
 273
 274                 case ACPI_TYPE_METHOD:
 275
 276                         acpi_os_printf("Args %X Len %.4X Aml %p\n",
 277                                        (u32) obj_desc->method.param_count,
 278                                        obj_desc->method.aml_length,
 279                                        obj_desc->method.aml_start);
 280                         break;
 281
 282                 case ACPI_TYPE_INTEGER:
 283
 284                         acpi_os_printf("= %8.8X%8.8X\n",
 285                                        ACPI_FORMAT_UINT64(obj_desc->integer.
 286                                                           value));
 287                         break;
 288
 289                 case ACPI_TYPE_PACKAGE:
 290
 291                         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
 292                                 acpi_os_printf("Elements %.2X\n",
 293                                                obj_desc->package.count);
 294                         } else {
 295                                 acpi_os_printf("[Length not yet evaluated]\n");
 296                         }
 297                         break;
 298
 299                 case ACPI_TYPE_BUFFER:
 300
 301                         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
 302                                 acpi_os_printf("Len %.2X",
 303                                                obj_desc->buffer.length);
 304
 305                                 /* Dump some of the buffer */
 306
 307                                 if (obj_desc->buffer.length > 0) {
 308                                         acpi_os_printf(" =");
 309                                         for (i = 0;
 310                                              (i < obj_desc->buffer.length
 311                                               && i < 12); i++) {
 312                                                 acpi_os_printf(" %.2hX",
 313                                                                obj_desc->buffer.
 314                                                                pointer[i]);
 315                                         }
 316                                 }
 317                                 acpi_os_printf("\n");
 318                         } else {
 319                                 acpi_os_printf("[Length not yet evaluated]\n");
 320                         }
 321                         break;
 322
 323                 case ACPI_TYPE_STRING:
 324
 325                         acpi_os_printf("Len %.2X ", obj_desc->string.length);
 326                         acpi_ut_print_string(obj_desc->string.pointer, 32);
 327                         acpi_os_printf("\n");
 328                         break;
 329
 330                 case ACPI_TYPE_REGION:
 331
 332                         acpi_os_printf("[%s]",
 333                                        acpi_ut_get_region_name(obj_desc->region.
 334                                                                space_id));
 335                         if (obj_desc->region.flags & AOPOBJ_DATA_VALID) {
 336                                 acpi_os_printf(" Addr %8.8X%8.8X Len %.4X\n",
 337                                                ACPI_FORMAT_NATIVE_UINT
 338                                                (obj_desc->region.address),
 339                                                obj_desc->region.length);
 340                         } else {
 341                                 acpi_os_printf
 342                                     (" [Address/Length not yet evaluated]\n");
 343                         }
 344                         break;
 345
 346                 case ACPI_TYPE_LOCAL_REFERENCE:
 347
 348                         acpi_os_printf("[%s]\n",
 349                                        acpi_ut_get_reference_name(obj_desc));
 350                         break;
 351
 352                 case ACPI_TYPE_BUFFER_FIELD:
 353
 354                         if (obj_desc->buffer_field.buffer_obj &&
 355                             obj_desc->buffer_field.buffer_obj->buffer.node) {
 356                                 acpi_os_printf("Buf [%4.4s]",
 357                                                acpi_ut_get_node_name(obj_desc->
 358                                                                      buffer_field.
 359                                                                      buffer_obj->
 360                                                                      buffer.
 361                                                                      node));
 362                         }
 363                         break;
 364
 365                 case ACPI_TYPE_LOCAL_REGION_FIELD:
 366
 367                         acpi_os_printf("Rgn [%4.4s]",
 368                                        acpi_ut_get_node_name(obj_desc->
 369                                                              common_field.
 370                                                              region_obj->region.
 371                                                              node));
 372                         break;
 373
 374                 case ACPI_TYPE_LOCAL_BANK_FIELD:
 375
 376                         acpi_os_printf("Rgn [%4.4s] Bnk [%4.4s]",
 377                                        acpi_ut_get_node_name(obj_desc->
 378                                                              common_field.
 379                                                              region_obj->region.
 380                                                              node),
 381                                        acpi_ut_get_node_name(obj_desc->
 382                                                              bank_field.
 383                                                              bank_obj->
 384                                                              common_field.
 385                                                              node));
 386                         break;
 387
 388                 case ACPI_TYPE_LOCAL_INDEX_FIELD:
 389
 390                         acpi_os_printf("Idx [%4.4s] Dat [%4.4s]",
 391                                        acpi_ut_get_node_name(obj_desc->
 392                                                              index_field.
 393                                                              index_obj->
 394                                                              common_field.node),
 395                                        acpi_ut_get_node_name(obj_desc->
 396                                                              index_field.
 397                                                              data_obj->
 398                                                              common_field.
 399                                                              node));
 400                         break;
 401
 402                 case ACPI_TYPE_LOCAL_ALIAS:
 403                 case ACPI_TYPE_LOCAL_METHOD_ALIAS:
 404
 405                         acpi_os_printf("Target %4.4s (%p)\n",
 406                                        acpi_ut_get_node_name(obj_desc),
 407                                        obj_desc);
 408                         break;
 409
 410                 default:
 411
 412                         acpi_os_printf("Object %p\n", obj_desc);
 413                         break;
 414                 }
 415
 416                 /* Common field handling */
 417
 418                 switch (type) {
 419                 case ACPI_TYPE_BUFFER_FIELD:
 420                 case ACPI_TYPE_LOCAL_REGION_FIELD:
 421                 case ACPI_TYPE_LOCAL_BANK_FIELD:
 422                 case ACPI_TYPE_LOCAL_INDEX_FIELD:
 423
 424                         acpi_os_printf(" Off %.3X Len %.2X Acc %.2hd\n",
 425                                        (obj_desc->common_field.
 426                                         base_byte_offset * 8)
 427                                        +
 428                                        obj_desc->common_field.
 429                                        start_field_bit_offset,
 430                                        obj_desc->common_field.bit_length,
 431                                        obj_desc->common_field.
 432                                        access_byte_width);
 433                         break;
 434
 435                 default:
 436                         break;
 437                 }
 438                 break;
 439
 440         case ACPI_DISPLAY_OBJECTS:
 441
 442                 acpi_os_printf("O:%p", obj_desc);
 443                 if (!obj_desc) {
 444
 445                         /* No attached object, we are done */
 446
 447                         acpi_os_printf("\n");
 448                         return (AE_OK);
 449                 }
 450
 451                 acpi_os_printf("(R%u)", obj_desc->common.reference_count);
 452
 453                 switch (type) {
 454                 case ACPI_TYPE_METHOD:
 455
 456                         /* Name is a Method and its AML offset/length are set */
 457
 458                         acpi_os_printf(" M:%p-%X\n", obj_desc->method.aml_start,
 459                                        obj_desc->method.aml_length);
 460                         break;
 461
 462                 case ACPI_TYPE_INTEGER:
 463
 464                         acpi_os_printf(" I:%8.8X8.8%X\n",
 465                                        ACPI_FORMAT_UINT64(obj_desc->integer.
 466                                                           value));
 467                         break;
 468
 469                 case ACPI_TYPE_STRING:
 470
 471                         acpi_os_printf(" S:%p-%X\n", obj_desc->string.pointer,
 472                                        obj_desc->string.length);
 473                         break;
 474
 475                 case ACPI_TYPE_BUFFER:
 476
 477                         acpi_os_printf(" B:%p-%X\n", obj_desc->buffer.pointer,
 478                                        obj_desc->buffer.length);
 479                         break;
 480
 481                 default:
 482
 483                         acpi_os_printf("\n");
 484                         break;
 485                 }
 486                 break;
 487
 488         default:
 489                 acpi_os_printf("\n");
 490                 break;
 491         }
 492
 493         /* If debug turned off, done */
 494
 495         if (!(acpi_dbg_level & ACPI_LV_VALUES)) {
 496                 return (AE_OK);
 497         }
 498
 499         /* If there is an attached object, display it */
 500
 501         dbg_level = acpi_dbg_level;
 502         acpi_dbg_level = 0;
 503         obj_desc = acpi_ns_get_attached_object(this_node);
 504         acpi_dbg_level = dbg_level;
 505
 506         /* Dump attached objects */
 507
 508         while (obj_desc) {
 509                 obj_type = ACPI_TYPE_INVALID;
 510                 acpi_os_printf("Attached Object %p: ", obj_desc);
 511
 512                 /* Decode the type of attached object and dump the contents */
 513
 514                 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
 515                 case ACPI_DESC_TYPE_NAMED:
 516
 517                         acpi_os_printf("(Ptr to Node)\n");
 518                         bytes_to_dump = sizeof(struct acpi_namespace_node);
 519                         ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
 520                         break;
 521
 522                 case ACPI_DESC_TYPE_OPERAND:
 523
 524                         obj_type = obj_desc->common.type;
 525
 526                         if (obj_type > ACPI_TYPE_LOCAL_MAX) {
 527                                 acpi_os_printf
 528                                     ("(Pointer to ACPI Object type %.2X [UNKNOWN])\n",
 529                                      obj_type);
 530                                 bytes_to_dump = 32;
 531                         } else {
 532                                 acpi_os_printf
 533                                     ("(Pointer to ACPI Object type %.2X [%s])\n",
 534                                      obj_type, acpi_ut_get_type_name(obj_type));
 535                                 bytes_to_dump =
 536                                     sizeof(union acpi_operand_object);
 537                         }
 538
 539                         ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
 540                         break;
 541
 542                 default:
 543
 544                         break;
 545                 }
 546
 547                 /* If value is NOT an internal object, we are done */
 548
 549                 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) !=
 550                     ACPI_DESC_TYPE_OPERAND) {
 551                         goto cleanup;
 552                 }
 553
 554                 /* Valid object, get the pointer to next level, if any */
 555
 556                 switch (obj_type) {
 557                 case ACPI_TYPE_BUFFER:
 558                 case ACPI_TYPE_STRING:
 559                         /*
 560                          * NOTE: takes advantage of common fields between string/buffer
 561                          */
 562                         bytes_to_dump = obj_desc->string.length;
 563                         obj_desc = (void *)obj_desc->string.pointer;
 564                         acpi_os_printf("(Buffer/String pointer %p length %X)\n",
 565                                        obj_desc, bytes_to_dump);
 566                         ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
 567                         goto cleanup;
 568
 569                 case ACPI_TYPE_BUFFER_FIELD:
 570                         obj_desc =
 571                             (union acpi_operand_object *)obj_desc->buffer_field.
 572                             buffer_obj;
 573                         break;
 574
 575                 case ACPI_TYPE_PACKAGE:
 576                         obj_desc = (void *)obj_desc->package.elements;
 577                         break;
 578
 579                 case ACPI_TYPE_METHOD:
 580                         obj_desc = (void *)obj_desc->method.aml_start;
 581                         break;
 582
 583                 case ACPI_TYPE_LOCAL_REGION_FIELD:
 584                         obj_desc = (void *)obj_desc->field.region_obj;
 585                         break;
 586
 587                 case ACPI_TYPE_LOCAL_BANK_FIELD:
 588                         obj_desc = (void *)obj_desc->bank_field.region_obj;
 589                         break;
 590
 591                 case ACPI_TYPE_LOCAL_INDEX_FIELD:
 592                         obj_desc = (void *)obj_desc->index_field.index_obj;
 593                         break;
 594
 595                 default:
 596                         goto cleanup;
 597                 }
 598
 599                 obj_type = ACPI_TYPE_INVALID;   /* Terminate loop after next pass */
 600         }
 601
 602       cleanup:
 603         acpi_os_printf("\n");
 604         return (AE_OK);
 605 }
 606
 607 #ifdef ACPI_FUTURE_USAGE
 608 /*******************************************************************************
 609  *
 610  * FUNCTION:    acpi_ns_dump_objects
 611  *
 612  * PARAMETERS:  type                - Object type to be dumped
 613  *              display_type        - 0 or ACPI_DISPLAY_SUMMARY
 614  *              max_depth           - Maximum depth of dump. Use ACPI_UINT32_MAX
 615  *                                    for an effectively unlimited depth.
 616  *              owner_id            - Dump only objects owned by this ID. Use
 617  *                                    ACPI_UINT32_MAX to match all owners.
 618  *              start_handle        - Where in namespace to start/end search
 619  *
 620  * RETURN:      None
 621  *
 622  * DESCRIPTION: Dump typed objects within the loaded namespace. Uses
 623  *              acpi_ns_walk_namespace in conjunction with acpi_ns_dump_one_object.
 624  *
 625  ******************************************************************************/
 626
 627 void
 628 acpi_ns_dump_objects(acpi_object_type type,
 629                      u8 display_type,
 630                      u32 max_depth,
 631                      acpi_owner_id owner_id, acpi_handle start_handle)
 632 {
 633         struct acpi_walk_info info;
 634         acpi_status status;
 635
 636         ACPI_FUNCTION_ENTRY();
 637
 638         /*
 639          * Just lock the entire namespace for the duration of the dump.
 640          * We don't want any changes to the namespace during this time,
 641          * especially the temporary nodes since we are going to display
 642          * them also.
 643          */
 644         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 645         if (ACPI_FAILURE(status)) {
 646                 acpi_os_printf("Could not acquire namespace mutex\n");
 647                 return;
 648         }
 649
 650         info.debug_level = ACPI_LV_TABLES;
 651         info.owner_id = owner_id;
 652         info.display_type = display_type;
 653
 654         (void)acpi_ns_walk_namespace(type, start_handle, max_depth,
 655                                      ACPI_NS_WALK_NO_UNLOCK |
 656                                      ACPI_NS_WALK_TEMP_NODES,
 657                                      acpi_ns_dump_one_object, NULL,
 658                                      (void *)&info, NULL);
 659
 660         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 661 }
 662 #endif                          /* ACPI_FUTURE_USAGE */
 663
 664 /*******************************************************************************
 665  *
 666  * FUNCTION:    acpi_ns_dump_entry
 667  *
 668  * PARAMETERS:  handle              - Node to be dumped
 669  *              debug_level         - Output level
 670  *
 671  * RETURN:      None
 672  *
 673  * DESCRIPTION: Dump a single Node
 674  *
 675  ******************************************************************************/
 676
 677 void acpi_ns_dump_entry(acpi_handle handle, u32 debug_level)
 678 {
 679         struct acpi_walk_info info;
 680
 681         ACPI_FUNCTION_ENTRY();
 682
 683         info.debug_level = debug_level;
 684         info.owner_id = ACPI_OWNER_ID_MAX;
 685         info.display_type = ACPI_DISPLAY_SUMMARY;
 686
 687         (void)acpi_ns_dump_one_object(handle, 1, &info, NULL);
 688 }
 689
 690 #ifdef ACPI_ASL_COMPILER
 691 /*******************************************************************************
 692  *
 693  * FUNCTION:    acpi_ns_dump_tables
 694  *
 695  * PARAMETERS:  search_base         - Root of subtree to be dumped, or
 696  *                                    NS_ALL to dump the entire namespace
 697  *              max_depth           - Maximum depth of dump. Use INT_MAX
 698  *                                    for an effectively unlimited depth.
 699  *
 700  * RETURN:      None
 701  *
 702  * DESCRIPTION: Dump the name space, or a portion of it.
 703  *
 704  ******************************************************************************/
 705
 706 void acpi_ns_dump_tables(acpi_handle search_base, u32 max_depth)
 707 {
 708         acpi_handle search_handle = search_base;
 709
 710         ACPI_FUNCTION_TRACE(ns_dump_tables);
 711
 712         if (!acpi_gbl_root_node) {
 713                 /*
 714                  * If the name space has not been initialized,
 715                  * there is nothing to dump.
 716                  */
 717                 ACPI_DEBUG_PRINT((ACPI_DB_TABLES,
 718                                   "namespace not initialized!\n"));
 719                 return_VOID;
 720         }
 721
 722         if (ACPI_NS_ALL == search_base) {
 723
 724                 /* Entire namespace */
 725
 726                 search_handle = acpi_gbl_root_node;
 727                 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "\\\n"));
 728         }
 729
 730         acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, max_depth,
 731                              ACPI_OWNER_ID_MAX, search_handle);
 732         return_VOID;
 733 }
 734 #endif
 735 #endif