1 /****************************************************************************** 2 * 3 * Module Name: utobject - ACPI object create/delete/size/cache routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2011, 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 #define __UTOBJECT_C__ 45 46 #include "acpi.h" 47 #include "accommon.h" 48 #include "acnamesp.h" 49 50 51 #define _COMPONENT ACPI_UTILITIES 52 ACPI_MODULE_NAME ("utobject") 53 54 /* Local prototypes */ 55 56 static ACPI_STATUS 57 AcpiUtGetSimpleObjectSize ( 58 ACPI_OPERAND_OBJECT *Obj, 59 ACPI_SIZE *ObjLength); 60 61 static ACPI_STATUS 62 AcpiUtGetPackageObjectSize ( 63 ACPI_OPERAND_OBJECT *Obj, 64 ACPI_SIZE *ObjLength); 65 66 static ACPI_STATUS 67 AcpiUtGetElementLength ( 68 UINT8 ObjectType, 69 ACPI_OPERAND_OBJECT *SourceObject, 70 ACPI_GENERIC_STATE *State, 71 void *Context); 72 73 74 /******************************************************************************* 75 * 76 * FUNCTION: AcpiUtCreateInternalObjectDbg 77 * 78 * PARAMETERS: ModuleName - Source file name of caller 79 * LineNumber - Line number of caller 80 * ComponentId - Component type of caller 81 * Type - ACPI Type of the new object 82 * 83 * RETURN: A new internal object, null on failure 84 * 85 * DESCRIPTION: Create and initialize a new internal object. 86 * 87 * NOTE: We always allocate the worst-case object descriptor because 88 * these objects are cached, and we want them to be 89 * one-size-satisifies-any-request. This in itself may not be 90 * the most memory efficient, but the efficiency of the object 91 * cache should more than make up for this! 92 * 93 ******************************************************************************/ 94 95 ACPI_OPERAND_OBJECT * 96 AcpiUtCreateInternalObjectDbg ( 97 const char *ModuleName, 98 UINT32 LineNumber, 99 UINT32 ComponentId, 100 ACPI_OBJECT_TYPE Type) 101 { 102 ACPI_OPERAND_OBJECT *Object; 103 ACPI_OPERAND_OBJECT *SecondObject; 104 105 106 ACPI_FUNCTION_TRACE_STR (UtCreateInternalObjectDbg, 107 AcpiUtGetTypeName (Type)); 108 109 110 /* Allocate the raw object descriptor */ 111 112 Object = AcpiUtAllocateObjectDescDbg (ModuleName, LineNumber, ComponentId); 113 if (!Object) 114 { 115 return_PTR (NULL); 116 } 117 118 switch (Type) 119 { 120 case ACPI_TYPE_REGION: 121 case ACPI_TYPE_BUFFER_FIELD: 122 case ACPI_TYPE_LOCAL_BANK_FIELD: 123 124 /* These types require a secondary object */ 125 126 SecondObject = AcpiUtAllocateObjectDescDbg (ModuleName, 127 LineNumber, ComponentId); 128 if (!SecondObject) 129 { 130 AcpiUtDeleteObjectDesc (Object); 131 return_PTR (NULL); 132 } 133 134 SecondObject->Common.Type = ACPI_TYPE_LOCAL_EXTRA; 135 SecondObject->Common.ReferenceCount = 1; 136 137 /* Link the second object to the first */ 138 139 Object->Common.NextObject = SecondObject; 140 break; 141 142 default: 143 /* All others have no secondary object */ 144 break; 145 } 146 147 /* Save the object type in the object descriptor */ 148 149 Object->Common.Type = (UINT8) Type; 150 151 /* Init the reference count */ 152 153 Object->Common.ReferenceCount = 1; 154 155 /* Any per-type initialization should go here */ 156 157 return_PTR (Object); 158 } 159 160 161 /******************************************************************************* 162 * 163 * FUNCTION: AcpiUtCreatePackageObject 164 * 165 * PARAMETERS: Count - Number of package elements 166 * 167 * RETURN: Pointer to a new Package object, null on failure 168 * 169 * DESCRIPTION: Create a fully initialized package object 170 * 171 ******************************************************************************/ 172 173 ACPI_OPERAND_OBJECT * 174 AcpiUtCreatePackageObject ( 175 UINT32 Count) 176 { 177 ACPI_OPERAND_OBJECT *PackageDesc; 178 ACPI_OPERAND_OBJECT **PackageElements; 179 180 181 ACPI_FUNCTION_TRACE_U32 (UtCreatePackageObject, Count); 182 183 184 /* Create a new Package object */ 185 186 PackageDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE); 187 if (!PackageDesc) 188 { 189 return_PTR (NULL); 190 } 191 192 /* 193 * Create the element array. Count+1 allows the array to be null 194 * terminated. 195 */ 196 PackageElements = ACPI_ALLOCATE_ZEROED ( 197 ((ACPI_SIZE) Count + 1) * sizeof (void *)); 198 if (!PackageElements) 199 { 200 ACPI_FREE (PackageDesc); 201 return_PTR (NULL); 202 } 203 204 PackageDesc->Package.Count = Count; 205 PackageDesc->Package.Elements = PackageElements; 206 return_PTR (PackageDesc); 207 } 208 209 210 /******************************************************************************* 211 * 212 * FUNCTION: AcpiUtCreateIntegerObject 213 * 214 * PARAMETERS: InitialValue - Initial value for the integer 215 * 216 * RETURN: Pointer to a new Integer object, null on failure 217 * 218 * DESCRIPTION: Create an initialized integer object 219 * 220 ******************************************************************************/ 221 222 ACPI_OPERAND_OBJECT * 223 AcpiUtCreateIntegerObject ( 224 UINT64 InitialValue) 225 { 226 ACPI_OPERAND_OBJECT *IntegerDesc; 227 228 229 ACPI_FUNCTION_TRACE (UtCreateIntegerObject); 230 231 232 /* Create and initialize a new integer object */ 233 234 IntegerDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER); 235 if (!IntegerDesc) 236 { 237 return_PTR (NULL); 238 } 239 240 IntegerDesc->Integer.Value = InitialValue; 241 return_PTR (IntegerDesc); 242 } 243 244 245 /******************************************************************************* 246 * 247 * FUNCTION: AcpiUtCreateBufferObject 248 * 249 * PARAMETERS: BufferSize - Size of buffer to be created 250 * 251 * RETURN: Pointer to a new Buffer object, null on failure 252 * 253 * DESCRIPTION: Create a fully initialized buffer object 254 * 255 ******************************************************************************/ 256 257 ACPI_OPERAND_OBJECT * 258 AcpiUtCreateBufferObject ( 259 ACPI_SIZE BufferSize) 260 { 261 ACPI_OPERAND_OBJECT *BufferDesc; 262 UINT8 *Buffer = NULL; 263 264 265 ACPI_FUNCTION_TRACE_U32 (UtCreateBufferObject, BufferSize); 266 267 268 /* Create a new Buffer object */ 269 270 BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); 271 if (!BufferDesc) 272 { 273 return_PTR (NULL); 274 } 275 276 /* Create an actual buffer only if size > 0 */ 277 278 if (BufferSize > 0) 279 { 280 /* Allocate the actual buffer */ 281 282 Buffer = ACPI_ALLOCATE_ZEROED (BufferSize); 283 if (!Buffer) 284 { 285 ACPI_ERROR ((AE_INFO, "Could not allocate size %u", 286 (UINT32) BufferSize)); 287 AcpiUtRemoveReference (BufferDesc); 288 return_PTR (NULL); 289 } 290 } 291 292 /* Complete buffer object initialization */ 293 294 BufferDesc->Buffer.Flags |= AOPOBJ_DATA_VALID; 295 BufferDesc->Buffer.Pointer = Buffer; 296 BufferDesc->Buffer.Length = (UINT32) BufferSize; 297 298 /* Return the new buffer descriptor */ 299 300 return_PTR (BufferDesc); 301 } 302 303 304 /******************************************************************************* 305 * 306 * FUNCTION: AcpiUtCreateStringObject 307 * 308 * PARAMETERS: StringSize - Size of string to be created. Does not 309 * include NULL terminator, this is added 310 * automatically. 311 * 312 * RETURN: Pointer to a new String object 313 * 314 * DESCRIPTION: Create a fully initialized string object 315 * 316 ******************************************************************************/ 317 318 ACPI_OPERAND_OBJECT * 319 AcpiUtCreateStringObject ( 320 ACPI_SIZE StringSize) 321 { 322 ACPI_OPERAND_OBJECT *StringDesc; 323 char *String; 324 325 326 ACPI_FUNCTION_TRACE_U32 (UtCreateStringObject, StringSize); 327 328 329 /* Create a new String object */ 330 331 StringDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING); 332 if (!StringDesc) 333 { 334 return_PTR (NULL); 335 } 336 337 /* 338 * Allocate the actual string buffer -- (Size + 1) for NULL terminator. 339 * NOTE: Zero-length strings are NULL terminated 340 */ 341 String = ACPI_ALLOCATE_ZEROED (StringSize + 1); 342 if (!String) 343 { 344 ACPI_ERROR ((AE_INFO, "Could not allocate size %u", 345 (UINT32) StringSize)); 346 AcpiUtRemoveReference (StringDesc); 347 return_PTR (NULL); 348 } 349 350 /* Complete string object initialization */ 351 352 StringDesc->String.Pointer = String; 353 StringDesc->String.Length = (UINT32) StringSize; 354 355 /* Return the new string descriptor */ 356 357 return_PTR (StringDesc); 358 } 359 360 361 /******************************************************************************* 362 * 363 * FUNCTION: AcpiUtValidInternalObject 364 * 365 * PARAMETERS: Object - Object to be validated 366 * 367 * RETURN: TRUE if object is valid, FALSE otherwise 368 * 369 * DESCRIPTION: Validate a pointer to be an ACPI_OPERAND_OBJECT 370 * 371 ******************************************************************************/ 372 373 BOOLEAN 374 AcpiUtValidInternalObject ( 375 void *Object) 376 { 377 378 ACPI_FUNCTION_NAME (UtValidInternalObject); 379 380 381 /* Check for a null pointer */ 382 383 if (!Object) 384 { 385 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "**** Null Object Ptr\n")); 386 return (FALSE); 387 } 388 389 /* Check the descriptor type field */ 390 391 switch (ACPI_GET_DESCRIPTOR_TYPE (Object)) 392 { 393 case ACPI_DESC_TYPE_OPERAND: 394 395 /* The object appears to be a valid ACPI_OPERAND_OBJECT */ 396 397 return (TRUE); 398 399 default: 400 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 401 "%p is not not an ACPI operand obj [%s]\n", 402 Object, AcpiUtGetDescriptorName (Object))); 403 break; 404 } 405 406 return (FALSE); 407 } 408 409 410 /******************************************************************************* 411 * 412 * FUNCTION: AcpiUtAllocateObjectDescDbg 413 * 414 * PARAMETERS: ModuleName - Caller's module name (for error output) 415 * LineNumber - Caller's line number (for error output) 416 * ComponentId - Caller's component ID (for error output) 417 * 418 * RETURN: Pointer to newly allocated object descriptor. Null on error 419 * 420 * DESCRIPTION: Allocate a new object descriptor. Gracefully handle 421 * error conditions. 422 * 423 ******************************************************************************/ 424 425 void * 426 AcpiUtAllocateObjectDescDbg ( 427 const char *ModuleName, 428 UINT32 LineNumber, 429 UINT32 ComponentId) 430 { 431 ACPI_OPERAND_OBJECT *Object; 432 433 434 ACPI_FUNCTION_TRACE (UtAllocateObjectDescDbg); 435 436 437 Object = AcpiOsAcquireObject (AcpiGbl_OperandCache); 438 if (!Object) 439 { 440 ACPI_ERROR ((ModuleName, LineNumber, 441 "Could not allocate an object descriptor")); 442 443 return_PTR (NULL); 444 } 445 446 /* Mark the descriptor type */ 447 448 ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_OPERAND); 449 450 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", 451 Object, (UINT32) sizeof (ACPI_OPERAND_OBJECT))); 452 453 return_PTR (Object); 454 } 455 456 457 /******************************************************************************* 458 * 459 * FUNCTION: AcpiUtDeleteObjectDesc 460 * 461 * PARAMETERS: Object - An Acpi internal object to be deleted 462 * 463 * RETURN: None. 464 * 465 * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache 466 * 467 ******************************************************************************/ 468 469 void 470 AcpiUtDeleteObjectDesc ( 471 ACPI_OPERAND_OBJECT *Object) 472 { 473 ACPI_FUNCTION_TRACE_PTR (UtDeleteObjectDesc, Object); 474 475 476 /* Object must be an ACPI_OPERAND_OBJECT */ 477 478 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND) 479 { 480 ACPI_ERROR ((AE_INFO, 481 "%p is not an ACPI Operand object [%s]", Object, 482 AcpiUtGetDescriptorName (Object))); 483 return_VOID; 484 } 485 486 (void) AcpiOsReleaseObject (AcpiGbl_OperandCache, Object); 487 return_VOID; 488 } 489 490 491 /******************************************************************************* 492 * 493 * FUNCTION: AcpiUtGetSimpleObjectSize 494 * 495 * PARAMETERS: InternalObject - An ACPI operand object 496 * ObjLength - Where the length is returned 497 * 498 * RETURN: Status 499 * 500 * DESCRIPTION: This function is called to determine the space required to 501 * contain a simple object for return to an external user. 502 * 503 * The length includes the object structure plus any additional 504 * needed space. 505 * 506 ******************************************************************************/ 507 508 static ACPI_STATUS 509 AcpiUtGetSimpleObjectSize ( 510 ACPI_OPERAND_OBJECT *InternalObject, 511 ACPI_SIZE *ObjLength) 512 { 513 ACPI_SIZE Length; 514 ACPI_SIZE Size; 515 ACPI_STATUS Status = AE_OK; 516 517 518 ACPI_FUNCTION_TRACE_PTR (UtGetSimpleObjectSize, InternalObject); 519 520 521 /* Start with the length of the (external) Acpi object */ 522 523 Length = sizeof (ACPI_OBJECT); 524 525 /* A NULL object is allowed, can be a legal uninitialized package element */ 526 527 if (!InternalObject) 528 { 529 /* 530 * Object is NULL, just return the length of ACPI_OBJECT 531 * (A NULL ACPI_OBJECT is an object of all zeroes.) 532 */ 533 *ObjLength = ACPI_ROUND_UP_TO_NATIVE_WORD (Length); 534 return_ACPI_STATUS (AE_OK); 535 } 536 537 /* A Namespace Node should never appear here */ 538 539 if (ACPI_GET_DESCRIPTOR_TYPE (InternalObject) == ACPI_DESC_TYPE_NAMED) 540 { 541 /* A namespace node should never get here */ 542 543 return_ACPI_STATUS (AE_AML_INTERNAL); 544 } 545 546 /* 547 * The final length depends on the object type 548 * Strings and Buffers are packed right up against the parent object and 549 * must be accessed bytewise or there may be alignment problems on 550 * certain processors 551 */ 552 switch (InternalObject->Common.Type) 553 { 554 case ACPI_TYPE_STRING: 555 556 Length += (ACPI_SIZE) InternalObject->String.Length + 1; 557 break; 558 559 560 case ACPI_TYPE_BUFFER: 561 562 Length += (ACPI_SIZE) InternalObject->Buffer.Length; 563 break; 564 565 566 case ACPI_TYPE_INTEGER: 567 case ACPI_TYPE_PROCESSOR: 568 case ACPI_TYPE_POWER: 569 570 /* No extra data for these types */ 571 572 break; 573 574 575 case ACPI_TYPE_LOCAL_REFERENCE: 576 577 switch (InternalObject->Reference.Class) 578 { 579 case ACPI_REFCLASS_NAME: 580 581 /* 582 * Get the actual length of the full pathname to this object. 583 * The reference will be converted to the pathname to the object 584 */ 585 Size = AcpiNsGetPathnameLength (InternalObject->Reference.Node); 586 if (!Size) 587 { 588 return_ACPI_STATUS (AE_BAD_PARAMETER); 589 } 590 591 Length += ACPI_ROUND_UP_TO_NATIVE_WORD (Size); 592 break; 593 594 default: 595 596 /* 597 * No other reference opcodes are supported. 598 * Notably, Locals and Args are not supported, but this may be 599 * required eventually. 600 */ 601 ACPI_ERROR ((AE_INFO, "Cannot convert to external object - " 602 "unsupported Reference Class [%s] 0x%X in object %p", 603 AcpiUtGetReferenceName (InternalObject), 604 InternalObject->Reference.Class, InternalObject)); 605 Status = AE_TYPE; 606 break; 607 } 608 break; 609 610 611 default: 612 613 ACPI_ERROR ((AE_INFO, "Cannot convert to external object - " 614 "unsupported type [%s] 0x%X in object %p", 615 AcpiUtGetObjectTypeName (InternalObject), 616 InternalObject->Common.Type, InternalObject)); 617 Status = AE_TYPE; 618 break; 619 } 620 621 /* 622 * Account for the space required by the object rounded up to the next 623 * multiple of the machine word size. This keeps each object aligned 624 * on a machine word boundary. (preventing alignment faults on some 625 * machines.) 626 */ 627 *ObjLength = ACPI_ROUND_UP_TO_NATIVE_WORD (Length); 628 return_ACPI_STATUS (Status); 629 } 630 631 632 /******************************************************************************* 633 * 634 * FUNCTION: AcpiUtGetElementLength 635 * 636 * PARAMETERS: ACPI_PKG_CALLBACK 637 * 638 * RETURN: Status 639 * 640 * DESCRIPTION: Get the length of one package element. 641 * 642 ******************************************************************************/ 643 644 static ACPI_STATUS 645 AcpiUtGetElementLength ( 646 UINT8 ObjectType, 647 ACPI_OPERAND_OBJECT *SourceObject, 648 ACPI_GENERIC_STATE *State, 649 void *Context) 650 { 651 ACPI_STATUS Status = AE_OK; 652 ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context; 653 ACPI_SIZE ObjectSpace; 654 655 656 switch (ObjectType) 657 { 658 case ACPI_COPY_TYPE_SIMPLE: 659 660 /* 661 * Simple object - just get the size (Null object/entry is handled 662 * here also) and sum it into the running package length 663 */ 664 Status = AcpiUtGetSimpleObjectSize (SourceObject, &ObjectSpace); 665 if (ACPI_FAILURE (Status)) 666 { 667 return (Status); 668 } 669 670 Info->Length += ObjectSpace; 671 break; 672 673 674 case ACPI_COPY_TYPE_PACKAGE: 675 676 /* Package object - nothing much to do here, let the walk handle it */ 677 678 Info->NumPackages++; 679 State->Pkg.ThisTargetObj = NULL; 680 break; 681 682 683 default: 684 685 /* No other types allowed */ 686 687 return (AE_BAD_PARAMETER); 688 } 689 690 return (Status); 691 } 692 693 694 /******************************************************************************* 695 * 696 * FUNCTION: AcpiUtGetPackageObjectSize 697 * 698 * PARAMETERS: InternalObject - An ACPI internal object 699 * ObjLength - Where the length is returned 700 * 701 * RETURN: Status 702 * 703 * DESCRIPTION: This function is called to determine the space required to 704 * contain a package object for return to an external user. 705 * 706 * This is moderately complex since a package contains other 707 * objects including packages. 708 * 709 ******************************************************************************/ 710 711 static ACPI_STATUS 712 AcpiUtGetPackageObjectSize ( 713 ACPI_OPERAND_OBJECT *InternalObject, 714 ACPI_SIZE *ObjLength) 715 { 716 ACPI_STATUS Status; 717 ACPI_PKG_INFO Info; 718 719 720 ACPI_FUNCTION_TRACE_PTR (UtGetPackageObjectSize, InternalObject); 721 722 723 Info.Length = 0; 724 Info.ObjectSpace = 0; 725 Info.NumPackages = 1; 726 727 Status = AcpiUtWalkPackageTree (InternalObject, NULL, 728 AcpiUtGetElementLength, &Info); 729 if (ACPI_FAILURE (Status)) 730 { 731 return_ACPI_STATUS (Status); 732 } 733 734 /* 735 * We have handled all of the objects in all levels of the package. 736 * just add the length of the package objects themselves. 737 * Round up to the next machine word. 738 */ 739 Info.Length += ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)) * 740 (ACPI_SIZE) Info.NumPackages; 741 742 /* Return the total package length */ 743 744 *ObjLength = Info.Length; 745 return_ACPI_STATUS (Status); 746 } 747 748 749 /******************************************************************************* 750 * 751 * FUNCTION: AcpiUtGetObjectSize 752 * 753 * PARAMETERS: InternalObject - An ACPI internal object 754 * ObjLength - Where the length will be returned 755 * 756 * RETURN: Status 757 * 758 * DESCRIPTION: This function is called to determine the space required to 759 * contain an object for return to an API user. 760 * 761 ******************************************************************************/ 762 763 ACPI_STATUS 764 AcpiUtGetObjectSize ( 765 ACPI_OPERAND_OBJECT *InternalObject, 766 ACPI_SIZE *ObjLength) 767 { 768 ACPI_STATUS Status; 769 770 771 ACPI_FUNCTION_ENTRY (); 772 773 774 if ((ACPI_GET_DESCRIPTOR_TYPE (InternalObject) == ACPI_DESC_TYPE_OPERAND) && 775 (InternalObject->Common.Type == ACPI_TYPE_PACKAGE)) 776 { 777 Status = AcpiUtGetPackageObjectSize (InternalObject, ObjLength); 778 } 779 else 780 { 781 Status = AcpiUtGetSimpleObjectSize (InternalObject, ObjLength); 782 } 783 784 return (Status); 785 } 786 787 788