drivers/acpi/acpica/dbtest.c

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