1105 lines · c
1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.02/*******************************************************************************3 *4 * Module Name: dbtest - Various debug-related tests5 *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_DEBUGGER16ACPI_MODULE_NAME("dbtest")17 18/* Local prototypes */19static void acpi_db_test_all_objects(void);20 21static acpi_status22acpi_db_test_one_object(acpi_handle obj_handle,23 u32 nesting_level, void *context, void **return_value);24 25static acpi_status26acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length);27 28static acpi_status29acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length);30 31static acpi_status32acpi_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_status37acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc);38 39static acpi_status40acpi_db_read_from_object(struct acpi_namespace_node *node,41 acpi_object_type expected_type,42 union acpi_object **value);43 44static acpi_status45acpi_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_status51acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle,52 u32 nesting_level,53 void *context, void **return_value);54 55/*56 * Test subcommands57 */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 065#define CMD_TEST_PREDEFINED 166 67#define BUFFER_FILL_VALUE 0xFF68 69/*70 * Support for the special debugger read/write control methods.71 * These methods are installed into the current namespace and are72 * used to read and write the various namespace objects. The point73 * 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 084definition_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#endif98 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_test120 *121 * PARAMETERS: type_arg - Subcommand122 *123 * RETURN: None124 *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(type_arg);136 temp = acpi_db_match_argument(type_arg, acpi_db_test_types);137 if (temp == ACPI_TYPE_NOT_FOUND) {138 acpi_os_printf("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_objects161 *162 * PARAMETERS: None163 *164 * RETURN: None165 *166 * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the167 * namespace by reading/writing/comparing all data objects such168 * 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(read_method_code);180 if (ACPI_FAILURE(status)) {181 acpi_os_printf182 ("%s, Could not install debugger read method\n",183 acpi_format_exception(status));184 return;185 }186 187 status =188 acpi_get_handle(NULL, ACPI_DB_READ_METHOD, &read_handle);189 if (ACPI_FAILURE(status)) {190 acpi_os_printf191 ("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(write_method_code);201 if (ACPI_FAILURE(status)) {202 acpi_os_printf203 ("%s, Could not install debugger write method\n",204 acpi_format_exception(status));205 return;206 }207 208 status =209 acpi_get_handle(NULL, ACPI_DB_WRITE_METHOD, &write_handle);210 if (ACPI_FAILURE(status)) {211 acpi_os_printf212 ("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, acpi_db_test_one_object,222 NULL, NULL, NULL);223}224 225/*******************************************************************************226 *227 * FUNCTION: acpi_db_test_one_object228 *229 * PARAMETERS: acpi_walk_callback230 *231 * RETURN: Status232 *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_status240acpi_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 or255 * 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 length295 * is larger than the size of an Integer (32 or 64 bits296 * 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("%14s: %4.4s",318 acpi_ut_get_type_name(node->type), node->name.ascii);319 320 if (!obj_desc) {321 acpi_os_printf(" 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(" 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("\n");367 return (status);368}369 370/*******************************************************************************371 *372 * FUNCTION: acpi_db_test_integer_type373 *374 * PARAMETERS: node - Parent NS node for the object375 * bit_length - Actual length of the object. Used for376 * support of arbitrary length field_unit377 * and buffer_field objects.378 *379 * RETURN: Status380 *381 * DESCRIPTION: Test read/write for an Integer-valued object. Performs a382 * write/read/compare of an arbitrary new value, then performs383 * a write/read/compare of the original value.384 *385 ******************************************************************************/386 387static acpi_status388acpi_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(" 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, &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, &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, &temp2);430 if (ACPI_FAILURE(status)) {431 goto exit;432 }433 434 if (temp2->integer.value != value_to_write) {435 acpi_os_printf(" 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, &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, &temp3);451 if (ACPI_FAILURE(status)) {452 goto exit;453 }454 455 if (temp3->integer.value != temp1->integer.value) {456 acpi_os_printf(" 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(temp1);464 }465 if (temp2) {466 acpi_os_free(temp2);467 }468 if (temp3) {469 acpi_os_free(temp3);470 }471 return (AE_OK);472}473 474/*******************************************************************************475 *476 * FUNCTION: acpi_db_test_buffer_type477 *478 * PARAMETERS: node - Parent NS node for the object479 * bit_length - Actual length of the object.480 *481 * RETURN: Status482 *483 * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a484 * write/read/compare of an arbitrary new value, then performs485 * a write/read/compare of the original value.486 *487 ******************************************************************************/488 489static acpi_status490acpi_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(" 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, &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(" %2.2X", temp1->buffer.pointer[i]);528 }529 acpi_os_printf("... ");530 531 /*532 * Write a new value.533 *534 * Handle possible extra bits at the end of the buffer. Can535 * happen for field_units larger than an integer, but the bit536 * count is not an integral number of bytes. Zero out the537 * 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, &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, &temp2);557 if (ACPI_FAILURE(status)) {558 goto exit;559 }560 561 if (memcmp(temp2->buffer.pointer, buffer, byte_length)) {562 acpi_os_printf(" 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, &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, &temp3);578 if (ACPI_FAILURE(status)) {579 goto exit;580 }581 582 if (memcmp(temp1->buffer.pointer, temp3->buffer.pointer, byte_length)) {583 acpi_os_printf(" MISMATCH 3: While restoring original buffer");584 }585 586exit:587 ACPI_FREE(buffer);588 if (temp1) {589 acpi_os_free(temp1);590 }591 if (temp2) {592 acpi_os_free(temp2);593 }594 if (temp3) {595 acpi_os_free(temp3);596 }597 return (status);598}599 600/*******************************************************************************601 *602 * FUNCTION: acpi_db_test_string_type603 *604 * PARAMETERS: node - Parent NS node for the object605 * byte_length - Actual length of the object.606 *607 * RETURN: Status608 *609 * DESCRIPTION: Test read/write for an String-valued object. Performs a610 * write/read/compare of an arbitrary new value, then performs611 * a write/read/compare of the original value.612 *613 ******************************************************************************/614 615static acpi_status616acpi_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, &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, &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, &temp2);650 if (ACPI_FAILURE(status)) {651 goto exit;652 }653 654 if (strcmp(temp2->string.pointer, value_to_write)) {655 acpi_os_printf(" 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, &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, &temp3);672 if (ACPI_FAILURE(status)) {673 goto exit;674 }675 676 if (strcmp(temp1->string.pointer, temp3->string.pointer)) {677 acpi_os_printf(" MISMATCH 3: %s, expecting %s",678 temp3->string.pointer, temp1->string.pointer);679 }680 681exit:682 if (temp1) {683 acpi_os_free(temp1);684 }685 if (temp2) {686 acpi_os_free(temp2);687 }688 if (temp3) {689 acpi_os_free(temp3);690 }691 return (status);692}693 694/*******************************************************************************695 *696 * FUNCTION: acpi_db_test_package_type697 *698 * PARAMETERS: node - Parent NS node for the object699 *700 * RETURN: Status701 *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, &temp1);714 if (ACPI_FAILURE(status)) {715 return (status);716 }717 718 acpi_os_printf(" %.2X Elements", temp1->package.count);719 acpi_os_free(temp1);720 return (status);721}722 723/*******************************************************************************724 *725 * FUNCTION: acpi_db_test_field_unit_type726 *727 * PARAMETERS: obj_desc - A field unit object728 *729 * RETURN: Status730 *731 * DESCRIPTION: Test read/write on a named field unit.732 *733 ******************************************************************************/734 735static acpi_status736acpi_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);762 if (status == AE_OK) {763 acpi_ex_write_data_to_field(ret_buffer_desc, obj_desc,764 NULL);765 acpi_ut_remove_reference(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(region_obj->region.777 space_id));778 return (status);779 780 default:781 782 acpi_os_printf783 (" %s address space is not supported in this command [%4.4s]",784 acpi_ut_get_region_name(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_object793 *794 * PARAMETERS: node - Parent NS node for the object795 * expected_type - Object type expected from the read796 * value - Where the value read is returned797 *798 * RETURN: Status799 *800 * DESCRIPTION: Performs a read from the specified object by invoking the801 * special debugger control method that reads the object. Thus,802 * the AML interpreter is doing all of the work, increasing the803 * validity of the test.804 *805 ******************************************************************************/806 807static acpi_status808acpi_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(read_handle, NULL,829 ¶m_objects, &return_obj);830 831 acpi_gbl_method_executing = FALSE;832 if (ACPI_FAILURE(status)) {833 acpi_os_printf("Could not read from object, %s",834 acpi_format_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 the847 * 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_printf852 (" Type mismatch: Expected %s, Received %s",853 acpi_ut_get_type_name(expected_type),854 acpi_ut_get_type_name(ret_value->type));855 856 acpi_os_free(return_obj.pointer);857 return (AE_TYPE);858 }859 860 *value = ret_value;861 break;862 863 default:864 865 acpi_os_printf(" Unsupported return object type, %s",866 acpi_ut_get_type_name(ret_value->type));867 868 acpi_os_free(return_obj.pointer);869 return (AE_TYPE);870 }871 872 return (status);873}874 875/*******************************************************************************876 *877 * FUNCTION: acpi_db_write_to_object878 *879 * PARAMETERS: node - Parent NS node for the object880 * value - Value to be written881 *882 * RETURN: Status883 *884 * DESCRIPTION: Performs a write to the specified object by invoking the885 * special debugger control method that writes the object. Thus,886 * the AML interpreter is doing all of the work, increasing the887 * validity of the test.888 *889 ******************************************************************************/890 891static acpi_status892acpi_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(¶ms[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(write_handle, NULL, ¶m_objects, NULL);912 acpi_gbl_method_executing = FALSE;913 914 if (ACPI_FAILURE(status)) {915 acpi_os_printf("Could not write to object, %s",916 acpi_format_exception(status));917 }918 919 return (status);920}921 922/*******************************************************************************923 *924 * FUNCTION: acpi_db_evaluate_all_predefined_names925 *926 * PARAMETERS: count_arg - Max number of methods to execute927 *928 * RETURN: None929 *930 * DESCRIPTION: Namespace batch execution. Execute predefined names in the931 * 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 acpi_db_evaluate_one_predefined_name, NULL,951 (void *)&info, NULL);952 953 acpi_os_printf("Evaluated %u predefined names in the namespace\n",954 info.count);955}956 957/*******************************************************************************958 *959 * FUNCTION: acpi_db_evaluate_one_predefined_name960 *961 * PARAMETERS: Callback from walk_namespace962 *963 * RETURN: Status964 *965 * DESCRIPTION: Batch execution module. Currently only executes predefined966 * ACPI names.967 *968 ******************************************************************************/969 970static acpi_status971acpi_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(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(obj_handle, &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 what1028 * the actual method defines. If there is a difference, then the1029 * 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_printf1065 ("%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(node, NULL, ¶m_objects, &return_obj);1086 1087 acpi_os_printf("%-32s returned %s\n",1088 pathname, acpi_format_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