1 /****************************************************************************** 2 * 3 * Module Name: exresop - AML Interpreter operand/object resolution 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 #include <contrib/dev/acpica/include/amlcode.h> 47 #include <contrib/dev/acpica/include/acparser.h> 48 #include <contrib/dev/acpica/include/acinterp.h> 49 #include <contrib/dev/acpica/include/acnamesp.h> 50 51 52 #define _COMPONENT ACPI_EXECUTER 53 ACPI_MODULE_NAME ("exresop") 54 55 /* Local prototypes */ 56 57 static ACPI_STATUS 58 AcpiExCheckObjectType ( 59 ACPI_OBJECT_TYPE TypeNeeded, 60 ACPI_OBJECT_TYPE ThisType, 61 void *Object); 62 63 64 /******************************************************************************* 65 * 66 * FUNCTION: AcpiExCheckObjectType 67 * 68 * PARAMETERS: TypeNeeded Object type needed 69 * ThisType Actual object type 70 * Object Object pointer 71 * 72 * RETURN: Status 73 * 74 * DESCRIPTION: Check required type against actual type 75 * 76 ******************************************************************************/ 77 78 static ACPI_STATUS 79 AcpiExCheckObjectType ( 80 ACPI_OBJECT_TYPE TypeNeeded, 81 ACPI_OBJECT_TYPE ThisType, 82 void *Object) 83 { 84 ACPI_FUNCTION_ENTRY (); 85 86 87 if (TypeNeeded == ACPI_TYPE_ANY) 88 { 89 /* All types OK, so we don't perform any typechecks */ 90 91 return (AE_OK); 92 } 93 94 if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE) 95 { 96 /* 97 * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference 98 * objects and thus allow them to be targets. (As per the ACPI 99 * specification, a store to a constant is a noop.) 100 */ 101 if ((ThisType == ACPI_TYPE_INTEGER) && 102 (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT)) 103 { 104 return (AE_OK); 105 } 106 } 107 108 if (TypeNeeded != ThisType) 109 { 110 ACPI_ERROR ((AE_INFO, 111 "Needed type [%s], found [%s] %p", 112 AcpiUtGetTypeName (TypeNeeded), 113 AcpiUtGetTypeName (ThisType), Object)); 114 115 return (AE_AML_OPERAND_TYPE); 116 } 117 118 return (AE_OK); 119 } 120 121 122 /******************************************************************************* 123 * 124 * FUNCTION: AcpiExResolveOperands 125 * 126 * PARAMETERS: Opcode - Opcode being interpreted 127 * StackPtr - Pointer to the operand stack to be 128 * resolved 129 * WalkState - Current state 130 * 131 * RETURN: Status 132 * 133 * DESCRIPTION: Convert multiple input operands to the types required by the 134 * target operator. 135 * 136 * Each 5-bit group in ArgTypes represents one required 137 * operand and indicates the required Type. The corresponding operand 138 * will be converted to the required type if possible, otherwise we 139 * abort with an exception. 140 * 141 ******************************************************************************/ 142 143 ACPI_STATUS 144 AcpiExResolveOperands ( 145 UINT16 Opcode, 146 ACPI_OPERAND_OBJECT **StackPtr, 147 ACPI_WALK_STATE *WalkState) 148 { 149 ACPI_OPERAND_OBJECT *ObjDesc; 150 ACPI_STATUS Status = AE_OK; 151 UINT8 ObjectType; 152 UINT32 ArgTypes; 153 const ACPI_OPCODE_INFO *OpInfo; 154 UINT32 ThisArgType; 155 ACPI_OBJECT_TYPE TypeNeeded; 156 UINT16 TargetOp = 0; 157 158 159 ACPI_FUNCTION_TRACE_U32 (ExResolveOperands, Opcode); 160 161 162 OpInfo = AcpiPsGetOpcodeInfo (Opcode); 163 if (OpInfo->Class == AML_CLASS_UNKNOWN) 164 { 165 return_ACPI_STATUS (AE_AML_BAD_OPCODE); 166 } 167 168 ArgTypes = OpInfo->RuntimeArgs; 169 if (ArgTypes == ARGI_INVALID_OPCODE) 170 { 171 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 172 Opcode)); 173 174 return_ACPI_STATUS (AE_AML_INTERNAL); 175 } 176 177 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 178 "Opcode %X [%s] RequiredOperandTypes=%8.8X\n", 179 Opcode, OpInfo->Name, ArgTypes)); 180 181 /* 182 * Normal exit is with (ArgTypes == 0) at end of argument list. 183 * Function will return an exception from within the loop upon 184 * finding an entry which is not (or cannot be converted 185 * to) the required type; if stack underflows; or upon 186 * finding a NULL stack entry (which should not happen). 187 */ 188 while (GET_CURRENT_ARG_TYPE (ArgTypes)) 189 { 190 if (!StackPtr || !*StackPtr) 191 { 192 ACPI_ERROR ((AE_INFO, "Null stack entry at %p", 193 StackPtr)); 194 195 return_ACPI_STATUS (AE_AML_INTERNAL); 196 } 197 198 /* Extract useful items */ 199 200 ObjDesc = *StackPtr; 201 202 /* Decode the descriptor type */ 203 204 switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc)) 205 { 206 case ACPI_DESC_TYPE_NAMED: 207 208 /* Namespace Node */ 209 210 ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type; 211 212 /* 213 * Resolve an alias object. The construction of these objects 214 * guarantees that there is only one level of alias indirection; 215 * thus, the attached object is always the aliased namespace node 216 */ 217 if (ObjectType == ACPI_TYPE_LOCAL_ALIAS) 218 { 219 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjDesc); 220 *StackPtr = ObjDesc; 221 ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type; 222 } 223 break; 224 225 case ACPI_DESC_TYPE_OPERAND: 226 227 /* ACPI internal object */ 228 229 ObjectType = ObjDesc->Common.Type; 230 231 /* Check for bad ACPI_OBJECT_TYPE */ 232 233 if (!AcpiUtValidObjectType (ObjectType)) 234 { 235 ACPI_ERROR ((AE_INFO, 236 "Bad operand object type [0x%X]", ObjectType)); 237 238 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 239 } 240 241 if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE) 242 { 243 /* Validate the Reference */ 244 245 switch (ObjDesc->Reference.Class) 246 { 247 case ACPI_REFCLASS_DEBUG: 248 249 TargetOp = AML_DEBUG_OP; 250 251 /*lint -fallthrough */ 252 253 case ACPI_REFCLASS_ARG: 254 case ACPI_REFCLASS_LOCAL: 255 case ACPI_REFCLASS_INDEX: 256 case ACPI_REFCLASS_REFOF: 257 case ACPI_REFCLASS_TABLE: /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */ 258 case ACPI_REFCLASS_NAME: /* Reference to a named object */ 259 260 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 261 "Operand is a Reference, Class [%s] %2.2X\n", 262 AcpiUtGetReferenceName (ObjDesc), 263 ObjDesc->Reference.Class)); 264 break; 265 266 default: 267 268 ACPI_ERROR ((AE_INFO, 269 "Unknown Reference Class 0x%2.2X in %p", 270 ObjDesc->Reference.Class, ObjDesc)); 271 272 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 273 } 274 } 275 break; 276 277 default: 278 279 /* Invalid descriptor */ 280 281 ACPI_ERROR ((AE_INFO, "Invalid descriptor %p [%s]", 282 ObjDesc, AcpiUtGetDescriptorName (ObjDesc))); 283 284 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 285 } 286 287 /* Get one argument type, point to the next */ 288 289 ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes); 290 INCREMENT_ARG_LIST (ArgTypes); 291 292 /* 293 * Handle cases where the object does not need to be 294 * resolved to a value 295 */ 296 switch (ThisArgType) 297 { 298 case ARGI_REF_OR_STRING: /* Can be a String or Reference */ 299 300 if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) && 301 (ObjDesc->Common.Type == ACPI_TYPE_STRING)) 302 { 303 /* 304 * String found - the string references a named object and 305 * must be resolved to a node 306 */ 307 goto NextOperand; 308 } 309 310 /* 311 * Else not a string - fall through to the normal Reference 312 * case below 313 */ 314 /*lint -fallthrough */ 315 316 case ARGI_REFERENCE: /* References: */ 317 case ARGI_INTEGER_REF: 318 case ARGI_OBJECT_REF: 319 case ARGI_DEVICE_REF: 320 case ARGI_TARGETREF: /* Allows implicit conversion rules before store */ 321 case ARGI_FIXED_TARGET: /* No implicit conversion before store to target */ 322 case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion */ 323 /* 324 * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE 325 * A Namespace Node is OK as-is 326 */ 327 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) 328 { 329 goto NextOperand; 330 } 331 332 Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE, 333 ObjectType, ObjDesc); 334 if (ACPI_FAILURE (Status)) 335 { 336 return_ACPI_STATUS (Status); 337 } 338 goto NextOperand; 339 340 case ARGI_DATAREFOBJ: /* Store operator only */ 341 /* 342 * We don't want to resolve IndexOp reference objects during 343 * a store because this would be an implicit DeRefOf operation. 344 * Instead, we just want to store the reference object. 345 * -- All others must be resolved below. 346 */ 347 if ((Opcode == AML_STORE_OP) && 348 ((*StackPtr)->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) && 349 ((*StackPtr)->Reference.Class == ACPI_REFCLASS_INDEX)) 350 { 351 goto NextOperand; 352 } 353 break; 354 355 default: 356 357 /* All cases covered above */ 358 359 break; 360 } 361 362 /* 363 * Resolve this object to a value 364 */ 365 Status = AcpiExResolveToValue (StackPtr, WalkState); 366 if (ACPI_FAILURE (Status)) 367 { 368 return_ACPI_STATUS (Status); 369 } 370 371 /* Get the resolved object */ 372 373 ObjDesc = *StackPtr; 374 375 /* 376 * Check the resulting object (value) type 377 */ 378 switch (ThisArgType) 379 { 380 /* 381 * For the simple cases, only one type of resolved object 382 * is allowed 383 */ 384 case ARGI_MUTEX: 385 386 /* Need an operand of type ACPI_TYPE_MUTEX */ 387 388 TypeNeeded = ACPI_TYPE_MUTEX; 389 break; 390 391 case ARGI_EVENT: 392 393 /* Need an operand of type ACPI_TYPE_EVENT */ 394 395 TypeNeeded = ACPI_TYPE_EVENT; 396 break; 397 398 case ARGI_PACKAGE: /* Package */ 399 400 /* Need an operand of type ACPI_TYPE_PACKAGE */ 401 402 TypeNeeded = ACPI_TYPE_PACKAGE; 403 break; 404 405 case ARGI_ANYTYPE: 406 407 /* Any operand type will do */ 408 409 TypeNeeded = ACPI_TYPE_ANY; 410 break; 411 412 case ARGI_DDBHANDLE: 413 414 /* Need an operand of type ACPI_TYPE_DDB_HANDLE */ 415 416 TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE; 417 break; 418 419 420 /* 421 * The more complex cases allow multiple resolved object types 422 */ 423 case ARGI_INTEGER: 424 425 /* 426 * Need an operand of type ACPI_TYPE_INTEGER, 427 * But we can implicitly convert from a STRING or BUFFER 428 * Aka - "Implicit Source Operand Conversion" 429 */ 430 Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16); 431 if (ACPI_FAILURE (Status)) 432 { 433 if (Status == AE_TYPE) 434 { 435 ACPI_ERROR ((AE_INFO, 436 "Needed [Integer/String/Buffer], found [%s] %p", 437 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 438 439 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 440 } 441 442 return_ACPI_STATUS (Status); 443 } 444 445 if (ObjDesc != *StackPtr) 446 { 447 AcpiUtRemoveReference (ObjDesc); 448 } 449 goto NextOperand; 450 451 case ARGI_BUFFER: 452 /* 453 * Need an operand of type ACPI_TYPE_BUFFER, 454 * But we can implicitly convert from a STRING or INTEGER 455 * Aka - "Implicit Source Operand Conversion" 456 */ 457 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr); 458 if (ACPI_FAILURE (Status)) 459 { 460 if (Status == AE_TYPE) 461 { 462 ACPI_ERROR ((AE_INFO, 463 "Needed [Integer/String/Buffer], found [%s] %p", 464 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 465 466 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 467 } 468 469 return_ACPI_STATUS (Status); 470 } 471 472 if (ObjDesc != *StackPtr) 473 { 474 AcpiUtRemoveReference (ObjDesc); 475 } 476 goto NextOperand; 477 478 case ARGI_STRING: 479 /* 480 * Need an operand of type ACPI_TYPE_STRING, 481 * But we can implicitly convert from a BUFFER or INTEGER 482 * Aka - "Implicit Source Operand Conversion" 483 */ 484 Status = AcpiExConvertToString (ObjDesc, StackPtr, 485 ACPI_IMPLICIT_CONVERT_HEX); 486 if (ACPI_FAILURE (Status)) 487 { 488 if (Status == AE_TYPE) 489 { 490 ACPI_ERROR ((AE_INFO, 491 "Needed [Integer/String/Buffer], found [%s] %p", 492 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 493 494 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 495 } 496 497 return_ACPI_STATUS (Status); 498 } 499 500 if (ObjDesc != *StackPtr) 501 { 502 AcpiUtRemoveReference (ObjDesc); 503 } 504 goto NextOperand; 505 506 case ARGI_COMPUTEDATA: 507 508 /* Need an operand of type INTEGER, STRING or BUFFER */ 509 510 switch (ObjDesc->Common.Type) 511 { 512 case ACPI_TYPE_INTEGER: 513 case ACPI_TYPE_STRING: 514 case ACPI_TYPE_BUFFER: 515 516 /* Valid operand */ 517 break; 518 519 default: 520 ACPI_ERROR ((AE_INFO, 521 "Needed [Integer/String/Buffer], found [%s] %p", 522 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 523 524 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 525 } 526 goto NextOperand; 527 528 case ARGI_BUFFER_OR_STRING: 529 530 /* Need an operand of type STRING or BUFFER */ 531 532 switch (ObjDesc->Common.Type) 533 { 534 case ACPI_TYPE_STRING: 535 case ACPI_TYPE_BUFFER: 536 537 /* Valid operand */ 538 break; 539 540 case ACPI_TYPE_INTEGER: 541 542 /* Highest priority conversion is to type Buffer */ 543 544 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr); 545 if (ACPI_FAILURE (Status)) 546 { 547 return_ACPI_STATUS (Status); 548 } 549 550 if (ObjDesc != *StackPtr) 551 { 552 AcpiUtRemoveReference (ObjDesc); 553 } 554 break; 555 556 default: 557 ACPI_ERROR ((AE_INFO, 558 "Needed [Integer/String/Buffer], found [%s] %p", 559 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 560 561 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 562 } 563 goto NextOperand; 564 565 case ARGI_DATAOBJECT: 566 /* 567 * ARGI_DATAOBJECT is only used by the SizeOf operator. 568 * Need a buffer, string, package, or RefOf reference. 569 * 570 * The only reference allowed here is a direct reference to 571 * a namespace node. 572 */ 573 switch (ObjDesc->Common.Type) 574 { 575 case ACPI_TYPE_PACKAGE: 576 case ACPI_TYPE_STRING: 577 case ACPI_TYPE_BUFFER: 578 case ACPI_TYPE_LOCAL_REFERENCE: 579 580 /* Valid operand */ 581 break; 582 583 default: 584 585 ACPI_ERROR ((AE_INFO, 586 "Needed [Buffer/String/Package/Reference], found [%s] %p", 587 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 588 589 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 590 } 591 goto NextOperand; 592 593 case ARGI_COMPLEXOBJ: 594 595 /* Need a buffer or package or (ACPI 2.0) String */ 596 597 switch (ObjDesc->Common.Type) 598 { 599 case ACPI_TYPE_PACKAGE: 600 case ACPI_TYPE_STRING: 601 case ACPI_TYPE_BUFFER: 602 603 /* Valid operand */ 604 break; 605 606 default: 607 608 ACPI_ERROR ((AE_INFO, 609 "Needed [Buffer/String/Package], found [%s] %p", 610 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 611 612 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 613 } 614 goto NextOperand; 615 616 case ARGI_REGION_OR_BUFFER: /* Used by Load() only */ 617 618 /* Need an operand of type REGION or a BUFFER (which could be a resolved region field) */ 619 620 switch (ObjDesc->Common.Type) 621 { 622 case ACPI_TYPE_BUFFER: 623 case ACPI_TYPE_REGION: 624 625 /* Valid operand */ 626 break; 627 628 default: 629 630 ACPI_ERROR ((AE_INFO, 631 "Needed [Region/Buffer], found [%s] %p", 632 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 633 634 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 635 } 636 goto NextOperand; 637 638 case ARGI_DATAREFOBJ: 639 640 /* Used by the Store() operator only */ 641 642 switch (ObjDesc->Common.Type) 643 { 644 case ACPI_TYPE_INTEGER: 645 case ACPI_TYPE_PACKAGE: 646 case ACPI_TYPE_STRING: 647 case ACPI_TYPE_BUFFER: 648 case ACPI_TYPE_BUFFER_FIELD: 649 case ACPI_TYPE_LOCAL_REFERENCE: 650 case ACPI_TYPE_LOCAL_REGION_FIELD: 651 case ACPI_TYPE_LOCAL_BANK_FIELD: 652 case ACPI_TYPE_LOCAL_INDEX_FIELD: 653 case ACPI_TYPE_DDB_HANDLE: 654 655 /* Valid operand */ 656 break; 657 658 default: 659 660 if (AcpiGbl_EnableInterpreterSlack) 661 { 662 /* 663 * Enable original behavior of Store(), allowing any and all 664 * objects as the source operand. The ACPI spec does not 665 * allow this, however. 666 */ 667 break; 668 } 669 670 if (TargetOp == AML_DEBUG_OP) 671 { 672 /* Allow store of any object to the Debug object */ 673 674 break; 675 } 676 677 ACPI_ERROR ((AE_INFO, 678 "Needed Integer/Buffer/String/Package/Ref/Ddb], found [%s] %p", 679 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 680 681 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 682 } 683 goto NextOperand; 684 685 default: 686 687 /* Unknown type */ 688 689 ACPI_ERROR ((AE_INFO, 690 "Internal - Unknown ARGI (required operand) type 0x%X", 691 ThisArgType)); 692 693 return_ACPI_STATUS (AE_BAD_PARAMETER); 694 } 695 696 /* 697 * Make sure that the original object was resolved to the 698 * required object type (Simple cases only). 699 */ 700 Status = AcpiExCheckObjectType (TypeNeeded, 701 (*StackPtr)->Common.Type, *StackPtr); 702 if (ACPI_FAILURE (Status)) 703 { 704 return_ACPI_STATUS (Status); 705 } 706 707 NextOperand: 708 /* 709 * If more operands needed, decrement StackPtr to point 710 * to next operand on stack 711 */ 712 if (GET_CURRENT_ARG_TYPE (ArgTypes)) 713 { 714 StackPtr--; 715 } 716 } 717 718 ACPI_DUMP_OPERANDS (WalkState->Operands, 719 AcpiPsGetOpcodeName (Opcode), WalkState->NumOperands); 720 721 return_ACPI_STATUS (Status); 722 } 723