Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6] / drivers / acpi / acpica / exdump.c
1 /******************************************************************************
2  *
3  * Module Name: exdump - Interpreter debug output routines
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acinterp.h"
47 #include "amlcode.h"
48 #include "acnamesp.h"
49
50 #define _COMPONENT          ACPI_EXECUTER
51 ACPI_MODULE_NAME("exdump")
52
53 /*
54  * The following routines are used for debug output only
55  */
56 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
57 /* Local prototypes */
58 static void acpi_ex_out_string(char *title, char *value);
59
60 static void acpi_ex_out_pointer(char *title, void *value);
61
62 static void
63 acpi_ex_dump_object(union acpi_operand_object *obj_desc,
64                     struct acpi_exdump_info *info);
65
66 static void acpi_ex_dump_reference_obj(union acpi_operand_object *obj_desc);
67
68 static void
69 acpi_ex_dump_package_obj(union acpi_operand_object *obj_desc,
70                          u32 level, u32 index);
71
72 /*******************************************************************************
73  *
74  * Object Descriptor info tables
75  *
76  * Note: The first table entry must be an INIT opcode and must contain
77  * the table length (number of table entries)
78  *
79  ******************************************************************************/
80
81 static struct acpi_exdump_info acpi_ex_dump_integer[2] = {
82         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_integer), NULL},
83         {ACPI_EXD_UINT64, ACPI_EXD_OFFSET(integer.value), "Value"}
84 };
85
86 static struct acpi_exdump_info acpi_ex_dump_string[4] = {
87         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_string), NULL},
88         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(string.length), "Length"},
89         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(string.pointer), "Pointer"},
90         {ACPI_EXD_STRING, 0, NULL}
91 };
92
93 static struct acpi_exdump_info acpi_ex_dump_buffer[5] = {
94         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_buffer), NULL},
95         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(buffer.length), "Length"},
96         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer.pointer), "Pointer"},
97         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer.node), "Parent Node"},
98         {ACPI_EXD_BUFFER, 0, NULL}
99 };
100
101 static struct acpi_exdump_info acpi_ex_dump_package[5] = {
102         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_package), NULL},
103         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(package.flags), "Flags"},
104         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(package.count), "Elements"},
105         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(package.elements), "Element List"},
106         {ACPI_EXD_PACKAGE, 0, NULL}
107 };
108
109 static struct acpi_exdump_info acpi_ex_dump_device[4] = {
110         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_device), NULL},
111         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.handler), "Handler"},
112         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.system_notify),
113          "System Notify"},
114         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(device.device_notify),
115          "Device Notify"}
116 };
117
118 static struct acpi_exdump_info acpi_ex_dump_event[2] = {
119         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_event), NULL},
120         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(event.os_semaphore), "OsSemaphore"}
121 };
122
123 static struct acpi_exdump_info acpi_ex_dump_method[8] = {
124         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_method), NULL},
125         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.param_count), "ParamCount"},
126         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.sync_level), "Sync Level"},
127         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.mutex), "Mutex"},
128         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.owner_id), "Owner Id"},
129         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.thread_count), "Thread Count"},
130         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(method.aml_length), "Aml Length"},
131         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.aml_start), "Aml Start"}
132 };
133
134 static struct acpi_exdump_info acpi_ex_dump_mutex[5] = {
135         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_mutex), NULL},
136         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(mutex.sync_level), "Sync Level"},
137         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.owner_thread), "Owner Thread"},
138         {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(mutex.acquisition_depth),
139          "Acquire Depth"},
140         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.os_mutex), "OsMutex"}
141 };
142
143 static struct acpi_exdump_info acpi_ex_dump_region[7] = {
144         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_region), NULL},
145         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(region.space_id), "Space Id"},
146         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(region.flags), "Flags"},
147         {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET(region.address), "Address"},
148         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(region.length), "Length"},
149         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(region.handler), "Handler"},
150         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(region.next), "Next"}
151 };
152
153 static struct acpi_exdump_info acpi_ex_dump_power[5] = {
154         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_power), NULL},
155         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(power_resource.system_level),
156          "System Level"},
157         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(power_resource.resource_order),
158          "Resource Order"},
159         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(power_resource.system_notify),
160          "System Notify"},
161         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(power_resource.device_notify),
162          "Device Notify"}
163 };
164
165 static struct acpi_exdump_info acpi_ex_dump_processor[7] = {
166         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_processor), NULL},
167         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(processor.proc_id), "Processor ID"},
168         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(processor.length), "Length"},
169         {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET(processor.address), "Address"},
170         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.system_notify),
171          "System Notify"},
172         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.device_notify),
173          "Device Notify"},
174         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(processor.handler), "Handler"}
175 };
176
177 static struct acpi_exdump_info acpi_ex_dump_thermal[4] = {
178         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_thermal), NULL},
179         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.system_notify),
180          "System Notify"},
181         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.device_notify),
182          "Device Notify"},
183         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(thermal_zone.handler), "Handler"}
184 };
185
186 static struct acpi_exdump_info acpi_ex_dump_buffer_field[3] = {
187         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_buffer_field), NULL},
188         {ACPI_EXD_FIELD, 0, NULL},
189         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(buffer_field.buffer_obj),
190          "Buffer Object"}
191 };
192
193 static struct acpi_exdump_info acpi_ex_dump_region_field[3] = {
194         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_region_field), NULL},
195         {ACPI_EXD_FIELD, 0, NULL},
196         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(field.region_obj), "Region Object"}
197 };
198
199 static struct acpi_exdump_info acpi_ex_dump_bank_field[5] = {
200         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_bank_field), NULL},
201         {ACPI_EXD_FIELD, 0, NULL},
202         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(bank_field.value), "Value"},
203         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(bank_field.region_obj),
204          "Region Object"},
205         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(bank_field.bank_obj), "Bank Object"}
206 };
207
208 static struct acpi_exdump_info acpi_ex_dump_index_field[5] = {
209         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_bank_field), NULL},
210         {ACPI_EXD_FIELD, 0, NULL},
211         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(index_field.value), "Value"},
212         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(index_field.index_obj),
213          "Index Object"},
214         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(index_field.data_obj), "Data Object"}
215 };
216
217 static struct acpi_exdump_info acpi_ex_dump_reference[8] = {
218         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_reference), NULL},
219         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(reference.class), "Class"},
220         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(reference.target_type), "Target Type"},
221         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(reference.value), "Value"},
222         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.object), "Object Desc"},
223         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.node), "Node"},
224         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(reference.where), "Where"},
225         {ACPI_EXD_REFERENCE, 0, NULL}
226 };
227
228 static struct acpi_exdump_info acpi_ex_dump_address_handler[6] = {
229         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_address_handler),
230          NULL},
231         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(address_space.space_id), "Space Id"},
232         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.next), "Next"},
233         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.region_list),
234          "Region List"},
235         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.node), "Node"},
236         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(address_space.context), "Context"}
237 };
238
239 static struct acpi_exdump_info acpi_ex_dump_notify[3] = {
240         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_notify), NULL},
241         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(notify.node), "Node"},
242         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(notify.context), "Context"}
243 };
244
245 /* Miscellaneous tables */
246
247 static struct acpi_exdump_info acpi_ex_dump_common[4] = {
248         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_common), NULL},
249         {ACPI_EXD_TYPE, 0, NULL},
250         {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(common.reference_count),
251          "Reference Count"},
252         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common.flags), "Flags"}
253 };
254
255 static struct acpi_exdump_info acpi_ex_dump_field_common[7] = {
256         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_field_common), NULL},
257         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.field_flags),
258          "Field Flags"},
259         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.access_byte_width),
260          "Access Byte Width"},
261         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(common_field.bit_length),
262          "Bit Length"},
263         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(common_field.start_field_bit_offset),
264          "Field Bit Offset"},
265         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(common_field.base_byte_offset),
266          "Base Byte Offset"},
267         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(common_field.node), "Parent Node"}
268 };
269
270 static struct acpi_exdump_info acpi_ex_dump_node[5] = {
271         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_node), NULL},
272         {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET(flags), "Flags"},
273         {ACPI_EXD_UINT8, ACPI_EXD_NSOFFSET(owner_id), "Owner Id"},
274         {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET(child), "Child List"},
275         {ACPI_EXD_POINTER, ACPI_EXD_NSOFFSET(peer), "Next Peer"}
276 };
277
278 /* Dispatch table, indexed by object type */
279
280 static struct acpi_exdump_info *acpi_ex_dump_info[] = {
281         NULL,
282         acpi_ex_dump_integer,
283         acpi_ex_dump_string,
284         acpi_ex_dump_buffer,
285         acpi_ex_dump_package,
286         NULL,
287         acpi_ex_dump_device,
288         acpi_ex_dump_event,
289         acpi_ex_dump_method,
290         acpi_ex_dump_mutex,
291         acpi_ex_dump_region,
292         acpi_ex_dump_power,
293         acpi_ex_dump_processor,
294         acpi_ex_dump_thermal,
295         acpi_ex_dump_buffer_field,
296         NULL,
297         NULL,
298         acpi_ex_dump_region_field,
299         acpi_ex_dump_bank_field,
300         acpi_ex_dump_index_field,
301         acpi_ex_dump_reference,
302         NULL,
303         NULL,
304         acpi_ex_dump_notify,
305         acpi_ex_dump_address_handler,
306         NULL,
307         NULL,
308         NULL
309 };
310
311 /*******************************************************************************
312  *
313  * FUNCTION:    acpi_ex_dump_object
314  *
315  * PARAMETERS:  obj_desc            - Descriptor to dump
316  *              Info                - Info table corresponding to this object
317  *                                    type
318  *
319  * RETURN:      None
320  *
321  * DESCRIPTION: Walk the info table for this object
322  *
323  ******************************************************************************/
324
325 static void
326 acpi_ex_dump_object(union acpi_operand_object *obj_desc,
327                     struct acpi_exdump_info *info)
328 {
329         u8 *target;
330         char *name;
331         u8 count;
332
333         if (!info) {
334                 acpi_os_printf
335                     ("ExDumpObject: Display not implemented for object type %s\n",
336                      acpi_ut_get_object_type_name(obj_desc));
337                 return;
338         }
339
340         /* First table entry must contain the table length (# of table entries) */
341
342         count = info->offset;
343
344         while (count) {
345                 target = ACPI_ADD_PTR(u8, obj_desc, info->offset);
346                 name = info->name;
347
348                 switch (info->opcode) {
349                 case ACPI_EXD_INIT:
350                         break;
351
352                 case ACPI_EXD_TYPE:
353                         acpi_ex_out_string("Type",
354                                            acpi_ut_get_object_type_name
355                                            (obj_desc));
356                         break;
357
358                 case ACPI_EXD_UINT8:
359
360                         acpi_os_printf("%20s : %2.2X\n", name, *target);
361                         break;
362
363                 case ACPI_EXD_UINT16:
364
365                         acpi_os_printf("%20s : %4.4X\n", name,
366                                        ACPI_GET16(target));
367                         break;
368
369                 case ACPI_EXD_UINT32:
370
371                         acpi_os_printf("%20s : %8.8X\n", name,
372                                        ACPI_GET32(target));
373                         break;
374
375                 case ACPI_EXD_UINT64:
376
377                         acpi_os_printf("%20s : %8.8X%8.8X\n", "Value",
378                                        ACPI_FORMAT_UINT64(ACPI_GET64(target)));
379                         break;
380
381                 case ACPI_EXD_POINTER:
382                 case ACPI_EXD_ADDRESS:
383
384                         acpi_ex_out_pointer(name,
385                                             *ACPI_CAST_PTR(void *, target));
386                         break;
387
388                 case ACPI_EXD_STRING:
389
390                         acpi_ut_print_string(obj_desc->string.pointer,
391                                              ACPI_UINT8_MAX);
392                         acpi_os_printf("\n");
393                         break;
394
395                 case ACPI_EXD_BUFFER:
396
397                         ACPI_DUMP_BUFFER(obj_desc->buffer.pointer,
398                                          obj_desc->buffer.length);
399                         break;
400
401                 case ACPI_EXD_PACKAGE:
402
403                         /* Dump the package contents */
404
405                         acpi_os_printf("\nPackage Contents:\n");
406                         acpi_ex_dump_package_obj(obj_desc, 0, 0);
407                         break;
408
409                 case ACPI_EXD_FIELD:
410
411                         acpi_ex_dump_object(obj_desc,
412                                             acpi_ex_dump_field_common);
413                         break;
414
415                 case ACPI_EXD_REFERENCE:
416
417                         acpi_ex_out_string("Class Name",
418                                            (char *)
419                                            acpi_ut_get_reference_name
420                                            (obj_desc));
421                         acpi_ex_dump_reference_obj(obj_desc);
422                         break;
423
424                 default:
425                         acpi_os_printf("**** Invalid table opcode [%X] ****\n",
426                                        info->opcode);
427                         return;
428                 }
429
430                 info++;
431                 count--;
432         }
433 }
434
435 /*******************************************************************************
436  *
437  * FUNCTION:    acpi_ex_dump_operand
438  *
439  * PARAMETERS:  *obj_desc       - Pointer to entry to be dumped
440  *              Depth           - Current nesting depth
441  *
442  * RETURN:      None
443  *
444  * DESCRIPTION: Dump an operand object
445  *
446  ******************************************************************************/
447
448 void acpi_ex_dump_operand(union acpi_operand_object *obj_desc, u32 depth)
449 {
450         u32 length;
451         u32 index;
452
453         ACPI_FUNCTION_NAME(ex_dump_operand)
454
455             if (!((ACPI_LV_EXEC & acpi_dbg_level)
456                   && (_COMPONENT & acpi_dbg_layer))) {
457                 return;
458         }
459
460         if (!obj_desc) {
461
462                 /* This could be a null element of a package */
463
464                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Null Object Descriptor\n"));
465                 return;
466         }
467
468         if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == ACPI_DESC_TYPE_NAMED) {
469                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%p Namespace Node: ",
470                                   obj_desc));
471                 ACPI_DUMP_ENTRY(obj_desc, ACPI_LV_EXEC);
472                 return;
473         }
474
475         if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) {
476                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
477                                   "%p is not a node or operand object: [%s]\n",
478                                   obj_desc,
479                                   acpi_ut_get_descriptor_name(obj_desc)));
480                 ACPI_DUMP_BUFFER(obj_desc, sizeof(union acpi_operand_object));
481                 return;
482         }
483
484         /* obj_desc is a valid object */
485
486         if (depth > 0) {
487                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%*s[%u] %p ",
488                                   depth, " ", depth, obj_desc));
489         } else {
490                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%p ", obj_desc));
491         }
492
493         /* Decode object type */
494
495         switch (ACPI_GET_OBJECT_TYPE(obj_desc)) {
496         case ACPI_TYPE_LOCAL_REFERENCE:
497
498                 acpi_os_printf("Reference: [%s] ",
499                                acpi_ut_get_reference_name(obj_desc));
500
501                 switch (obj_desc->reference.class) {
502                 case ACPI_REFCLASS_DEBUG:
503
504                         acpi_os_printf("\n");
505                         break;
506
507                 case ACPI_REFCLASS_INDEX:
508
509                         acpi_os_printf("%p\n", obj_desc->reference.object);
510                         break;
511
512                 case ACPI_REFCLASS_TABLE:
513
514                         acpi_os_printf("Table Index %X\n",
515                                        obj_desc->reference.value);
516                         break;
517
518                 case ACPI_REFCLASS_REFOF:
519
520                         acpi_os_printf("%p [%s]\n", obj_desc->reference.object,
521                                        acpi_ut_get_type_name(((union
522                                                                acpi_operand_object
523                                                                *)
524                                                               obj_desc->
525                                                               reference.
526                                                               object)->common.
527                                                              type));
528                         break;
529
530                 case ACPI_REFCLASS_ARG:
531
532                         acpi_os_printf("%X", obj_desc->reference.value);
533
534                         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
535
536                                 /* Value is an Integer */
537
538                                 acpi_os_printf(" value is [%8.8X%8.8x]",
539                                                ACPI_FORMAT_UINT64(obj_desc->
540                                                                   integer.
541                                                                   value));
542                         }
543
544                         acpi_os_printf("\n");
545                         break;
546
547                 case ACPI_REFCLASS_LOCAL:
548
549                         acpi_os_printf("%X", obj_desc->reference.value);
550
551                         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
552
553                                 /* Value is an Integer */
554
555                                 acpi_os_printf(" value is [%8.8X%8.8x]",
556                                                ACPI_FORMAT_UINT64(obj_desc->
557                                                                   integer.
558                                                                   value));
559                         }
560
561                         acpi_os_printf("\n");
562                         break;
563
564                 case ACPI_REFCLASS_NAME:
565
566                         acpi_os_printf("- [%4.4s]\n",
567                                        obj_desc->reference.node->name.ascii);
568                         break;
569
570                 default:        /* Unknown reference class */
571
572                         acpi_os_printf("%2.2X\n", obj_desc->reference.class);
573                         break;
574                 }
575                 break;
576
577         case ACPI_TYPE_BUFFER:
578
579                 acpi_os_printf("Buffer length %.2X @ %p\n",
580                                obj_desc->buffer.length,
581                                obj_desc->buffer.pointer);
582
583                 /* Debug only -- dump the buffer contents */
584
585                 if (obj_desc->buffer.pointer) {
586                         length = obj_desc->buffer.length;
587                         if (length > 128) {
588                                 length = 128;
589                         }
590
591                         acpi_os_printf
592                             ("Buffer Contents: (displaying length 0x%.2X)\n",
593                              length);
594                         ACPI_DUMP_BUFFER(obj_desc->buffer.pointer, length);
595                 }
596                 break;
597
598         case ACPI_TYPE_INTEGER:
599
600                 acpi_os_printf("Integer %8.8X%8.8X\n",
601                                ACPI_FORMAT_UINT64(obj_desc->integer.value));
602                 break;
603
604         case ACPI_TYPE_PACKAGE:
605
606                 acpi_os_printf("Package [Len %X] ElementArray %p\n",
607                                obj_desc->package.count,
608                                obj_desc->package.elements);
609
610                 /*
611                  * If elements exist, package element pointer is valid,
612                  * and debug_level exceeds 1, dump package's elements.
613                  */
614                 if (obj_desc->package.count &&
615                     obj_desc->package.elements && acpi_dbg_level > 1) {
616                         for (index = 0; index < obj_desc->package.count;
617                              index++) {
618                                 acpi_ex_dump_operand(obj_desc->package.
619                                                      elements[index],
620                                                      depth + 1);
621                         }
622                 }
623                 break;
624
625         case ACPI_TYPE_REGION:
626
627                 acpi_os_printf("Region %s (%X)",
628                                acpi_ut_get_region_name(obj_desc->region.
629                                                        space_id),
630                                obj_desc->region.space_id);
631
632                 /*
633                  * If the address and length have not been evaluated,
634                  * don't print them.
635                  */
636                 if (!(obj_desc->region.flags & AOPOBJ_DATA_VALID)) {
637                         acpi_os_printf("\n");
638                 } else {
639                         acpi_os_printf(" base %8.8X%8.8X Length %X\n",
640                                        ACPI_FORMAT_NATIVE_UINT(obj_desc->region.
641                                                                address),
642                                        obj_desc->region.length);
643                 }
644                 break;
645
646         case ACPI_TYPE_STRING:
647
648                 acpi_os_printf("String length %X @ %p ",
649                                obj_desc->string.length,
650                                obj_desc->string.pointer);
651
652                 acpi_ut_print_string(obj_desc->string.pointer, ACPI_UINT8_MAX);
653                 acpi_os_printf("\n");
654                 break;
655
656         case ACPI_TYPE_LOCAL_BANK_FIELD:
657
658                 acpi_os_printf("BankField\n");
659                 break;
660
661         case ACPI_TYPE_LOCAL_REGION_FIELD:
662
663                 acpi_os_printf
664                     ("RegionField: Bits=%X AccWidth=%X Lock=%X Update=%X at byte=%X bit=%X of below:\n",
665                      obj_desc->field.bit_length,
666                      obj_desc->field.access_byte_width,
667                      obj_desc->field.field_flags & AML_FIELD_LOCK_RULE_MASK,
668                      obj_desc->field.field_flags & AML_FIELD_UPDATE_RULE_MASK,
669                      obj_desc->field.base_byte_offset,
670                      obj_desc->field.start_field_bit_offset);
671
672                 acpi_ex_dump_operand(obj_desc->field.region_obj, depth + 1);
673                 break;
674
675         case ACPI_TYPE_LOCAL_INDEX_FIELD:
676
677                 acpi_os_printf("IndexField\n");
678                 break;
679
680         case ACPI_TYPE_BUFFER_FIELD:
681
682                 acpi_os_printf("BufferField: %X bits at byte %X bit %X of\n",
683                                obj_desc->buffer_field.bit_length,
684                                obj_desc->buffer_field.base_byte_offset,
685                                obj_desc->buffer_field.start_field_bit_offset);
686
687                 if (!obj_desc->buffer_field.buffer_obj) {
688                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "*NULL*\n"));
689                 } else
690                     if (ACPI_GET_OBJECT_TYPE(obj_desc->buffer_field.buffer_obj)
691                         != ACPI_TYPE_BUFFER) {
692                         acpi_os_printf("*not a Buffer*\n");
693                 } else {
694                         acpi_ex_dump_operand(obj_desc->buffer_field.buffer_obj,
695                                              depth + 1);
696                 }
697                 break;
698
699         case ACPI_TYPE_EVENT:
700
701                 acpi_os_printf("Event\n");
702                 break;
703
704         case ACPI_TYPE_METHOD:
705
706                 acpi_os_printf("Method(%X) @ %p:%X\n",
707                                obj_desc->method.param_count,
708                                obj_desc->method.aml_start,
709                                obj_desc->method.aml_length);
710                 break;
711
712         case ACPI_TYPE_MUTEX:
713
714                 acpi_os_printf("Mutex\n");
715                 break;
716
717         case ACPI_TYPE_DEVICE:
718
719                 acpi_os_printf("Device\n");
720                 break;
721
722         case ACPI_TYPE_POWER:
723
724                 acpi_os_printf("Power\n");
725                 break;
726
727         case ACPI_TYPE_PROCESSOR:
728
729                 acpi_os_printf("Processor\n");
730                 break;
731
732         case ACPI_TYPE_THERMAL:
733
734                 acpi_os_printf("Thermal\n");
735                 break;
736
737         default:
738                 /* Unknown Type */
739
740                 acpi_os_printf("Unknown Type %X\n",
741                                ACPI_GET_OBJECT_TYPE(obj_desc));
742                 break;
743         }
744
745         return;
746 }
747
748 /*******************************************************************************
749  *
750  * FUNCTION:    acpi_ex_dump_operands
751  *
752  * PARAMETERS:  Operands            - A list of Operand objects
753  *              opcode_name         - AML opcode name
754  *              num_operands        - Operand count for this opcode
755  *
756  * DESCRIPTION: Dump the operands associated with the opcode
757  *
758  ******************************************************************************/
759
760 void
761 acpi_ex_dump_operands(union acpi_operand_object **operands,
762                       const char *opcode_name, u32 num_operands)
763 {
764         ACPI_FUNCTION_NAME(ex_dump_operands);
765
766         if (!opcode_name) {
767                 opcode_name = "UNKNOWN";
768         }
769
770         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
771                           "**** Start operand dump for opcode [%s], %d operands\n",
772                           opcode_name, num_operands));
773
774         if (num_operands == 0) {
775                 num_operands = 1;
776         }
777
778         /* Dump the individual operands */
779
780         while (num_operands) {
781                 acpi_ex_dump_operand(*operands, 0);
782                 operands++;
783                 num_operands--;
784         }
785
786         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
787                           "**** End operand dump for [%s]\n", opcode_name));
788         return;
789 }
790
791 /*******************************************************************************
792  *
793  * FUNCTION:    acpi_ex_out* functions
794  *
795  * PARAMETERS:  Title               - Descriptive text
796  *              Value               - Value to be displayed
797  *
798  * DESCRIPTION: Object dump output formatting functions.  These functions
799  *              reduce the number of format strings required and keeps them
800  *              all in one place for easy modification.
801  *
802  ******************************************************************************/
803
804 static void acpi_ex_out_string(char *title, char *value)
805 {
806         acpi_os_printf("%20s : %s\n", title, value);
807 }
808
809 static void acpi_ex_out_pointer(char *title, void *value)
810 {
811         acpi_os_printf("%20s : %p\n", title, value);
812 }
813
814 /*******************************************************************************
815  *
816  * FUNCTION:    acpi_ex_dump_namespace_node
817  *
818  * PARAMETERS:  Node                - Descriptor to dump
819  *              Flags               - Force display if TRUE
820  *
821  * DESCRIPTION: Dumps the members of the given.Node
822  *
823  ******************************************************************************/
824
825 void acpi_ex_dump_namespace_node(struct acpi_namespace_node *node, u32 flags)
826 {
827
828         ACPI_FUNCTION_ENTRY();
829
830         if (!flags) {
831                 if (!((ACPI_LV_OBJECTS & acpi_dbg_level)
832                       && (_COMPONENT & acpi_dbg_layer))) {
833                         return;
834                 }
835         }
836
837         acpi_os_printf("%20s : %4.4s\n", "Name", acpi_ut_get_node_name(node));
838         acpi_ex_out_string("Type", acpi_ut_get_type_name(node->type));
839         acpi_ex_out_pointer("Attached Object",
840                             acpi_ns_get_attached_object(node));
841         acpi_ex_out_pointer("Parent", acpi_ns_get_parent_node(node));
842
843         acpi_ex_dump_object(ACPI_CAST_PTR(union acpi_operand_object, node),
844                             acpi_ex_dump_node);
845 }
846
847 /*******************************************************************************
848  *
849  * FUNCTION:    acpi_ex_dump_reference_obj
850  *
851  * PARAMETERS:  Object              - Descriptor to dump
852  *
853  * DESCRIPTION: Dumps a reference object
854  *
855  ******************************************************************************/
856
857 static void acpi_ex_dump_reference_obj(union acpi_operand_object *obj_desc)
858 {
859         struct acpi_buffer ret_buf;
860         acpi_status status;
861
862         ret_buf.length = ACPI_ALLOCATE_LOCAL_BUFFER;
863
864         if (obj_desc->reference.class == ACPI_REFCLASS_NAME) {
865                 acpi_os_printf(" %p ", obj_desc->reference.node);
866
867                 status =
868                     acpi_ns_handle_to_pathname(obj_desc->reference.node,
869                                                &ret_buf);
870                 if (ACPI_FAILURE(status)) {
871                         acpi_os_printf(" Could not convert name to pathname\n");
872                 } else {
873                         acpi_os_printf("%s\n", (char *)ret_buf.pointer);
874                         ACPI_FREE(ret_buf.pointer);
875                 }
876         } else if (obj_desc->reference.object) {
877                 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) ==
878                     ACPI_DESC_TYPE_OPERAND) {
879                         acpi_os_printf(" Target: %p",
880                                        obj_desc->reference.object);
881                         if (obj_desc->reference.class == ACPI_REFCLASS_TABLE) {
882                                 acpi_os_printf(" Table Index: %X\n",
883                                                obj_desc->reference.value);
884                         } else {
885                                 acpi_os_printf(" Target: %p [%s]\n",
886                                                obj_desc->reference.object,
887                                                acpi_ut_get_type_name(((union
888                                                                        acpi_operand_object
889                                                                        *)
890                                                                       obj_desc->
891                                                                       reference.
892                                                                       object)->
893                                                                      common.
894                                                                      type));
895                         }
896                 } else {
897                         acpi_os_printf(" Target: %p\n",
898                                        obj_desc->reference.object);
899                 }
900         }
901 }
902
903 /*******************************************************************************
904  *
905  * FUNCTION:    acpi_ex_dump_package_obj
906  *
907  * PARAMETERS:  obj_desc            - Descriptor to dump
908  *              Level               - Indentation Level
909  *              Index               - Package index for this object
910  *
911  * DESCRIPTION: Dumps the elements of the package
912  *
913  ******************************************************************************/
914
915 static void
916 acpi_ex_dump_package_obj(union acpi_operand_object *obj_desc,
917                          u32 level, u32 index)
918 {
919         u32 i;
920
921         /* Indentation and index output */
922
923         if (level > 0) {
924                 for (i = 0; i < level; i++) {
925                         acpi_os_printf(" ");
926                 }
927
928                 acpi_os_printf("[%.2d] ", index);
929         }
930
931         acpi_os_printf("%p ", obj_desc);
932
933         /* Null package elements are allowed */
934
935         if (!obj_desc) {
936                 acpi_os_printf("[Null Object]\n");
937                 return;
938         }
939
940         /* Packages may only contain a few object types */
941
942         switch (ACPI_GET_OBJECT_TYPE(obj_desc)) {
943         case ACPI_TYPE_INTEGER:
944
945                 acpi_os_printf("[Integer] = %8.8X%8.8X\n",
946                                ACPI_FORMAT_UINT64(obj_desc->integer.value));
947                 break;
948
949         case ACPI_TYPE_STRING:
950
951                 acpi_os_printf("[String] Value: ");
952                 for (i = 0; i < obj_desc->string.length; i++) {
953                         acpi_os_printf("%c", obj_desc->string.pointer[i]);
954                 }
955                 acpi_os_printf("\n");
956                 break;
957
958         case ACPI_TYPE_BUFFER:
959
960                 acpi_os_printf("[Buffer] Length %.2X = ",
961                                obj_desc->buffer.length);
962                 if (obj_desc->buffer.length) {
963                         acpi_ut_dump_buffer(ACPI_CAST_PTR
964                                             (u8, obj_desc->buffer.pointer),
965                                             obj_desc->buffer.length,
966                                             DB_DWORD_DISPLAY, _COMPONENT);
967                 } else {
968                         acpi_os_printf("\n");
969                 }
970                 break;
971
972         case ACPI_TYPE_PACKAGE:
973
974                 acpi_os_printf("[Package] Contains %d Elements:\n",
975                                obj_desc->package.count);
976
977                 for (i = 0; i < obj_desc->package.count; i++) {
978                         acpi_ex_dump_package_obj(obj_desc->package.elements[i],
979                                                  level + 1, i);
980                 }
981                 break;
982
983         case ACPI_TYPE_LOCAL_REFERENCE:
984
985                 acpi_os_printf("[Object Reference] Type [%s] %2.2X",
986                                acpi_ut_get_reference_name(obj_desc),
987                                obj_desc->reference.class);
988                 acpi_ex_dump_reference_obj(obj_desc);
989                 break;
990
991         default:
992
993                 acpi_os_printf("[Unknown Type] %X\n",
994                                ACPI_GET_OBJECT_TYPE(obj_desc));
995                 break;
996         }
997 }
998
999 /*******************************************************************************
1000  *
1001  * FUNCTION:    acpi_ex_dump_object_descriptor
1002  *
1003  * PARAMETERS:  obj_desc            - Descriptor to dump
1004  *              Flags               - Force display if TRUE
1005  *
1006  * DESCRIPTION: Dumps the members of the object descriptor given.
1007  *
1008  ******************************************************************************/
1009
1010 void
1011 acpi_ex_dump_object_descriptor(union acpi_operand_object *obj_desc, u32 flags)
1012 {
1013         ACPI_FUNCTION_TRACE(ex_dump_object_descriptor);
1014
1015         if (!obj_desc) {
1016                 return_VOID;
1017         }
1018
1019         if (!flags) {
1020                 if (!((ACPI_LV_OBJECTS & acpi_dbg_level)
1021                       && (_COMPONENT & acpi_dbg_layer))) {
1022                         return_VOID;
1023                 }
1024         }
1025
1026         if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == ACPI_DESC_TYPE_NAMED) {
1027                 acpi_ex_dump_namespace_node((struct acpi_namespace_node *)
1028                                             obj_desc, flags);
1029
1030                 acpi_os_printf("\nAttached Object (%p):\n",
1031                                ((struct acpi_namespace_node *)obj_desc)->
1032                                object);
1033
1034                 acpi_ex_dump_object_descriptor(((struct acpi_namespace_node *)
1035                                                 obj_desc)->object, flags);
1036                 return_VOID;
1037         }
1038
1039         if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) {
1040                 acpi_os_printf
1041                     ("ExDumpObjectDescriptor: %p is not an ACPI operand object: [%s]\n",
1042                      obj_desc, acpi_ut_get_descriptor_name(obj_desc));
1043                 return_VOID;
1044         }
1045
1046         if (obj_desc->common.type > ACPI_TYPE_NS_NODE_MAX) {
1047                 return_VOID;
1048         }
1049
1050         /* Common Fields */
1051
1052         acpi_ex_dump_object(obj_desc, acpi_ex_dump_common);
1053
1054         /* Object-specific fields */
1055
1056         acpi_ex_dump_object(obj_desc, acpi_ex_dump_info[obj_desc->common.type]);
1057         return_VOID;
1058 }
1059
1060 #endif