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