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