1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/*******************************************************************************
3 *
4 * Module Name: dbtest - Various debug-related tests
5 *
6 ******************************************************************************/
7
8#include <acpi/acpi.h>
9#include "accommon.h"
10#include "acdebug.h"
11#include "acnamesp.h"
12#include "acpredef.h"
13#include "acinterp.h"
14
15#define _COMPONENT ACPI_CA_DEBUGGER
16ACPI_MODULE_NAME("dbtest")
17
18/* Local prototypes */
19static void acpi_db_test_all_objects(void);
20
21static acpi_status
22acpi_db_test_one_object(acpi_handle obj_handle,
23 u32 nesting_level, void *context, void **return_value);
24
25static acpi_status
26acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length);
27
28static acpi_status
29acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length);
30
31static acpi_status
32acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length);
33
34static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node);
35
36static acpi_status
37acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc);
38
39static acpi_status
40acpi_db_read_from_object(struct acpi_namespace_node *node,
41 acpi_object_type expected_type,
42 union acpi_object **value);
43
44static acpi_status
45acpi_db_write_to_object(struct acpi_namespace_node *node,
46 union acpi_object *value);
47
48static void acpi_db_evaluate_all_predefined_names(char *count_arg);
49
50static acpi_status
51acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle,
52 u32 nesting_level,
53 void *context, void **return_value);
54
55/*
56 * Test subcommands
57 */
58static struct acpi_db_argument_info acpi_db_test_types[] = {
59 {"OBJECTS"},
60 {"PREDEFINED"},
61 {NULL} /* Must be null terminated */
62};
63
64#define CMD_TEST_OBJECTS 0
65#define CMD_TEST_PREDEFINED 1
66
67#define BUFFER_FILL_VALUE 0xFF
68
69/*
70 * Support for the special debugger read/write control methods.
71 * These methods are installed into the current namespace and are
72 * used to read and write the various namespace objects. The point
73 * is to force the AML interpreter do all of the work.
74 */
75#define ACPI_DB_READ_METHOD "\\_T98"
76#define ACPI_DB_WRITE_METHOD "\\_T99"
77
78static acpi_handle read_handle = NULL;
79static acpi_handle write_handle = NULL;
80
81/* ASL Definitions of the debugger read/write control methods. AML below. */
82
83#if 0
84definition_block("ssdt.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
85{
86 method(_T98, 1, not_serialized) { /* Read */
87 return (de_ref_of(arg0))
88 }
89}
90
91definition_block("ssdt2.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
92{
93 method(_T99, 2, not_serialized) { /* Write */
94 store(arg1, arg0)
95 }
96}
97#endif
98
99static unsigned char read_method_code[] = {
100 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */
101 0x02, 0xC9, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */
102 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */
103 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */
104 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */
105 0x39, 0x38, 0x01, 0xA4, 0x83, 0x68 /* 00000028 "98...h" */
106};
107
108static unsigned char write_method_code[] = {
109 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */
110 0x02, 0x15, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */
111 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */
112 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */
113 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */
114 0x39, 0x39, 0x02, 0x70, 0x69, 0x68 /* 00000028 "99.pih" */
115};
116
117/*******************************************************************************
118 *
119 * FUNCTION: acpi_db_execute_test
120 *
121 * PARAMETERS: type_arg - Subcommand
122 *
123 * RETURN: None
124 *
125 * DESCRIPTION: Execute various debug tests.
126 *
127 * Note: Code is prepared for future expansion of the TEST command.
128 *
129 ******************************************************************************/
130
131void acpi_db_execute_test(char *type_arg)
132{
133 u32 temp;
134
135 acpi_ut_strupr(src_string: type_arg);
136 temp = acpi_db_match_argument(user_argument: type_arg, arguments: acpi_db_test_types);
137 if (temp == ACPI_TYPE_NOT_FOUND) {
138 acpi_os_printf(format: "Invalid or unsupported argument\n");
139 return;
140 }
141
142 switch (temp) {
143 case CMD_TEST_OBJECTS:
144
145 acpi_db_test_all_objects();
146 break;
147
148 case CMD_TEST_PREDEFINED:
149
150 acpi_db_evaluate_all_predefined_names(NULL);
151 break;
152
153 default:
154 break;
155 }
156}
157
158/*******************************************************************************
159 *
160 * FUNCTION: acpi_db_test_all_objects
161 *
162 * PARAMETERS: None
163 *
164 * RETURN: None
165 *
166 * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the
167 * namespace by reading/writing/comparing all data objects such
168 * as integers, strings, buffers, fields, buffer fields, etc.
169 *
170 ******************************************************************************/
171
172static void acpi_db_test_all_objects(void)
173{
174 acpi_status status;
175
176 /* Install the debugger read-object control method if necessary */
177
178 if (!read_handle) {
179 status = acpi_install_method(buffer: read_method_code);
180 if (ACPI_FAILURE(status)) {
181 acpi_os_printf
182 (format: "%s, Could not install debugger read method\n",
183 acpi_format_exception(exception: status));
184 return;
185 }
186
187 status =
188 acpi_get_handle(NULL, ACPI_DB_READ_METHOD, ret_handle: &read_handle);
189 if (ACPI_FAILURE(status)) {
190 acpi_os_printf
191 (format: "Could not obtain handle for debug method %s\n",
192 ACPI_DB_READ_METHOD);
193 return;
194 }
195 }
196
197 /* Install the debugger write-object control method if necessary */
198
199 if (!write_handle) {
200 status = acpi_install_method(buffer: write_method_code);
201 if (ACPI_FAILURE(status)) {
202 acpi_os_printf
203 (format: "%s, Could not install debugger write method\n",
204 acpi_format_exception(exception: status));
205 return;
206 }
207
208 status =
209 acpi_get_handle(NULL, ACPI_DB_WRITE_METHOD, ret_handle: &write_handle);
210 if (ACPI_FAILURE(status)) {
211 acpi_os_printf
212 (format: "Could not obtain handle for debug method %s\n",
213 ACPI_DB_WRITE_METHOD);
214 return;
215 }
216 }
217
218 /* Walk the entire namespace, testing each supported named data object */
219
220 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
221 ACPI_UINT32_MAX, descending_callback: acpi_db_test_one_object,
222 NULL, NULL, NULL);
223}
224
225/*******************************************************************************
226 *
227 * FUNCTION: acpi_db_test_one_object
228 *
229 * PARAMETERS: acpi_walk_callback
230 *
231 * RETURN: Status
232 *
233 * DESCRIPTION: Test one namespace object. Supported types are Integer,
234 * String, Buffer, Package, buffer_field, and field_unit.
235 * All other object types are simply ignored.
236 *
237 ******************************************************************************/
238
239static acpi_status
240acpi_db_test_one_object(acpi_handle obj_handle,
241 u32 nesting_level, void *context, void **return_value)
242{
243 struct acpi_namespace_node *node;
244 union acpi_operand_object *obj_desc;
245 acpi_object_type local_type;
246 u32 bit_length = 0;
247 u32 byte_length = 0;
248 acpi_status status = AE_OK;
249
250 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
251 obj_desc = node->object;
252
253 /*
254 * For the supported types, get the actual bit length or
255 * byte length. Map the type to one of Integer/String/Buffer.
256 */
257 switch (node->type) {
258 case ACPI_TYPE_INTEGER:
259
260 /* Integer width is either 32 or 64 */
261
262 local_type = ACPI_TYPE_INTEGER;
263 bit_length = acpi_gbl_integer_bit_width;
264 break;
265
266 case ACPI_TYPE_STRING:
267
268 local_type = ACPI_TYPE_STRING;
269 byte_length = obj_desc->string.length;
270 break;
271
272 case ACPI_TYPE_BUFFER:
273
274 local_type = ACPI_TYPE_BUFFER;
275 byte_length = obj_desc->buffer.length;
276 bit_length = byte_length * 8;
277 break;
278
279 case ACPI_TYPE_PACKAGE:
280
281 local_type = ACPI_TYPE_PACKAGE;
282 break;
283
284 case ACPI_TYPE_FIELD_UNIT:
285 case ACPI_TYPE_LOCAL_REGION_FIELD:
286 case ACPI_TYPE_LOCAL_INDEX_FIELD:
287 case ACPI_TYPE_LOCAL_BANK_FIELD:
288
289 local_type = ACPI_TYPE_FIELD_UNIT;
290 break;
291
292 case ACPI_TYPE_BUFFER_FIELD:
293 /*
294 * The returned object will be a Buffer if the field length
295 * is larger than the size of an Integer (32 or 64 bits
296 * depending on the DSDT version).
297 */
298 local_type = ACPI_TYPE_INTEGER;
299 if (obj_desc) {
300 bit_length = obj_desc->common_field.bit_length;
301 byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length);
302 if (bit_length > acpi_gbl_integer_bit_width) {
303 local_type = ACPI_TYPE_BUFFER;
304 }
305 }
306 break;
307
308 default:
309
310 /* Ignore all non-data types - Methods, Devices, Scopes, etc. */
311
312 return (AE_OK);
313 }
314
315 /* Emit the common prefix: Type:Name */
316
317 acpi_os_printf(format: "%14s: %4.4s",
318 acpi_ut_get_type_name(type: node->type), node->name.ascii);
319
320 if (!obj_desc) {
321 acpi_os_printf(format: " No attached sub-object, ignoring\n");
322 return (AE_OK);
323 }
324
325 /* At this point, we have resolved the object to one of the major types */
326
327 switch (local_type) {
328 case ACPI_TYPE_INTEGER:
329
330 status = acpi_db_test_integer_type(node, bit_length);
331 break;
332
333 case ACPI_TYPE_STRING:
334
335 status = acpi_db_test_string_type(node, byte_length);
336 break;
337
338 case ACPI_TYPE_BUFFER:
339
340 status = acpi_db_test_buffer_type(node, bit_length);
341 break;
342
343 case ACPI_TYPE_PACKAGE:
344
345 status = acpi_db_test_package_type(node);
346 break;
347
348 case ACPI_TYPE_FIELD_UNIT:
349
350 status = acpi_db_test_field_unit_type(obj_desc);
351 break;
352
353 default:
354
355 acpi_os_printf(format: " Ignoring, type not implemented (%2.2X)",
356 local_type);
357 break;
358 }
359
360 /* Exit on error, but don't abort the namespace walk */
361
362 if (ACPI_FAILURE(status)) {
363 status = AE_OK;
364 }
365
366 acpi_os_printf(format: "\n");
367 return (status);
368}
369
370/*******************************************************************************
371 *
372 * FUNCTION: acpi_db_test_integer_type
373 *
374 * PARAMETERS: node - Parent NS node for the object
375 * bit_length - Actual length of the object. Used for
376 * support of arbitrary length field_unit
377 * and buffer_field objects.
378 *
379 * RETURN: Status
380 *
381 * DESCRIPTION: Test read/write for an Integer-valued object. Performs a
382 * write/read/compare of an arbitrary new value, then performs
383 * a write/read/compare of the original value.
384 *
385 ******************************************************************************/
386
387static acpi_status
388acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length)
389{
390 union acpi_object *temp1 = NULL;
391 union acpi_object *temp2 = NULL;
392 union acpi_object *temp3 = NULL;
393 union acpi_object write_value;
394 u64 value_to_write;
395 acpi_status status;
396
397 if (bit_length > 64) {
398 acpi_os_printf(format: " Invalid length for an Integer: %u",
399 bit_length);
400 return (AE_OK);
401 }
402
403 /* Read the original value */
404
405 status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp1);
406 if (ACPI_FAILURE(status)) {
407 return (status);
408 }
409
410 acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " %8.8X%8.8X",
411 bit_length, ACPI_ROUND_BITS_UP_TO_BYTES(bit_length),
412 ACPI_FORMAT_UINT64(temp1->integer.value));
413
414 value_to_write = ACPI_UINT64_MAX >> (64 - bit_length);
415 if (temp1->integer.value == value_to_write) {
416 value_to_write = 0;
417 }
418 /* Write a new value */
419
420 write_value.type = ACPI_TYPE_INTEGER;
421 write_value.integer.value = value_to_write;
422 status = acpi_db_write_to_object(node, value: &write_value);
423 if (ACPI_FAILURE(status)) {
424 goto exit;
425 }
426
427 /* Ensure that we can read back the new value */
428
429 status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp2);
430 if (ACPI_FAILURE(status)) {
431 goto exit;
432 }
433
434 if (temp2->integer.value != value_to_write) {
435 acpi_os_printf(format: " MISMATCH 2: %8.8X%8.8X, expecting %8.8X%8.8X",
436 ACPI_FORMAT_UINT64(temp2->integer.value),
437 ACPI_FORMAT_UINT64(value_to_write));
438 }
439
440 /* Write back the original value */
441
442 write_value.integer.value = temp1->integer.value;
443 status = acpi_db_write_to_object(node, value: &write_value);
444 if (ACPI_FAILURE(status)) {
445 goto exit;
446 }
447
448 /* Ensure that we can read back the original value */
449
450 status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp3);
451 if (ACPI_FAILURE(status)) {
452 goto exit;
453 }
454
455 if (temp3->integer.value != temp1->integer.value) {
456 acpi_os_printf(format: " MISMATCH 3: %8.8X%8.8X, expecting %8.8X%8.8X",
457 ACPI_FORMAT_UINT64(temp3->integer.value),
458 ACPI_FORMAT_UINT64(temp1->integer.value));
459 }
460
461exit:
462 if (temp1) {
463 acpi_os_free(memory: temp1);
464 }
465 if (temp2) {
466 acpi_os_free(memory: temp2);
467 }
468 if (temp3) {
469 acpi_os_free(memory: temp3);
470 }
471 return (AE_OK);
472}
473
474/*******************************************************************************
475 *
476 * FUNCTION: acpi_db_test_buffer_type
477 *
478 * PARAMETERS: node - Parent NS node for the object
479 * bit_length - Actual length of the object.
480 *
481 * RETURN: Status
482 *
483 * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a
484 * write/read/compare of an arbitrary new value, then performs
485 * a write/read/compare of the original value.
486 *
487 ******************************************************************************/
488
489static acpi_status
490acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length)
491{
492 union acpi_object *temp1 = NULL;
493 union acpi_object *temp2 = NULL;
494 union acpi_object *temp3 = NULL;
495 u8 *buffer;
496 union acpi_object write_value;
497 acpi_status status;
498 u32 byte_length;
499 u32 i;
500 u8 extra_bits;
501
502 byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length);
503 if (byte_length == 0) {
504 acpi_os_printf(format: " Ignoring zero length buffer");
505 return (AE_OK);
506 }
507
508 /* Allocate a local buffer */
509
510 buffer = ACPI_ALLOCATE_ZEROED(byte_length);
511 if (!buffer) {
512 return (AE_NO_MEMORY);
513 }
514
515 /* Read the original value */
516
517 status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp1);
518 if (ACPI_FAILURE(status)) {
519 goto exit;
520 }
521
522 /* Emit a few bytes of the buffer */
523
524 acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT, bit_length,
525 temp1->buffer.length);
526 for (i = 0; ((i < 8) && (i < byte_length)); i++) {
527 acpi_os_printf(format: " %2.2X", temp1->buffer.pointer[i]);
528 }
529 acpi_os_printf(format: "... ");
530
531 /*
532 * Write a new value.
533 *
534 * Handle possible extra bits at the end of the buffer. Can
535 * happen for field_units larger than an integer, but the bit
536 * count is not an integral number of bytes. Zero out the
537 * unused bits.
538 */
539 memset(buffer, BUFFER_FILL_VALUE, byte_length);
540 extra_bits = bit_length % 8;
541 if (extra_bits) {
542 buffer[byte_length - 1] = ACPI_MASK_BITS_ABOVE(extra_bits);
543 }
544
545 write_value.type = ACPI_TYPE_BUFFER;
546 write_value.buffer.length = byte_length;
547 write_value.buffer.pointer = buffer;
548
549 status = acpi_db_write_to_object(node, value: &write_value);
550 if (ACPI_FAILURE(status)) {
551 goto exit;
552 }
553
554 /* Ensure that we can read back the new value */
555
556 status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp2);
557 if (ACPI_FAILURE(status)) {
558 goto exit;
559 }
560
561 if (memcmp(p: temp2->buffer.pointer, q: buffer, size: byte_length)) {
562 acpi_os_printf(format: " MISMATCH 2: New buffer value");
563 }
564
565 /* Write back the original value */
566
567 write_value.buffer.length = byte_length;
568 write_value.buffer.pointer = temp1->buffer.pointer;
569
570 status = acpi_db_write_to_object(node, value: &write_value);
571 if (ACPI_FAILURE(status)) {
572 goto exit;
573 }
574
575 /* Ensure that we can read back the original value */
576
577 status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp3);
578 if (ACPI_FAILURE(status)) {
579 goto exit;
580 }
581
582 if (memcmp(p: temp1->buffer.pointer, q: temp3->buffer.pointer, size: byte_length)) {
583 acpi_os_printf(format: " MISMATCH 3: While restoring original buffer");
584 }
585
586exit:
587 ACPI_FREE(buffer);
588 if (temp1) {
589 acpi_os_free(memory: temp1);
590 }
591 if (temp2) {
592 acpi_os_free(memory: temp2);
593 }
594 if (temp3) {
595 acpi_os_free(memory: temp3);
596 }
597 return (status);
598}
599
600/*******************************************************************************
601 *
602 * FUNCTION: acpi_db_test_string_type
603 *
604 * PARAMETERS: node - Parent NS node for the object
605 * byte_length - Actual length of the object.
606 *
607 * RETURN: Status
608 *
609 * DESCRIPTION: Test read/write for an String-valued object. Performs a
610 * write/read/compare of an arbitrary new value, then performs
611 * a write/read/compare of the original value.
612 *
613 ******************************************************************************/
614
615static acpi_status
616acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length)
617{
618 union acpi_object *temp1 = NULL;
619 union acpi_object *temp2 = NULL;
620 union acpi_object *temp3 = NULL;
621 char *value_to_write = "Test String from AML Debugger";
622 union acpi_object write_value;
623 acpi_status status;
624
625 /* Read the original value */
626
627 status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp1);
628 if (ACPI_FAILURE(status)) {
629 return (status);
630 }
631
632 acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " \"%s\"",
633 (temp1->string.length * 8), temp1->string.length,
634 temp1->string.pointer);
635
636 /* Write a new value */
637
638 write_value.type = ACPI_TYPE_STRING;
639 write_value.string.length = strlen(value_to_write);
640 write_value.string.pointer = value_to_write;
641
642 status = acpi_db_write_to_object(node, value: &write_value);
643 if (ACPI_FAILURE(status)) {
644 goto exit;
645 }
646
647 /* Ensure that we can read back the new value */
648
649 status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp2);
650 if (ACPI_FAILURE(status)) {
651 goto exit;
652 }
653
654 if (strcmp(temp2->string.pointer, value_to_write)) {
655 acpi_os_printf(format: " MISMATCH 2: %s, expecting %s",
656 temp2->string.pointer, value_to_write);
657 }
658
659 /* Write back the original value */
660
661 write_value.string.length = strlen(temp1->string.pointer);
662 write_value.string.pointer = temp1->string.pointer;
663
664 status = acpi_db_write_to_object(node, value: &write_value);
665 if (ACPI_FAILURE(status)) {
666 goto exit;
667 }
668
669 /* Ensure that we can read back the original value */
670
671 status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp3);
672 if (ACPI_FAILURE(status)) {
673 goto exit;
674 }
675
676 if (strcmp(temp1->string.pointer, temp3->string.pointer)) {
677 acpi_os_printf(format: " MISMATCH 3: %s, expecting %s",
678 temp3->string.pointer, temp1->string.pointer);
679 }
680
681exit:
682 if (temp1) {
683 acpi_os_free(memory: temp1);
684 }
685 if (temp2) {
686 acpi_os_free(memory: temp2);
687 }
688 if (temp3) {
689 acpi_os_free(memory: temp3);
690 }
691 return (status);
692}
693
694/*******************************************************************************
695 *
696 * FUNCTION: acpi_db_test_package_type
697 *
698 * PARAMETERS: node - Parent NS node for the object
699 *
700 * RETURN: Status
701 *
702 * DESCRIPTION: Test read for a Package object.
703 *
704 ******************************************************************************/
705
706static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node)
707{
708 union acpi_object *temp1 = NULL;
709 acpi_status status;
710
711 /* Read the original value */
712
713 status = acpi_db_read_from_object(node, ACPI_TYPE_PACKAGE, value: &temp1);
714 if (ACPI_FAILURE(status)) {
715 return (status);
716 }
717
718 acpi_os_printf(format: " %.2X Elements", temp1->package.count);
719 acpi_os_free(memory: temp1);
720 return (status);
721}
722
723/*******************************************************************************
724 *
725 * FUNCTION: acpi_db_test_field_unit_type
726 *
727 * PARAMETERS: obj_desc - A field unit object
728 *
729 * RETURN: Status
730 *
731 * DESCRIPTION: Test read/write on a named field unit.
732 *
733 ******************************************************************************/
734
735static acpi_status
736acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc)
737{
738 union acpi_operand_object *region_obj;
739 u32 bit_length = 0;
740 u32 byte_length = 0;
741 acpi_status status = AE_OK;
742 union acpi_operand_object *ret_buffer_desc;
743
744 /* Supported spaces are memory/io/pci_config */
745
746 region_obj = obj_desc->field.region_obj;
747 switch (region_obj->region.space_id) {
748 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
749 case ACPI_ADR_SPACE_SYSTEM_IO:
750 case ACPI_ADR_SPACE_PCI_CONFIG:
751
752 /* Need the interpreter to execute */
753
754 acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
755 acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
756
757 /* Exercise read-then-write */
758
759 status =
760 acpi_ex_read_data_from_field(NULL, obj_desc,
761 ret_buffer_desc: &ret_buffer_desc);
762 if (status == AE_OK) {
763 acpi_ex_write_data_to_field(source_desc: ret_buffer_desc, obj_desc,
764 NULL);
765 acpi_ut_remove_reference(object: ret_buffer_desc);
766 }
767
768 acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
769 acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
770
771 bit_length = obj_desc->common_field.bit_length;
772 byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length);
773
774 acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " [%s]", bit_length,
775 byte_length,
776 acpi_ut_get_region_name(space_id: region_obj->region.
777 space_id));
778 return (status);
779
780 default:
781
782 acpi_os_printf
783 (format: " %s address space is not supported in this command [%4.4s]",
784 acpi_ut_get_region_name(space_id: region_obj->region.space_id),
785 region_obj->region.node->name.ascii);
786 return (AE_OK);
787 }
788}
789
790/*******************************************************************************
791 *
792 * FUNCTION: acpi_db_read_from_object
793 *
794 * PARAMETERS: node - Parent NS node for the object
795 * expected_type - Object type expected from the read
796 * value - Where the value read is returned
797 *
798 * RETURN: Status
799 *
800 * DESCRIPTION: Performs a read from the specified object by invoking the
801 * special debugger control method that reads the object. Thus,
802 * the AML interpreter is doing all of the work, increasing the
803 * validity of the test.
804 *
805 ******************************************************************************/
806
807static acpi_status
808acpi_db_read_from_object(struct acpi_namespace_node *node,
809 acpi_object_type expected_type,
810 union acpi_object **value)
811{
812 union acpi_object *ret_value;
813 struct acpi_object_list param_objects;
814 union acpi_object params[2];
815 struct acpi_buffer return_obj;
816 acpi_status status;
817
818 params[0].type = ACPI_TYPE_LOCAL_REFERENCE;
819 params[0].reference.actual_type = node->type;
820 params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node);
821
822 param_objects.count = 1;
823 param_objects.pointer = params;
824
825 return_obj.length = ACPI_ALLOCATE_BUFFER;
826
827 acpi_gbl_method_executing = TRUE;
828 status = acpi_evaluate_object(object: read_handle, NULL,
829 parameter_objects: &param_objects, return_object_buffer: &return_obj);
830
831 acpi_gbl_method_executing = FALSE;
832 if (ACPI_FAILURE(status)) {
833 acpi_os_printf(format: "Could not read from object, %s",
834 acpi_format_exception(exception: status));
835 return (status);
836 }
837
838 ret_value = (union acpi_object *)return_obj.pointer;
839
840 switch (ret_value->type) {
841 case ACPI_TYPE_INTEGER:
842 case ACPI_TYPE_BUFFER:
843 case ACPI_TYPE_STRING:
844 case ACPI_TYPE_PACKAGE:
845 /*
846 * Did we receive the type we wanted? Most important for the
847 * Integer/Buffer case (when a field is larger than an Integer,
848 * it should return a Buffer).
849 */
850 if (ret_value->type != expected_type) {
851 acpi_os_printf
852 (format: " Type mismatch: Expected %s, Received %s",
853 acpi_ut_get_type_name(type: expected_type),
854 acpi_ut_get_type_name(type: ret_value->type));
855
856 acpi_os_free(memory: return_obj.pointer);
857 return (AE_TYPE);
858 }
859
860 *value = ret_value;
861 break;
862
863 default:
864
865 acpi_os_printf(format: " Unsupported return object type, %s",
866 acpi_ut_get_type_name(type: ret_value->type));
867
868 acpi_os_free(memory: return_obj.pointer);
869 return (AE_TYPE);
870 }
871
872 return (status);
873}
874
875/*******************************************************************************
876 *
877 * FUNCTION: acpi_db_write_to_object
878 *
879 * PARAMETERS: node - Parent NS node for the object
880 * value - Value to be written
881 *
882 * RETURN: Status
883 *
884 * DESCRIPTION: Performs a write to the specified object by invoking the
885 * special debugger control method that writes the object. Thus,
886 * the AML interpreter is doing all of the work, increasing the
887 * validity of the test.
888 *
889 ******************************************************************************/
890
891static acpi_status
892acpi_db_write_to_object(struct acpi_namespace_node *node,
893 union acpi_object *value)
894{
895 struct acpi_object_list param_objects;
896 union acpi_object params[2];
897 acpi_status status;
898
899 params[0].type = ACPI_TYPE_LOCAL_REFERENCE;
900 params[0].reference.actual_type = node->type;
901 params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node);
902
903 /* Copy the incoming user parameter */
904
905 memcpy(&params[1], value, sizeof(union acpi_object));
906
907 param_objects.count = 2;
908 param_objects.pointer = params;
909
910 acpi_gbl_method_executing = TRUE;
911 status = acpi_evaluate_object(object: write_handle, NULL, parameter_objects: &param_objects, NULL);
912 acpi_gbl_method_executing = FALSE;
913
914 if (ACPI_FAILURE(status)) {
915 acpi_os_printf(format: "Could not write to object, %s",
916 acpi_format_exception(exception: status));
917 }
918
919 return (status);
920}
921
922/*******************************************************************************
923 *
924 * FUNCTION: acpi_db_evaluate_all_predefined_names
925 *
926 * PARAMETERS: count_arg - Max number of methods to execute
927 *
928 * RETURN: None
929 *
930 * DESCRIPTION: Namespace batch execution. Execute predefined names in the
931 * namespace, up to the max count, if specified.
932 *
933 ******************************************************************************/
934
935static void acpi_db_evaluate_all_predefined_names(char *count_arg)
936{
937 struct acpi_db_execute_walk info;
938
939 info.count = 0;
940 info.max_count = ACPI_UINT32_MAX;
941
942 if (count_arg) {
943 info.max_count = strtoul(count_arg, NULL, 0);
944 }
945
946 /* Search all nodes in namespace */
947
948 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
949 ACPI_UINT32_MAX,
950 descending_callback: acpi_db_evaluate_one_predefined_name, NULL,
951 context: (void *)&info, NULL);
952
953 acpi_os_printf(format: "Evaluated %u predefined names in the namespace\n",
954 info.count);
955}
956
957/*******************************************************************************
958 *
959 * FUNCTION: acpi_db_evaluate_one_predefined_name
960 *
961 * PARAMETERS: Callback from walk_namespace
962 *
963 * RETURN: Status
964 *
965 * DESCRIPTION: Batch execution module. Currently only executes predefined
966 * ACPI names.
967 *
968 ******************************************************************************/
969
970static acpi_status
971acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle,
972 u32 nesting_level,
973 void *context, void **return_value)
974{
975 struct acpi_namespace_node *node =
976 (struct acpi_namespace_node *)obj_handle;
977 struct acpi_db_execute_walk *info =
978 (struct acpi_db_execute_walk *)context;
979 char *pathname;
980 const union acpi_predefined_info *predefined;
981 struct acpi_device_info *obj_info;
982 struct acpi_object_list param_objects;
983 union acpi_object params[ACPI_METHOD_NUM_ARGS];
984 union acpi_object *this_param;
985 struct acpi_buffer return_obj;
986 acpi_status status;
987 u16 arg_type_list;
988 u8 arg_count;
989 u8 arg_type;
990 u32 i;
991
992 /* The name must be a predefined ACPI name */
993
994 predefined = acpi_ut_match_predefined_method(name: node->name.ascii);
995 if (!predefined) {
996 return (AE_OK);
997 }
998
999 if (node->type == ACPI_TYPE_LOCAL_SCOPE) {
1000 return (AE_OK);
1001 }
1002
1003 pathname = acpi_ns_get_normalized_pathname(node, TRUE);
1004 if (!pathname) {
1005 return (AE_OK);
1006 }
1007
1008 /* Get the object info for number of method parameters */
1009
1010 status = acpi_get_object_info(object: obj_handle, return_buffer: &obj_info);
1011 if (ACPI_FAILURE(status)) {
1012 ACPI_FREE(pathname);
1013 return (status);
1014 }
1015
1016 param_objects.count = 0;
1017 param_objects.pointer = NULL;
1018
1019 if (obj_info->type == ACPI_TYPE_METHOD) {
1020
1021 /* Setup default parameters (with proper types) */
1022
1023 arg_type_list = predefined->info.argument_list;
1024 arg_count = METHOD_GET_ARG_COUNT(arg_type_list);
1025
1026 /*
1027 * Setup the ACPI-required number of arguments, regardless of what
1028 * the actual method defines. If there is a difference, then the
1029 * method is wrong and a warning will be issued during execution.
1030 */
1031 this_param = params;
1032 for (i = 0; i < arg_count; i++) {
1033 arg_type = METHOD_GET_NEXT_TYPE(arg_type_list);
1034 this_param->type = arg_type;
1035
1036 switch (arg_type) {
1037 case ACPI_TYPE_INTEGER:
1038
1039 this_param->integer.value = 1;
1040 break;
1041
1042 case ACPI_TYPE_STRING:
1043
1044 this_param->string.pointer =
1045 "This is the default argument string";
1046 this_param->string.length =
1047 strlen(this_param->string.pointer);
1048 break;
1049
1050 case ACPI_TYPE_BUFFER:
1051
1052 this_param->buffer.pointer = (u8 *)params; /* just a garbage buffer */
1053 this_param->buffer.length = 48;
1054 break;
1055
1056 case ACPI_TYPE_PACKAGE:
1057
1058 this_param->package.elements = NULL;
1059 this_param->package.count = 0;
1060 break;
1061
1062 default:
1063
1064 acpi_os_printf
1065 (format: "%s: Unsupported argument type: %u\n",
1066 pathname, arg_type);
1067 break;
1068 }
1069
1070 this_param++;
1071 }
1072
1073 param_objects.count = arg_count;
1074 param_objects.pointer = params;
1075 }
1076
1077 ACPI_FREE(obj_info);
1078 return_obj.pointer = NULL;
1079 return_obj.length = ACPI_ALLOCATE_BUFFER;
1080
1081 /* Do the actual method execution */
1082
1083 acpi_gbl_method_executing = TRUE;
1084
1085 status = acpi_evaluate_object(object: node, NULL, parameter_objects: &param_objects, return_object_buffer: &return_obj);
1086
1087 acpi_os_printf(format: "%-32s returned %s\n",
1088 pathname, acpi_format_exception(exception: status));
1089 acpi_gbl_method_executing = FALSE;
1090 ACPI_FREE(pathname);
1091
1092 /* Ignore status from method execution */
1093
1094 status = AE_OK;
1095
1096 /* Update count, check if we have executed enough methods */
1097
1098 info->count++;
1099 if (info->count >= info->max_count) {
1100 status = AE_CTRL_TERMINATE;
1101 }
1102
1103 return (status);
1104}
1105

source code of linux/drivers/acpi/acpica/dbtest.c