1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2/*******************************************************************************
   3 *
   4 * Module Name: dbtest - Various debug-related tests
   5 *
   6 ******************************************************************************/
   7
   8#include <acpi/acpi.h>
   9#include "accommon.h"
  10#include "acdebug.h"
  11#include "acnamesp.h"
  12#include "acpredef.h"
  13#include "acinterp.h"
  14
  15#define _COMPONENT          ACPI_CA_DEBUGGER
  16ACPI_MODULE_NAME("dbtest")
  17
  18/* Local prototypes */
  19static void acpi_db_test_all_objects(void);
  20
  21static acpi_status
  22acpi_db_test_one_object(acpi_handle obj_handle,
  23			u32 nesting_level, void *context, void **return_value);
  24
  25static acpi_status
  26acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length);
  27
  28static acpi_status
  29acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length);
  30
  31static acpi_status
  32acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length);
  33
  34static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node);
  35
  36static acpi_status
  37acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc);
  38
  39static acpi_status
  40acpi_db_read_from_object(struct acpi_namespace_node *node,
  41			 acpi_object_type expected_type,
  42			 union acpi_object **value);
  43
  44static acpi_status
  45acpi_db_write_to_object(struct acpi_namespace_node *node,
  46			union acpi_object *value);
  47
  48static void acpi_db_evaluate_all_predefined_names(char *count_arg);
  49
  50static acpi_status
  51acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle,
  52				     u32 nesting_level,
  53				     void *context, void **return_value);
  54
  55/*
  56 * Test subcommands
  57 */
  58static struct acpi_db_argument_info acpi_db_test_types[] = {
  59	{"OBJECTS"},
  60	{"PREDEFINED"},
  61	{NULL}			/* Must be null terminated */
  62};
  63
  64#define CMD_TEST_OBJECTS        0
  65#define CMD_TEST_PREDEFINED     1
  66
  67#define BUFFER_FILL_VALUE       0xFF
  68
  69/*
  70 * Support for the special debugger read/write control methods.
  71 * These methods are installed into the current namespace and are
  72 * used to read and write the various namespace objects. The point
  73 * is to force the AML interpreter do all of the work.
  74 */
  75#define ACPI_DB_READ_METHOD     "\\_T98"
  76#define ACPI_DB_WRITE_METHOD    "\\_T99"
  77
  78static acpi_handle read_handle = NULL;
  79static acpi_handle write_handle = NULL;
  80
  81/* ASL Definitions of the debugger read/write control methods. AML below. */
  82
  83#if 0
  84definition_block("ssdt.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
  85{
  86	method(_T98, 1, not_serialized) {	/* Read */
  87		return (de_ref_of(arg0))
  88	}
  89}
  90
  91definition_block("ssdt2.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001)
  92{
  93	method(_T99, 2, not_serialized) {	/* Write */
  94		store(arg1, arg0)
  95	}
  96}
  97#endif
  98
  99static unsigned char read_method_code[] = {
 100	0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00,	/* 00000000    "SSDT...." */
 101	0x02, 0xC9, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00,	/* 00000008    "..Intel." */
 102	0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00,	/* 00000010    "DEBUG..." */
 103	0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C,	/* 00000018    "....INTL" */
 104	0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54,	/* 00000020    "... .._T" */
 105	0x39, 0x38, 0x01, 0xA4, 0x83, 0x68	/* 00000028    "98...h"   */
 106};
 107
 108static unsigned char write_method_code[] = {
 109	0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00,	/* 00000000    "SSDT...." */
 110	0x02, 0x15, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00,	/* 00000008    "..Intel." */
 111	0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00,	/* 00000010    "DEBUG..." */
 112	0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C,	/* 00000018    "....INTL" */
 113	0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54,	/* 00000020    "... .._T" */
 114	0x39, 0x39, 0x02, 0x70, 0x69, 0x68	/* 00000028    "99.pih"   */
 115};
 116
 117/*******************************************************************************
 118 *
 119 * FUNCTION:    acpi_db_execute_test
 120 *
 121 * PARAMETERS:  type_arg        - Subcommand
 122 *
 123 * RETURN:      None
 124 *
 125 * DESCRIPTION: Execute various debug tests.
 126 *
 127 * Note: Code is prepared for future expansion of the TEST command.
 128 *
 129 ******************************************************************************/
 130
 131void acpi_db_execute_test(char *type_arg)
 132{
 133	u32 temp;
 134
 135	acpi_ut_strupr(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_objects
 161 *
 162 * PARAMETERS:  None
 163 *
 164 * RETURN:      None
 165 *
 166 * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the
 167 *              namespace by reading/writing/comparing all data objects such
 168 *              as integers, strings, buffers, fields, buffer fields, etc.
 169 *
 170 ******************************************************************************/
 171
 172static void acpi_db_test_all_objects(void)
 173{
 174	acpi_status status;
 175
 176	/* Install the debugger read-object control method if necessary */
 177
 178	if (!read_handle) {
 179		status = acpi_install_method(read_method_code);
 180		if (ACPI_FAILURE(status)) {
 181			acpi_os_printf
 182			    ("%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_printf
 191			    ("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_printf
 203			    ("%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_printf
 212			    ("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_object
 228 *
 229 * PARAMETERS:  acpi_walk_callback
 230 *
 231 * RETURN:      Status
 232 *
 233 * DESCRIPTION: Test one namespace object. Supported types are Integer,
 234 *              String, Buffer, Package, buffer_field, and field_unit.
 235 *              All other object types are simply ignored.
 236 *
 237 ******************************************************************************/
 238
 239static acpi_status
 240acpi_db_test_one_object(acpi_handle obj_handle,
 241			u32 nesting_level, void *context, void **return_value)
 242{
 243	struct acpi_namespace_node *node;
 244	union acpi_operand_object *obj_desc;
 245	acpi_object_type local_type;
 246	u32 bit_length = 0;
 247	u32 byte_length = 0;
 248	acpi_status status = AE_OK;
 249
 250	node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
 251	obj_desc = node->object;
 252
 253	/*
 254	 * For the supported types, get the actual bit length or
 255	 * byte length. Map the type to one of Integer/String/Buffer.
 256	 */
 257	switch (node->type) {
 258	case ACPI_TYPE_INTEGER:
 259
 260		/* Integer width is either 32 or 64 */
 261
 262		local_type = ACPI_TYPE_INTEGER;
 263		bit_length = acpi_gbl_integer_bit_width;
 264		break;
 265
 266	case ACPI_TYPE_STRING:
 267
 268		local_type = ACPI_TYPE_STRING;
 269		byte_length = obj_desc->string.length;
 270		break;
 271
 272	case ACPI_TYPE_BUFFER:
 273
 274		local_type = ACPI_TYPE_BUFFER;
 275		byte_length = obj_desc->buffer.length;
 276		bit_length = byte_length * 8;
 277		break;
 278
 279	case ACPI_TYPE_PACKAGE:
 280
 281		local_type = ACPI_TYPE_PACKAGE;
 282		break;
 283
 284	case ACPI_TYPE_FIELD_UNIT:
 285	case ACPI_TYPE_LOCAL_REGION_FIELD:
 286	case ACPI_TYPE_LOCAL_INDEX_FIELD:
 287	case ACPI_TYPE_LOCAL_BANK_FIELD:
 288
 289		local_type = ACPI_TYPE_FIELD_UNIT;
 290		break;
 291
 292	case ACPI_TYPE_BUFFER_FIELD:
 293		/*
 294		 * The returned object will be a Buffer if the field length
 295		 * is larger than the size of an Integer (32 or 64 bits
 296		 * depending on the DSDT version).
 297		 */
 298		local_type = ACPI_TYPE_INTEGER;
 299		if (obj_desc) {
 300			bit_length = obj_desc->common_field.bit_length;
 301			byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length);
 302			if (bit_length > acpi_gbl_integer_bit_width) {
 303				local_type = ACPI_TYPE_BUFFER;
 304			}
 305		}
 306		break;
 307
 308	default:
 309
 310		/* Ignore all non-data types - Methods, Devices, Scopes, etc. */
 311
 312		return (AE_OK);
 313	}
 314
 315	/* Emit the common prefix: Type:Name */
 316
 317	acpi_os_printf("%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_type
 373 *
 374 * PARAMETERS:  node                - Parent NS node for the object
 375 *              bit_length          - Actual length of the object. Used for
 376 *                                    support of arbitrary length field_unit
 377 *                                    and buffer_field objects.
 378 *
 379 * RETURN:      Status
 380 *
 381 * DESCRIPTION: Test read/write for an Integer-valued object. Performs a
 382 *              write/read/compare of an arbitrary new value, then performs
 383 *              a write/read/compare of the original value.
 384 *
 385 ******************************************************************************/
 386
 387static acpi_status
 388acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length)
 389{
 390	union acpi_object *temp1 = NULL;
 391	union acpi_object *temp2 = NULL;
 392	union acpi_object *temp3 = NULL;
 393	union acpi_object write_value;
 394	u64 value_to_write;
 395	acpi_status status;
 396
 397	if (bit_length > 64) {
 398		acpi_os_printf(" 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_type
 477 *
 478 * PARAMETERS:  node                - Parent NS node for the object
 479 *              bit_length          - Actual length of the object.
 480 *
 481 * RETURN:      Status
 482 *
 483 * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a
 484 *              write/read/compare of an arbitrary new value, then performs
 485 *              a write/read/compare of the original value.
 486 *
 487 ******************************************************************************/
 488
 489static acpi_status
 490acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length)
 491{
 492	union acpi_object *temp1 = NULL;
 493	union acpi_object *temp2 = NULL;
 494	union acpi_object *temp3 = NULL;
 495	u8 *buffer;
 496	union acpi_object write_value;
 497	acpi_status status;
 498	u32 byte_length;
 499	u32 i;
 500	u8 extra_bits;
 501
 502	byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length);
 503	if (byte_length == 0) {
 504		acpi_os_printf(" 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. Can
 535	 * happen for field_units larger than an integer, but the bit
 536	 * count is not an integral number of bytes. Zero out the
 537	 * unused bits.
 538	 */
 539	memset(buffer, BUFFER_FILL_VALUE, byte_length);
 540	extra_bits = bit_length % 8;
 541	if (extra_bits) {
 542		buffer[byte_length - 1] = ACPI_MASK_BITS_ABOVE(extra_bits);
 543	}
 544
 545	write_value.type = ACPI_TYPE_BUFFER;
 546	write_value.buffer.length = byte_length;
 547	write_value.buffer.pointer = buffer;
 548
 549	status = acpi_db_write_to_object(node, &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_type
 603 *
 604 * PARAMETERS:  node                - Parent NS node for the object
 605 *              byte_length         - Actual length of the object.
 606 *
 607 * RETURN:      Status
 608 *
 609 * DESCRIPTION: Test read/write for an String-valued object. Performs a
 610 *              write/read/compare of an arbitrary new value, then performs
 611 *              a write/read/compare of the original value.
 612 *
 613 ******************************************************************************/
 614
 615static acpi_status
 616acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length)
 617{
 618	union acpi_object *temp1 = NULL;
 619	union acpi_object *temp2 = NULL;
 620	union acpi_object *temp3 = NULL;
 621	char *value_to_write = "Test String from AML Debugger";
 622	union acpi_object write_value;
 623	acpi_status status;
 624
 625	/* Read the original value */
 626
 627	status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, &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_type
 697 *
 698 * PARAMETERS:  node                - Parent NS node for the object
 699 *
 700 * RETURN:      Status
 701 *
 702 * DESCRIPTION: Test read for a Package object.
 703 *
 704 ******************************************************************************/
 705
 706static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node)
 707{
 708	union acpi_object *temp1 = NULL;
 709	acpi_status status;
 710
 711	/* Read the original value */
 712
 713	status = acpi_db_read_from_object(node, ACPI_TYPE_PACKAGE, &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_type
 726 *
 727 * PARAMETERS:  obj_desc                - A field unit object
 728 *
 729 * RETURN:      Status
 730 *
 731 * DESCRIPTION: Test read/write on a named field unit.
 732 *
 733 ******************************************************************************/
 734
 735static acpi_status
 736acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc)
 737{
 738	union acpi_operand_object *region_obj;
 739	u32 bit_length = 0;
 740	u32 byte_length = 0;
 741	acpi_status status = AE_OK;
 742	union acpi_operand_object *ret_buffer_desc;
 743
 744	/* Supported spaces are memory/io/pci_config */
 745
 746	region_obj = obj_desc->field.region_obj;
 747	switch (region_obj->region.space_id) {
 748	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 749	case ACPI_ADR_SPACE_SYSTEM_IO:
 750	case ACPI_ADR_SPACE_PCI_CONFIG:
 751
 752		/* Need the interpreter to execute */
 753
 754		acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
 755		acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 756
 757		/* Exercise read-then-write */
 758
 759		status =
 760		    acpi_ex_read_data_from_field(NULL, obj_desc,
 761						 &ret_buffer_desc);
 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_printf
 783		    ("      %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_object
 793 *
 794 * PARAMETERS:  node                - Parent NS node for the object
 795 *              expected_type       - Object type expected from the read
 796 *              value               - Where the value read is returned
 797 *
 798 * RETURN:      Status
 799 *
 800 * DESCRIPTION: Performs a read from the specified object by invoking the
 801 *              special debugger control method that reads the object. Thus,
 802 *              the AML interpreter is doing all of the work, increasing the
 803 *              validity of the test.
 804 *
 805 ******************************************************************************/
 806
 807static acpi_status
 808acpi_db_read_from_object(struct acpi_namespace_node *node,
 809			 acpi_object_type expected_type,
 810			 union acpi_object **value)
 811{
 812	union acpi_object *ret_value;
 813	struct acpi_object_list param_objects;
 814	union acpi_object params[2];
 815	struct acpi_buffer return_obj;
 816	acpi_status status;
 817
 818	params[0].type = ACPI_TYPE_LOCAL_REFERENCE;
 819	params[0].reference.actual_type = node->type;
 820	params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node);
 821
 822	param_objects.count = 1;
 823	param_objects.pointer = params;
 824
 825	return_obj.length = ACPI_ALLOCATE_BUFFER;
 826
 827	acpi_gbl_method_executing = TRUE;
 828	status = acpi_evaluate_object(read_handle, NULL,
 829				      &param_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 the
 847		 * Integer/Buffer case (when a field is larger than an Integer,
 848		 * it should return a Buffer).
 849		 */
 850		if (ret_value->type != expected_type) {
 851			acpi_os_printf
 852			    (" 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_object
 878 *
 879 * PARAMETERS:  node                - Parent NS node for the object
 880 *              value               - Value to be written
 881 *
 882 * RETURN:      Status
 883 *
 884 * DESCRIPTION: Performs a write to the specified object by invoking the
 885 *              special debugger control method that writes the object. Thus,
 886 *              the AML interpreter is doing all of the work, increasing the
 887 *              validity of the test.
 888 *
 889 ******************************************************************************/
 890
 891static acpi_status
 892acpi_db_write_to_object(struct acpi_namespace_node *node,
 893			union acpi_object *value)
 894{
 895	struct acpi_object_list param_objects;
 896	union acpi_object params[2];
 897	acpi_status status;
 898
 899	params[0].type = ACPI_TYPE_LOCAL_REFERENCE;
 900	params[0].reference.actual_type = node->type;
 901	params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node);
 902
 903	/* Copy the incoming user parameter */
 904
 905	memcpy(&params[1], value, sizeof(union acpi_object));
 906
 907	param_objects.count = 2;
 908	param_objects.pointer = params;
 909
 910	acpi_gbl_method_executing = TRUE;
 911	status = acpi_evaluate_object(write_handle, NULL, &param_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_names
 925 *
 926 * PARAMETERS:  count_arg           - Max number of methods to execute
 927 *
 928 * RETURN:      None
 929 *
 930 * DESCRIPTION: Namespace batch execution. Execute predefined names in the
 931 *              namespace, up to the max count, if specified.
 932 *
 933 ******************************************************************************/
 934
 935static void acpi_db_evaluate_all_predefined_names(char *count_arg)
 936{
 937	struct acpi_db_execute_walk info;
 938
 939	info.count = 0;
 940	info.max_count = ACPI_UINT32_MAX;
 941
 942	if (count_arg) {
 943		info.max_count = strtoul(count_arg, NULL, 0);
 944	}
 945
 946	/* Search all nodes in namespace */
 947
 948	(void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 949				  ACPI_UINT32_MAX,
 950				  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_name
 960 *
 961 * PARAMETERS:  Callback from walk_namespace
 962 *
 963 * RETURN:      Status
 964 *
 965 * DESCRIPTION: Batch execution module. Currently only executes predefined
 966 *              ACPI names.
 967 *
 968 ******************************************************************************/
 969
 970static acpi_status
 971acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle,
 972				     u32 nesting_level,
 973				     void *context, void **return_value)
 974{
 975	struct acpi_namespace_node *node =
 976	    (struct acpi_namespace_node *)obj_handle;
 977	struct acpi_db_execute_walk *info =
 978	    (struct acpi_db_execute_walk *)context;
 979	char *pathname;
 980	const union acpi_predefined_info *predefined;
 981	struct acpi_device_info *obj_info;
 982	struct acpi_object_list param_objects;
 983	union acpi_object params[ACPI_METHOD_NUM_ARGS];
 984	union acpi_object *this_param;
 985	struct acpi_buffer return_obj;
 986	acpi_status status;
 987	u16 arg_type_list;
 988	u8 arg_count;
 989	u8 arg_type;
 990	u32 i;
 991
 992	/* The name must be a predefined ACPI name */
 993
 994	predefined = acpi_ut_match_predefined_method(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 what
1028		 * the actual method defines. If there is a difference, then the
1029		 * method is wrong and a warning will be issued during execution.
1030		 */
1031		this_param = params;
1032		for (i = 0; i < arg_count; i++) {
1033			arg_type = METHOD_GET_NEXT_TYPE(arg_type_list);
1034			this_param->type = arg_type;
1035
1036			switch (arg_type) {
1037			case ACPI_TYPE_INTEGER:
1038
1039				this_param->integer.value = 1;
1040				break;
1041
1042			case ACPI_TYPE_STRING:
1043
1044				this_param->string.pointer =
1045				    "This is the default argument string";
1046				this_param->string.length =
1047				    strlen(this_param->string.pointer);
1048				break;
1049
1050			case ACPI_TYPE_BUFFER:
1051
1052				this_param->buffer.pointer = (u8 *)params;	/* just a garbage buffer */
1053				this_param->buffer.length = 48;
1054				break;
1055
1056			case ACPI_TYPE_PACKAGE:
1057
1058				this_param->package.elements = NULL;
1059				this_param->package.count = 0;
1060				break;
1061
1062			default:
1063
1064				acpi_os_printf
1065				    ("%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, &param_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}