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