1 /******************************************************************************* 2 * 3 * Module Name: dbtest - Various debug-related tests 4 * 5 ******************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #include "acpi.h" 153 #include "accommon.h" 154 #include "acdebug.h" 155 #include "acnamesp.h" 156 #include "acpredef.h" 157 #include "acinterp.h" 158 159 #ifdef ACPI_DEBUGGER 160 161 #define _COMPONENT ACPI_CA_DEBUGGER 162 ACPI_MODULE_NAME ("dbtest") 163 164 165 /* Local prototypes */ 166 167 static void 168 AcpiDbTestAllObjects ( 169 void); 170 171 static ACPI_STATUS 172 AcpiDbTestOneObject ( 173 ACPI_HANDLE ObjHandle, 174 UINT32 NestingLevel, 175 void *Context, 176 void **ReturnValue); 177 178 static ACPI_STATUS 179 AcpiDbTestIntegerType ( 180 ACPI_NAMESPACE_NODE *Node, 181 UINT32 BitLength); 182 183 static ACPI_STATUS 184 AcpiDbTestBufferType ( 185 ACPI_NAMESPACE_NODE *Node, 186 UINT32 BitLength); 187 188 static ACPI_STATUS 189 AcpiDbTestStringType ( 190 ACPI_NAMESPACE_NODE *Node, 191 UINT32 ByteLength); 192 193 static ACPI_STATUS 194 AcpiDbTestPackageType ( 195 ACPI_NAMESPACE_NODE *Node); 196 197 static ACPI_STATUS 198 AcpiDbTestFieldUnitType ( 199 ACPI_OPERAND_OBJECT *ObjDesc); 200 201 static ACPI_STATUS 202 AcpiDbReadFromObject ( 203 ACPI_NAMESPACE_NODE *Node, 204 ACPI_OBJECT_TYPE ExpectedType, 205 ACPI_OBJECT **Value); 206 207 static ACPI_STATUS 208 AcpiDbWriteToObject ( 209 ACPI_NAMESPACE_NODE *Node, 210 ACPI_OBJECT *Value); 211 212 static void 213 AcpiDbEvaluateAllPredefinedNames ( 214 char *CountArg); 215 216 static ACPI_STATUS 217 AcpiDbEvaluateOnePredefinedName ( 218 ACPI_HANDLE ObjHandle, 219 UINT32 NestingLevel, 220 void *Context, 221 void **ReturnValue); 222 223 /* 224 * Test subcommands 225 */ 226 static ACPI_DB_ARGUMENT_INFO AcpiDbTestTypes [] = 227 { 228 {"OBJECTS"}, 229 {"PREDEFINED"}, 230 {NULL} /* Must be null terminated */ 231 }; 232 233 #define CMD_TEST_OBJECTS 0 234 #define CMD_TEST_PREDEFINED 1 235 236 #define BUFFER_FILL_VALUE 0xFF 237 238 /* 239 * Support for the special debugger read/write control methods. 240 * These methods are installed into the current namespace and are 241 * used to read and write the various namespace objects. The point 242 * is to force the AML interpreter do all of the work. 243 */ 244 #define ACPI_DB_READ_METHOD "\\_T98" 245 #define ACPI_DB_WRITE_METHOD "\\_T99" 246 247 static ACPI_HANDLE ReadHandle = NULL; 248 static ACPI_HANDLE WriteHandle = NULL; 249 250 /* ASL Definitions of the debugger read/write control methods. AML below. */ 251 252 #if 0 253 DefinitionBlock ("ssdt.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001) 254 { 255 Method (_T98, 1, NotSerialized) /* Read */ 256 { 257 Return (DeRefOf (Arg0)) 258 } 259 } 260 DefinitionBlock ("ssdt2.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001) 261 { 262 Method (_T99, 2, NotSerialized) /* Write */ 263 { 264 Store (Arg1, Arg0) 265 } 266 } 267 #endif 268 269 static unsigned char ReadMethodCode[] = 270 { 271 0x53,0x53,0x44,0x54,0x2E,0x00,0x00,0x00, /* 00000000 "SSDT...." */ 272 0x02,0xC9,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */ 273 0x44,0x45,0x42,0x55,0x47,0x00,0x00,0x00, /* 00000010 "DEBUG..." */ 274 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */ 275 0x18,0x12,0x13,0x20,0x14,0x09,0x5F,0x54, /* 00000020 "... .._T" */ 276 0x39,0x38,0x01,0xA4,0x83,0x68 /* 00000028 "98...h" */ 277 }; 278 279 static unsigned char WriteMethodCode[] = 280 { 281 0x53,0x53,0x44,0x54,0x2E,0x00,0x00,0x00, /* 00000000 "SSDT...." */ 282 0x02,0x15,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */ 283 0x44,0x45,0x42,0x55,0x47,0x00,0x00,0x00, /* 00000010 "DEBUG..." */ 284 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */ 285 0x18,0x12,0x13,0x20,0x14,0x09,0x5F,0x54, /* 00000020 "... .._T" */ 286 0x39,0x39,0x02,0x70,0x69,0x68 /* 00000028 "99.pih" */ 287 }; 288 289 290 /******************************************************************************* 291 * 292 * FUNCTION: AcpiDbExecuteTest 293 * 294 * PARAMETERS: TypeArg - Subcommand 295 * 296 * RETURN: None 297 * 298 * DESCRIPTION: Execute various debug tests. 299 * 300 * Note: Code is prepared for future expansion of the TEST command. 301 * 302 ******************************************************************************/ 303 304 void 305 AcpiDbExecuteTest ( 306 char *TypeArg) 307 { 308 UINT32 Temp; 309 310 311 AcpiUtStrupr (TypeArg); 312 Temp = AcpiDbMatchArgument (TypeArg, AcpiDbTestTypes); 313 if (Temp == ACPI_TYPE_NOT_FOUND) 314 { 315 AcpiOsPrintf ("Invalid or unsupported argument\n"); 316 return; 317 } 318 319 switch (Temp) 320 { 321 case CMD_TEST_OBJECTS: 322 323 AcpiDbTestAllObjects (); 324 break; 325 326 case CMD_TEST_PREDEFINED: 327 328 AcpiDbEvaluateAllPredefinedNames (NULL); 329 break; 330 331 default: 332 break; 333 } 334 } 335 336 337 /******************************************************************************* 338 * 339 * FUNCTION: AcpiDbTestAllObjects 340 * 341 * PARAMETERS: None 342 * 343 * RETURN: None 344 * 345 * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the 346 * namespace by reading/writing/comparing all data objects such 347 * as integers, strings, buffers, fields, buffer fields, etc. 348 * 349 ******************************************************************************/ 350 351 static void 352 AcpiDbTestAllObjects ( 353 void) 354 { 355 ACPI_STATUS Status; 356 357 358 /* Install the debugger read-object control method if necessary */ 359 360 if (!ReadHandle) 361 { 362 Status = AcpiInstallMethod (ReadMethodCode); 363 if (ACPI_FAILURE (Status)) 364 { 365 AcpiOsPrintf ("%s, Could not install debugger read method\n", 366 AcpiFormatException (Status)); 367 return; 368 } 369 370 Status = AcpiGetHandle (NULL, ACPI_DB_READ_METHOD, &ReadHandle); 371 if (ACPI_FAILURE (Status)) 372 { 373 AcpiOsPrintf ("Could not obtain handle for debug method %s\n", 374 ACPI_DB_READ_METHOD); 375 return; 376 } 377 } 378 379 /* Install the debugger write-object control method if necessary */ 380 381 if (!WriteHandle) 382 { 383 Status = AcpiInstallMethod (WriteMethodCode); 384 if (ACPI_FAILURE (Status)) 385 { 386 AcpiOsPrintf ("%s, Could not install debugger write method\n", 387 AcpiFormatException (Status)); 388 return; 389 } 390 391 Status = AcpiGetHandle (NULL, ACPI_DB_WRITE_METHOD, &WriteHandle); 392 if (ACPI_FAILURE (Status)) 393 { 394 AcpiOsPrintf ("Could not obtain handle for debug method %s\n", 395 ACPI_DB_WRITE_METHOD); 396 return; 397 } 398 } 399 400 /* Walk the entire namespace, testing each supported named data object */ 401 402 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 403 ACPI_UINT32_MAX, AcpiDbTestOneObject, NULL, NULL, NULL); 404 } 405 406 407 /******************************************************************************* 408 * 409 * FUNCTION: AcpiDbTestOneObject 410 * 411 * PARAMETERS: ACPI_WALK_CALLBACK 412 * 413 * RETURN: Status 414 * 415 * DESCRIPTION: Test one namespace object. Supported types are Integer, 416 * String, Buffer, Package, BufferField, and FieldUnit. 417 * All other object types are simply ignored. 418 * 419 ******************************************************************************/ 420 421 static ACPI_STATUS 422 AcpiDbTestOneObject ( 423 ACPI_HANDLE ObjHandle, 424 UINT32 NestingLevel, 425 void *Context, 426 void **ReturnValue) 427 { 428 ACPI_NAMESPACE_NODE *Node; 429 ACPI_OPERAND_OBJECT *ObjDesc; 430 ACPI_OBJECT_TYPE LocalType; 431 UINT32 BitLength = 0; 432 UINT32 ByteLength = 0; 433 ACPI_STATUS Status = AE_OK; 434 435 436 Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle); 437 ObjDesc = Node->Object; 438 439 /* 440 * For the supported types, get the actual bit length or 441 * byte length. Map the type to one of Integer/String/Buffer. 442 */ 443 switch (Node->Type) 444 { 445 case ACPI_TYPE_INTEGER: 446 447 /* Integer width is either 32 or 64 */ 448 449 LocalType = ACPI_TYPE_INTEGER; 450 BitLength = AcpiGbl_IntegerBitWidth; 451 break; 452 453 case ACPI_TYPE_STRING: 454 455 LocalType = ACPI_TYPE_STRING; 456 ByteLength = ObjDesc->String.Length; 457 break; 458 459 case ACPI_TYPE_BUFFER: 460 461 LocalType = ACPI_TYPE_BUFFER; 462 ByteLength = ObjDesc->Buffer.Length; 463 BitLength = ByteLength * 8; 464 break; 465 466 case ACPI_TYPE_PACKAGE: 467 468 LocalType = ACPI_TYPE_PACKAGE; 469 break; 470 471 case ACPI_TYPE_FIELD_UNIT: 472 case ACPI_TYPE_LOCAL_REGION_FIELD: 473 case ACPI_TYPE_LOCAL_INDEX_FIELD: 474 case ACPI_TYPE_LOCAL_BANK_FIELD: 475 476 LocalType = ACPI_TYPE_FIELD_UNIT; 477 break; 478 479 case ACPI_TYPE_BUFFER_FIELD: 480 /* 481 * The returned object will be a Buffer if the field length 482 * is larger than the size of an Integer (32 or 64 bits 483 * depending on the DSDT version). 484 */ 485 LocalType = ACPI_TYPE_INTEGER; 486 if (ObjDesc) 487 { 488 BitLength = ObjDesc->CommonField.BitLength; 489 ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength); 490 if (BitLength > AcpiGbl_IntegerBitWidth) 491 { 492 LocalType = ACPI_TYPE_BUFFER; 493 } 494 } 495 break; 496 497 default: 498 499 /* Ignore all non-data types - Methods, Devices, Scopes, etc. */ 500 501 return (AE_OK); 502 } 503 504 /* Emit the common prefix: Type:Name */ 505 506 AcpiOsPrintf ("%14s: %4.4s", 507 AcpiUtGetTypeName (Node->Type), Node->Name.Ascii); 508 509 if (!ObjDesc) 510 { 511 AcpiOsPrintf (" No attached sub-object, ignoring\n"); 512 return (AE_OK); 513 } 514 515 /* At this point, we have resolved the object to one of the major types */ 516 517 switch (LocalType) 518 { 519 case ACPI_TYPE_INTEGER: 520 521 Status = AcpiDbTestIntegerType (Node, BitLength); 522 break; 523 524 case ACPI_TYPE_STRING: 525 526 Status = AcpiDbTestStringType (Node, ByteLength); 527 break; 528 529 case ACPI_TYPE_BUFFER: 530 531 Status = AcpiDbTestBufferType (Node, BitLength); 532 break; 533 534 case ACPI_TYPE_PACKAGE: 535 536 Status = AcpiDbTestPackageType (Node); 537 break; 538 539 case ACPI_TYPE_FIELD_UNIT: 540 541 Status = AcpiDbTestFieldUnitType (ObjDesc); 542 break; 543 544 default: 545 546 AcpiOsPrintf (" Ignoring, type not implemented (%2.2X)", 547 LocalType); 548 break; 549 } 550 551 /* Exit on error, but don't abort the namespace walk */ 552 553 if (ACPI_FAILURE (Status)) 554 { 555 Status = AE_OK; 556 } 557 558 AcpiOsPrintf ("\n"); 559 return (Status); 560 } 561 562 563 /******************************************************************************* 564 * 565 * FUNCTION: AcpiDbTestIntegerType 566 * 567 * PARAMETERS: Node - Parent NS node for the object 568 * BitLength - Actual length of the object. Used for 569 * support of arbitrary length FieldUnit 570 * and BufferField objects. 571 * 572 * RETURN: Status 573 * 574 * DESCRIPTION: Test read/write for an Integer-valued object. Performs a 575 * write/read/compare of an arbitrary new value, then performs 576 * a write/read/compare of the original value. 577 * 578 ******************************************************************************/ 579 580 static ACPI_STATUS 581 AcpiDbTestIntegerType ( 582 ACPI_NAMESPACE_NODE *Node, 583 UINT32 BitLength) 584 { 585 ACPI_OBJECT *Temp1 = NULL; 586 ACPI_OBJECT *Temp2 = NULL; 587 ACPI_OBJECT *Temp3 = NULL; 588 ACPI_OBJECT WriteValue; 589 UINT64 ValueToWrite; 590 ACPI_STATUS Status; 591 592 593 if (BitLength > 64) 594 { 595 AcpiOsPrintf (" Invalid length for an Integer: %u", BitLength); 596 return (AE_OK); 597 } 598 599 /* Read the original value */ 600 601 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp1); 602 if (ACPI_FAILURE (Status)) 603 { 604 return (Status); 605 } 606 607 AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " %8.8X%8.8X", 608 BitLength, ACPI_ROUND_BITS_UP_TO_BYTES (BitLength), 609 ACPI_FORMAT_UINT64 (Temp1->Integer.Value)); 610 611 ValueToWrite = ACPI_UINT64_MAX >> (64 - BitLength); 612 if (Temp1->Integer.Value == ValueToWrite) 613 { 614 ValueToWrite = 0; 615 } 616 /* Write a new value */ 617 618 WriteValue.Type = ACPI_TYPE_INTEGER; 619 WriteValue.Integer.Value = ValueToWrite; 620 Status = AcpiDbWriteToObject (Node, &WriteValue); 621 if (ACPI_FAILURE (Status)) 622 { 623 goto Exit; 624 } 625 626 /* Ensure that we can read back the new value */ 627 628 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp2); 629 if (ACPI_FAILURE (Status)) 630 { 631 goto Exit; 632 } 633 634 if (Temp2->Integer.Value != ValueToWrite) 635 { 636 AcpiOsPrintf (" MISMATCH 2: %8.8X%8.8X, expecting %8.8X%8.8X", 637 ACPI_FORMAT_UINT64 (Temp2->Integer.Value), 638 ACPI_FORMAT_UINT64 (ValueToWrite)); 639 } 640 641 /* Write back the original value */ 642 643 WriteValue.Integer.Value = Temp1->Integer.Value; 644 Status = AcpiDbWriteToObject (Node, &WriteValue); 645 if (ACPI_FAILURE (Status)) 646 { 647 goto Exit; 648 } 649 650 /* Ensure that we can read back the original value */ 651 652 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp3); 653 if (ACPI_FAILURE (Status)) 654 { 655 goto Exit; 656 } 657 658 if (Temp3->Integer.Value != Temp1->Integer.Value) 659 { 660 AcpiOsPrintf (" MISMATCH 3: %8.8X%8.8X, expecting %8.8X%8.8X", 661 ACPI_FORMAT_UINT64 (Temp3->Integer.Value), 662 ACPI_FORMAT_UINT64 (Temp1->Integer.Value)); 663 } 664 665 Exit: 666 if (Temp1) {AcpiOsFree (Temp1);} 667 if (Temp2) {AcpiOsFree (Temp2);} 668 if (Temp3) {AcpiOsFree (Temp3);} 669 return (AE_OK); 670 } 671 672 673 /******************************************************************************* 674 * 675 * FUNCTION: AcpiDbTestBufferType 676 * 677 * PARAMETERS: Node - Parent NS node for the object 678 * BitLength - Actual length of the object. 679 * 680 * RETURN: Status 681 * 682 * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a 683 * write/read/compare of an arbitrary new value, then performs 684 * a write/read/compare of the original value. 685 * 686 ******************************************************************************/ 687 688 static ACPI_STATUS 689 AcpiDbTestBufferType ( 690 ACPI_NAMESPACE_NODE *Node, 691 UINT32 BitLength) 692 { 693 ACPI_OBJECT *Temp1 = NULL; 694 ACPI_OBJECT *Temp2 = NULL; 695 ACPI_OBJECT *Temp3 = NULL; 696 UINT8 *Buffer; 697 ACPI_OBJECT WriteValue; 698 ACPI_STATUS Status; 699 UINT32 ByteLength; 700 UINT32 i; 701 UINT8 ExtraBits; 702 703 704 ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength); 705 if (ByteLength == 0) 706 { 707 AcpiOsPrintf (" Ignoring zero length buffer"); 708 return (AE_OK); 709 } 710 711 /* Allocate a local buffer */ 712 713 Buffer = ACPI_ALLOCATE_ZEROED (ByteLength); 714 if (!Buffer) 715 { 716 return (AE_NO_MEMORY); 717 } 718 719 /* Read the original value */ 720 721 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp1); 722 if (ACPI_FAILURE (Status)) 723 { 724 goto Exit; 725 } 726 727 /* Emit a few bytes of the buffer */ 728 729 AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT, BitLength, Temp1->Buffer.Length); 730 for (i = 0; ((i < 8) && (i < ByteLength)); i++) 731 { 732 AcpiOsPrintf (" %2.2X", Temp1->Buffer.Pointer[i]); 733 } 734 AcpiOsPrintf ("... "); 735 736 /* 737 * Write a new value. 738 * 739 * Handle possible extra bits at the end of the buffer. Can 740 * happen for FieldUnits larger than an integer, but the bit 741 * count is not an integral number of bytes. Zero out the 742 * unused bits. 743 */ 744 memset (Buffer, BUFFER_FILL_VALUE, ByteLength); 745 ExtraBits = BitLength % 8; 746 if (ExtraBits) 747 { 748 Buffer [ByteLength - 1] = ACPI_MASK_BITS_ABOVE (ExtraBits); 749 } 750 751 WriteValue.Type = ACPI_TYPE_BUFFER; 752 WriteValue.Buffer.Length = ByteLength; 753 WriteValue.Buffer.Pointer = Buffer; 754 755 Status = AcpiDbWriteToObject (Node, &WriteValue); 756 if (ACPI_FAILURE (Status)) 757 { 758 goto Exit; 759 } 760 761 /* Ensure that we can read back the new value */ 762 763 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp2); 764 if (ACPI_FAILURE (Status)) 765 { 766 goto Exit; 767 } 768 769 if (memcmp (Temp2->Buffer.Pointer, Buffer, ByteLength)) 770 { 771 AcpiOsPrintf (" MISMATCH 2: New buffer value"); 772 } 773 774 /* Write back the original value */ 775 776 WriteValue.Buffer.Length = ByteLength; 777 WriteValue.Buffer.Pointer = Temp1->Buffer.Pointer; 778 779 Status = AcpiDbWriteToObject (Node, &WriteValue); 780 if (ACPI_FAILURE (Status)) 781 { 782 goto Exit; 783 } 784 785 /* Ensure that we can read back the original value */ 786 787 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_BUFFER, &Temp3); 788 if (ACPI_FAILURE (Status)) 789 { 790 goto Exit; 791 } 792 793 if (memcmp (Temp1->Buffer.Pointer, 794 Temp3->Buffer.Pointer, ByteLength)) 795 { 796 AcpiOsPrintf (" MISMATCH 3: While restoring original buffer"); 797 } 798 799 Exit: 800 ACPI_FREE (Buffer); 801 if (Temp1) {AcpiOsFree (Temp1);} 802 if (Temp2) {AcpiOsFree (Temp2);} 803 if (Temp3) {AcpiOsFree (Temp3);} 804 return (Status); 805 } 806 807 808 /******************************************************************************* 809 * 810 * FUNCTION: AcpiDbTestStringType 811 * 812 * PARAMETERS: Node - Parent NS node for the object 813 * ByteLength - Actual length of the object. 814 * 815 * RETURN: Status 816 * 817 * DESCRIPTION: Test read/write for an String-valued object. Performs a 818 * write/read/compare of an arbitrary new value, then performs 819 * a write/read/compare of the original value. 820 * 821 ******************************************************************************/ 822 823 static ACPI_STATUS 824 AcpiDbTestStringType ( 825 ACPI_NAMESPACE_NODE *Node, 826 UINT32 ByteLength) 827 { 828 ACPI_OBJECT *Temp1 = NULL; 829 ACPI_OBJECT *Temp2 = NULL; 830 ACPI_OBJECT *Temp3 = NULL; 831 char *ValueToWrite = "Test String from AML Debugger"; 832 ACPI_OBJECT WriteValue; 833 ACPI_STATUS Status; 834 835 836 /* Read the original value */ 837 838 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp1); 839 if (ACPI_FAILURE (Status)) 840 { 841 return (Status); 842 } 843 844 AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " \"%s\"", (Temp1->String.Length * 8), 845 Temp1->String.Length, Temp1->String.Pointer); 846 847 /* Write a new value */ 848 849 WriteValue.Type = ACPI_TYPE_STRING; 850 WriteValue.String.Length = strlen (ValueToWrite); 851 WriteValue.String.Pointer = ValueToWrite; 852 853 Status = AcpiDbWriteToObject (Node, &WriteValue); 854 if (ACPI_FAILURE (Status)) 855 { 856 goto Exit; 857 } 858 859 /* Ensure that we can read back the new value */ 860 861 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp2); 862 if (ACPI_FAILURE (Status)) 863 { 864 goto Exit; 865 } 866 867 if (strcmp (Temp2->String.Pointer, ValueToWrite)) 868 { 869 AcpiOsPrintf (" MISMATCH 2: %s, expecting %s", 870 Temp2->String.Pointer, ValueToWrite); 871 } 872 873 /* Write back the original value */ 874 875 WriteValue.String.Length = strlen (Temp1->String.Pointer); 876 WriteValue.String.Pointer = Temp1->String.Pointer; 877 878 Status = AcpiDbWriteToObject (Node, &WriteValue); 879 if (ACPI_FAILURE (Status)) 880 { 881 goto Exit; 882 } 883 884 /* Ensure that we can read back the original value */ 885 886 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_STRING, &Temp3); 887 if (ACPI_FAILURE (Status)) 888 { 889 goto Exit; 890 } 891 892 if (strcmp (Temp1->String.Pointer, Temp3->String.Pointer)) 893 { 894 AcpiOsPrintf (" MISMATCH 3: %s, expecting %s", 895 Temp3->String.Pointer, Temp1->String.Pointer); 896 } 897 898 Exit: 899 if (Temp1) {AcpiOsFree (Temp1);} 900 if (Temp2) {AcpiOsFree (Temp2);} 901 if (Temp3) {AcpiOsFree (Temp3);} 902 return (Status); 903 } 904 905 906 /******************************************************************************* 907 * 908 * FUNCTION: AcpiDbTestPackageType 909 * 910 * PARAMETERS: Node - Parent NS node for the object 911 * 912 * RETURN: Status 913 * 914 * DESCRIPTION: Test read for a Package object. 915 * 916 ******************************************************************************/ 917 918 static ACPI_STATUS 919 AcpiDbTestPackageType ( 920 ACPI_NAMESPACE_NODE *Node) 921 { 922 ACPI_OBJECT *Temp1 = NULL; 923 ACPI_STATUS Status; 924 925 926 /* Read the original value */ 927 928 Status = AcpiDbReadFromObject (Node, ACPI_TYPE_PACKAGE, &Temp1); 929 if (ACPI_FAILURE (Status)) 930 { 931 return (Status); 932 } 933 934 AcpiOsPrintf (" %.2X Elements", Temp1->Package.Count); 935 AcpiOsFree (Temp1); 936 return (Status); 937 } 938 939 940 /******************************************************************************* 941 * 942 * FUNCTION: AcpiDbTestFieldUnitType 943 * 944 * PARAMETERS: ObjDesc - A field unit object 945 * 946 * RETURN: Status 947 * 948 * DESCRIPTION: Test read/write on a named field unit. 949 * 950 ******************************************************************************/ 951 952 static ACPI_STATUS 953 AcpiDbTestFieldUnitType ( 954 ACPI_OPERAND_OBJECT *ObjDesc) 955 { 956 ACPI_OPERAND_OBJECT *RegionObj; 957 UINT32 BitLength = 0; 958 UINT32 ByteLength = 0; 959 ACPI_STATUS Status = AE_OK; 960 ACPI_OPERAND_OBJECT *RetBufferDesc; 961 962 963 /* Supported spaces are memory/io/pci_config */ 964 965 RegionObj = ObjDesc->Field.RegionObj; 966 switch (RegionObj->Region.SpaceId) 967 { 968 case ACPI_ADR_SPACE_SYSTEM_MEMORY: 969 case ACPI_ADR_SPACE_SYSTEM_IO: 970 case ACPI_ADR_SPACE_PCI_CONFIG: 971 972 /* Need the interpreter to execute */ 973 974 AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER); 975 AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 976 977 /* Exercise read-then-write */ 978 979 Status = AcpiExReadDataFromField (NULL, ObjDesc, &RetBufferDesc); 980 if (Status == AE_OK) 981 { 982 AcpiExWriteDataToField (RetBufferDesc, ObjDesc, NULL); 983 AcpiUtRemoveReference (RetBufferDesc); 984 } 985 986 AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 987 AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER); 988 989 BitLength = ObjDesc->CommonField.BitLength; 990 ByteLength = ACPI_ROUND_BITS_UP_TO_BYTES (BitLength); 991 992 AcpiOsPrintf (ACPI_DEBUG_LENGTH_FORMAT " [%s]", BitLength, 993 ByteLength, AcpiUtGetRegionName (RegionObj->Region.SpaceId)); 994 return (Status); 995 996 default: 997 998 AcpiOsPrintf ( 999 " %s address space is not supported in this command [%4.4s]", 1000 AcpiUtGetRegionName (RegionObj->Region.SpaceId), 1001 RegionObj->Region.Node->Name.Ascii); 1002 return (AE_OK); 1003 } 1004 } 1005 1006 1007 /******************************************************************************* 1008 * 1009 * FUNCTION: AcpiDbReadFromObject 1010 * 1011 * PARAMETERS: Node - Parent NS node for the object 1012 * ExpectedType - Object type expected from the read 1013 * Value - Where the value read is returned 1014 * 1015 * RETURN: Status 1016 * 1017 * DESCRIPTION: Performs a read from the specified object by invoking the 1018 * special debugger control method that reads the object. Thus, 1019 * the AML interpreter is doing all of the work, increasing the 1020 * validity of the test. 1021 * 1022 ******************************************************************************/ 1023 1024 static ACPI_STATUS 1025 AcpiDbReadFromObject ( 1026 ACPI_NAMESPACE_NODE *Node, 1027 ACPI_OBJECT_TYPE ExpectedType, 1028 ACPI_OBJECT **Value) 1029 { 1030 ACPI_OBJECT *RetValue; 1031 ACPI_OBJECT_LIST ParamObjects; 1032 ACPI_OBJECT Params[2]; 1033 ACPI_BUFFER ReturnObj; 1034 ACPI_STATUS Status; 1035 1036 1037 Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE; 1038 Params[0].Reference.ActualType = Node->Type; 1039 Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node); 1040 1041 ParamObjects.Count = 1; 1042 ParamObjects.Pointer = Params; 1043 1044 ReturnObj.Length = ACPI_ALLOCATE_BUFFER; 1045 1046 AcpiGbl_MethodExecuting = TRUE; 1047 Status = AcpiEvaluateObject (ReadHandle, NULL, 1048 &ParamObjects, &ReturnObj); 1049 1050 AcpiGbl_MethodExecuting = FALSE; 1051 if (ACPI_FAILURE (Status)) 1052 { 1053 AcpiOsPrintf ("Could not read from object, %s", 1054 AcpiFormatException (Status)); 1055 return (Status); 1056 } 1057 1058 RetValue = (ACPI_OBJECT *) ReturnObj.Pointer; 1059 1060 switch (RetValue->Type) 1061 { 1062 case ACPI_TYPE_INTEGER: 1063 case ACPI_TYPE_BUFFER: 1064 case ACPI_TYPE_STRING: 1065 case ACPI_TYPE_PACKAGE: 1066 /* 1067 * Did we receive the type we wanted? Most important for the 1068 * Integer/Buffer case (when a field is larger than an Integer, 1069 * it should return a Buffer). 1070 */ 1071 if (RetValue->Type != ExpectedType) 1072 { 1073 AcpiOsPrintf (" Type mismatch: Expected %s, Received %s", 1074 AcpiUtGetTypeName (ExpectedType), 1075 AcpiUtGetTypeName (RetValue->Type)); 1076 1077 AcpiOsFree (ReturnObj.Pointer); 1078 return (AE_TYPE); 1079 } 1080 1081 *Value = RetValue; 1082 break; 1083 1084 default: 1085 1086 AcpiOsPrintf (" Unsupported return object type, %s", 1087 AcpiUtGetTypeName (RetValue->Type)); 1088 1089 AcpiOsFree (ReturnObj.Pointer); 1090 return (AE_TYPE); 1091 } 1092 1093 return (Status); 1094 } 1095 1096 1097 /******************************************************************************* 1098 * 1099 * FUNCTION: AcpiDbWriteToObject 1100 * 1101 * PARAMETERS: Node - Parent NS node for the object 1102 * Value - Value to be written 1103 * 1104 * RETURN: Status 1105 * 1106 * DESCRIPTION: Performs a write to the specified object by invoking the 1107 * special debugger control method that writes the object. Thus, 1108 * the AML interpreter is doing all of the work, increasing the 1109 * validity of the test. 1110 * 1111 ******************************************************************************/ 1112 1113 static ACPI_STATUS 1114 AcpiDbWriteToObject ( 1115 ACPI_NAMESPACE_NODE *Node, 1116 ACPI_OBJECT *Value) 1117 { 1118 ACPI_OBJECT_LIST ParamObjects; 1119 ACPI_OBJECT Params[2]; 1120 ACPI_STATUS Status; 1121 1122 1123 Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE; 1124 Params[0].Reference.ActualType = Node->Type; 1125 Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node); 1126 1127 /* Copy the incoming user parameter */ 1128 1129 memcpy (&Params[1], Value, sizeof (ACPI_OBJECT)); 1130 1131 ParamObjects.Count = 2; 1132 ParamObjects.Pointer = Params; 1133 1134 AcpiGbl_MethodExecuting = TRUE; 1135 Status = AcpiEvaluateObject (WriteHandle, NULL, &ParamObjects, NULL); 1136 AcpiGbl_MethodExecuting = FALSE; 1137 1138 if (ACPI_FAILURE (Status)) 1139 { 1140 AcpiOsPrintf ("Could not write to object, %s", 1141 AcpiFormatException (Status)); 1142 } 1143 1144 return (Status); 1145 } 1146 1147 1148 /******************************************************************************* 1149 * 1150 * FUNCTION: AcpiDbEvaluateAllPredefinedNames 1151 * 1152 * PARAMETERS: CountArg - Max number of methods to execute 1153 * 1154 * RETURN: None 1155 * 1156 * DESCRIPTION: Namespace batch execution. Execute predefined names in the 1157 * namespace, up to the max count, if specified. 1158 * 1159 ******************************************************************************/ 1160 1161 static void 1162 AcpiDbEvaluateAllPredefinedNames ( 1163 char *CountArg) 1164 { 1165 ACPI_DB_EXECUTE_WALK Info; 1166 1167 1168 Info.Count = 0; 1169 Info.MaxCount = ACPI_UINT32_MAX; 1170 1171 if (CountArg) 1172 { 1173 Info.MaxCount = strtoul (CountArg, NULL, 0); 1174 } 1175 1176 /* Search all nodes in namespace */ 1177 1178 (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 1179 ACPI_UINT32_MAX, AcpiDbEvaluateOnePredefinedName, NULL, 1180 (void *) &Info, NULL); 1181 1182 AcpiOsPrintf ( 1183 "Evaluated %u predefined names in the namespace\n", Info.Count); 1184 } 1185 1186 1187 /******************************************************************************* 1188 * 1189 * FUNCTION: AcpiDbEvaluateOnePredefinedName 1190 * 1191 * PARAMETERS: Callback from WalkNamespace 1192 * 1193 * RETURN: Status 1194 * 1195 * DESCRIPTION: Batch execution module. Currently only executes predefined 1196 * ACPI names. 1197 * 1198 ******************************************************************************/ 1199 1200 static ACPI_STATUS 1201 AcpiDbEvaluateOnePredefinedName ( 1202 ACPI_HANDLE ObjHandle, 1203 UINT32 NestingLevel, 1204 void *Context, 1205 void **ReturnValue) 1206 { 1207 ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle; 1208 ACPI_DB_EXECUTE_WALK *Info = (ACPI_DB_EXECUTE_WALK *) Context; 1209 char *Pathname; 1210 const ACPI_PREDEFINED_INFO *Predefined; 1211 ACPI_DEVICE_INFO *ObjInfo; 1212 ACPI_OBJECT_LIST ParamObjects; 1213 ACPI_OBJECT Params[ACPI_METHOD_NUM_ARGS]; 1214 ACPI_OBJECT *ThisParam; 1215 ACPI_BUFFER ReturnObj; 1216 ACPI_STATUS Status; 1217 UINT16 ArgTypeList; 1218 UINT8 ArgCount; 1219 UINT8 ArgType; 1220 UINT32 i; 1221 1222 1223 /* The name must be a predefined ACPI name */ 1224 1225 Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii); 1226 if (!Predefined) 1227 { 1228 return (AE_OK); 1229 } 1230 1231 if (Node->Type == ACPI_TYPE_LOCAL_SCOPE) 1232 { 1233 return (AE_OK); 1234 } 1235 1236 Pathname = AcpiNsGetNormalizedPathname (Node, TRUE); 1237 if (!Pathname) 1238 { 1239 return (AE_OK); 1240 } 1241 1242 /* Get the object info for number of method parameters */ 1243 1244 Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo); 1245 if (ACPI_FAILURE (Status)) 1246 { 1247 ACPI_FREE (Pathname); 1248 return (Status); 1249 } 1250 1251 ParamObjects.Count = 0; 1252 ParamObjects.Pointer = NULL; 1253 1254 if (ObjInfo->Type == ACPI_TYPE_METHOD) 1255 { 1256 /* Setup default parameters (with proper types) */ 1257 1258 ArgTypeList = Predefined->Info.ArgumentList; 1259 ArgCount = METHOD_GET_ARG_COUNT (ArgTypeList); 1260 1261 /* 1262 * Setup the ACPI-required number of arguments, regardless of what 1263 * the actual method defines. If there is a difference, then the 1264 * method is wrong and a warning will be issued during execution. 1265 */ 1266 ThisParam = Params; 1267 for (i = 0; i < ArgCount; i++) 1268 { 1269 ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList); 1270 ThisParam->Type = ArgType; 1271 1272 switch (ArgType) 1273 { 1274 case ACPI_TYPE_INTEGER: 1275 1276 ThisParam->Integer.Value = 1; 1277 break; 1278 1279 case ACPI_TYPE_STRING: 1280 1281 ThisParam->String.Pointer = 1282 "This is the default argument string"; 1283 ThisParam->String.Length = 1284 strlen (ThisParam->String.Pointer); 1285 break; 1286 1287 case ACPI_TYPE_BUFFER: 1288 1289 ThisParam->Buffer.Pointer = (UINT8 *) Params; /* just a garbage buffer */ 1290 ThisParam->Buffer.Length = 48; 1291 break; 1292 1293 case ACPI_TYPE_PACKAGE: 1294 1295 ThisParam->Package.Elements = NULL; 1296 ThisParam->Package.Count = 0; 1297 break; 1298 1299 default: 1300 1301 AcpiOsPrintf ("%s: Unsupported argument type: %u\n", 1302 Pathname, ArgType); 1303 break; 1304 } 1305 1306 ThisParam++; 1307 } 1308 1309 ParamObjects.Count = ArgCount; 1310 ParamObjects.Pointer = Params; 1311 } 1312 1313 ACPI_FREE (ObjInfo); 1314 ReturnObj.Pointer = NULL; 1315 ReturnObj.Length = ACPI_ALLOCATE_BUFFER; 1316 1317 /* Do the actual method execution */ 1318 1319 AcpiGbl_MethodExecuting = TRUE; 1320 1321 Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj); 1322 1323 AcpiOsPrintf ("%-32s returned %s\n", 1324 Pathname, AcpiFormatException (Status)); 1325 AcpiGbl_MethodExecuting = FALSE; 1326 ACPI_FREE (Pathname); 1327 1328 /* Ignore status from method execution */ 1329 1330 Status = AE_OK; 1331 1332 /* Update count, check if we have executed enough methods */ 1333 1334 Info->Count++; 1335 if (Info->Count >= Info->MaxCount) 1336 { 1337 Status = AE_CTRL_TERMINATE; 1338 } 1339 1340 return (Status); 1341 } 1342 1343 #endif /* ACPI_DEBUGGER */ 1344