1/****************************************************************************** 2 * 3 * Module Name: utcopy - Internal to external object translation utilities
|
4 * $Revision: 1.122 $
|
4 * $Revision: 1.130 $ |
5 * 6 *****************************************************************************/ 7 8/****************************************************************************** 9 * 10 * 1. Copyright Notice 11 *
|
12 * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
|
12 * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp. |
13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117#define __UTCOPY_C__ 118 119#include <contrib/dev/acpica/acpi.h> 120#include <contrib/dev/acpica/amlcode.h> 121 122 123#define _COMPONENT ACPI_UTILITIES 124 ACPI_MODULE_NAME ("utcopy") 125 126/* Local prototypes */ 127 128static ACPI_STATUS 129AcpiUtCopyIsimpleToEsimple ( 130 ACPI_OPERAND_OBJECT *InternalObject, 131 ACPI_OBJECT *ExternalObject, 132 UINT8 *DataSpace, 133 ACPI_SIZE *BufferSpaceUsed); 134 135static ACPI_STATUS 136AcpiUtCopyIelementToIelement ( 137 UINT8 ObjectType, 138 ACPI_OPERAND_OBJECT *SourceObject, 139 ACPI_GENERIC_STATE *State, 140 void *Context); 141 142static ACPI_STATUS 143AcpiUtCopyIpackageToEpackage ( 144 ACPI_OPERAND_OBJECT *InternalObject, 145 UINT8 *Buffer, 146 ACPI_SIZE *SpaceUsed); 147 148static ACPI_STATUS 149AcpiUtCopyEsimpleToIsimple( 150 ACPI_OBJECT *UserObj, 151 ACPI_OPERAND_OBJECT **ReturnObj); 152 153static ACPI_STATUS 154AcpiUtCopySimpleObject ( 155 ACPI_OPERAND_OBJECT *SourceDesc, 156 ACPI_OPERAND_OBJECT *DestDesc); 157 158static ACPI_STATUS 159AcpiUtCopyIelementToEelement ( 160 UINT8 ObjectType, 161 ACPI_OPERAND_OBJECT *SourceObject, 162 ACPI_GENERIC_STATE *State, 163 void *Context); 164 165static ACPI_STATUS 166AcpiUtCopyIpackageToIpackage ( 167 ACPI_OPERAND_OBJECT *SourceObj, 168 ACPI_OPERAND_OBJECT *DestObj, 169 ACPI_WALK_STATE *WalkState); 170 171 172/******************************************************************************* 173 * 174 * FUNCTION: AcpiUtCopyIsimpleToEsimple 175 * 176 * PARAMETERS: InternalObject - Source object to be copied 177 * ExternalObject - Where to return the copied object 178 * DataSpace - Where object data is returned (such as 179 * buffer and string data) 180 * BufferSpaceUsed - Length of DataSpace that was used 181 * 182 * RETURN: Status 183 * 184 * DESCRIPTION: This function is called to copy a simple internal object to 185 * an external object. 186 * 187 * The DataSpace buffer is assumed to have sufficient space for 188 * the object. 189 * 190 ******************************************************************************/ 191 192static ACPI_STATUS 193AcpiUtCopyIsimpleToEsimple ( 194 ACPI_OPERAND_OBJECT *InternalObject, 195 ACPI_OBJECT *ExternalObject, 196 UINT8 *DataSpace, 197 ACPI_SIZE *BufferSpaceUsed) 198{ 199 ACPI_STATUS Status = AE_OK; 200 201
|
202 ACPI_FUNCTION_TRACE ("UtCopyIsimpleToEsimple");
|
202 ACPI_FUNCTION_TRACE (UtCopyIsimpleToEsimple); |
203 204 205 *BufferSpaceUsed = 0; 206 207 /* 208 * Check for NULL object case (could be an uninitialized 209 * package element) 210 */ 211 if (!InternalObject) 212 { 213 return_ACPI_STATUS (AE_OK); 214 } 215 216 /* Always clear the external object */ 217 218 ACPI_MEMSET (ExternalObject, 0, sizeof (ACPI_OBJECT)); 219 220 /* 221 * In general, the external object will be the same type as 222 * the internal object 223 */ 224 ExternalObject->Type = ACPI_GET_OBJECT_TYPE (InternalObject); 225 226 /* However, only a limited number of external types are supported */ 227 228 switch (ACPI_GET_OBJECT_TYPE (InternalObject)) 229 { 230 case ACPI_TYPE_STRING: 231 232 ExternalObject->String.Pointer = (char *) DataSpace; 233 ExternalObject->String.Length = InternalObject->String.Length; 234 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD ( 235 (ACPI_SIZE) InternalObject->String.Length + 1); 236 237 ACPI_MEMCPY ((void *) DataSpace, 238 (void *) InternalObject->String.Pointer, 239 (ACPI_SIZE) InternalObject->String.Length + 1); 240 break; 241 242 243 case ACPI_TYPE_BUFFER: 244 245 ExternalObject->Buffer.Pointer = DataSpace; 246 ExternalObject->Buffer.Length = InternalObject->Buffer.Length; 247 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD ( 248 InternalObject->String.Length); 249 250 ACPI_MEMCPY ((void *) DataSpace, 251 (void *) InternalObject->Buffer.Pointer, 252 InternalObject->Buffer.Length); 253 break; 254 255 256 case ACPI_TYPE_INTEGER: 257 258 ExternalObject->Integer.Value = InternalObject->Integer.Value; 259 break; 260 261 262 case ACPI_TYPE_LOCAL_REFERENCE: 263 264 /* 265 * This is an object reference. Attempt to dereference it. 266 */ 267 switch (InternalObject->Reference.Opcode) 268 { 269 case AML_INT_NAMEPATH_OP: 270 271 /* For namepath, return the object handle ("reference") */ 272 273 default: 274 /* 275 * Use the object type of "Any" to indicate a reference 276 * to object containing a handle to an ACPI named object. 277 */ 278 ExternalObject->Type = ACPI_TYPE_ANY; 279 ExternalObject->Reference.Handle = InternalObject->Reference.Node; 280 break; 281 } 282 break; 283 284 285 case ACPI_TYPE_PROCESSOR: 286 287 ExternalObject->Processor.ProcId = InternalObject->Processor.ProcId; 288 ExternalObject->Processor.PblkAddress = InternalObject->Processor.Address; 289 ExternalObject->Processor.PblkLength = InternalObject->Processor.Length; 290 break; 291 292 293 case ACPI_TYPE_POWER: 294 295 ExternalObject->PowerResource.SystemLevel = 296 InternalObject->PowerResource.SystemLevel; 297 298 ExternalObject->PowerResource.ResourceOrder = 299 InternalObject->PowerResource.ResourceOrder; 300 break; 301 302 303 default: 304 /* 305 * There is no corresponding external object type 306 */ 307 return_ACPI_STATUS (AE_SUPPORT); 308 } 309 310 return_ACPI_STATUS (Status); 311} 312 313 314/******************************************************************************* 315 * 316 * FUNCTION: AcpiUtCopyIelementToEelement 317 * 318 * PARAMETERS: ACPI_PKG_CALLBACK 319 * 320 * RETURN: Status 321 * 322 * DESCRIPTION: Copy one package element to another package element 323 * 324 ******************************************************************************/ 325 326static ACPI_STATUS 327AcpiUtCopyIelementToEelement ( 328 UINT8 ObjectType, 329 ACPI_OPERAND_OBJECT *SourceObject, 330 ACPI_GENERIC_STATE *State, 331 void *Context) 332{ 333 ACPI_STATUS Status = AE_OK; 334 ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context; 335 ACPI_SIZE ObjectSpace; 336 UINT32 ThisIndex; 337 ACPI_OBJECT *TargetObject; 338 339 340 ACPI_FUNCTION_ENTRY (); 341 342 343 ThisIndex = State->Pkg.Index; 344 TargetObject = (ACPI_OBJECT *) 345 &((ACPI_OBJECT *)(State->Pkg.DestObject))->Package.Elements[ThisIndex]; 346 347 switch (ObjectType) 348 { 349 case ACPI_COPY_TYPE_SIMPLE: 350 351 /* 352 * This is a simple or null object 353 */ 354 Status = AcpiUtCopyIsimpleToEsimple (SourceObject, 355 TargetObject, Info->FreeSpace, &ObjectSpace); 356 if (ACPI_FAILURE (Status)) 357 { 358 return (Status); 359 } 360 break; 361 362 363 case ACPI_COPY_TYPE_PACKAGE: 364 365 /* 366 * Build the package object 367 */ 368 TargetObject->Type = ACPI_TYPE_PACKAGE; 369 TargetObject->Package.Count = SourceObject->Package.Count; 370 TargetObject->Package.Elements = 371 ACPI_CAST_PTR (ACPI_OBJECT, Info->FreeSpace); 372 373 /* 374 * Pass the new package object back to the package walk routine 375 */ 376 State->Pkg.ThisTargetObj = TargetObject; 377 378 /* 379 * Save space for the array of objects (Package elements) 380 * update the buffer length counter 381 */ 382 ObjectSpace = ACPI_ROUND_UP_TO_NATIVE_WORD ( 383 (ACPI_SIZE) TargetObject->Package.Count * 384 sizeof (ACPI_OBJECT)); 385 break; 386 387 388 default: 389 return (AE_BAD_PARAMETER); 390 } 391 392 Info->FreeSpace += ObjectSpace; 393 Info->Length += ObjectSpace; 394 return (Status); 395} 396 397 398/******************************************************************************* 399 * 400 * FUNCTION: AcpiUtCopyIpackageToEpackage 401 * 402 * PARAMETERS: InternalObject - Pointer to the object we are returning 403 * Buffer - Where the object is returned 404 * SpaceUsed - Where the object length is returned 405 * 406 * RETURN: Status 407 * 408 * DESCRIPTION: This function is called to place a package object in a user 409 * buffer. A package object by definition contains other objects. 410 * 411 * The buffer is assumed to have sufficient space for the object. 412 * The caller must have verified the buffer length needed using the 413 * AcpiUtGetObjectSize function before calling this function. 414 * 415 ******************************************************************************/ 416 417static ACPI_STATUS 418AcpiUtCopyIpackageToEpackage ( 419 ACPI_OPERAND_OBJECT *InternalObject, 420 UINT8 *Buffer, 421 ACPI_SIZE *SpaceUsed) 422{ 423 ACPI_OBJECT *ExternalObject; 424 ACPI_STATUS Status; 425 ACPI_PKG_INFO Info; 426 427
|
428 ACPI_FUNCTION_TRACE ("UtCopyIpackageToEpackage");
|
428 ACPI_FUNCTION_TRACE (UtCopyIpackageToEpackage); |
429 430 431 /* 432 * First package at head of the buffer 433 */ 434 ExternalObject = ACPI_CAST_PTR (ACPI_OBJECT, Buffer); 435 436 /* 437 * Free space begins right after the first package 438 */ 439 Info.Length = ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)); 440 Info.FreeSpace = Buffer + ACPI_ROUND_UP_TO_NATIVE_WORD ( 441 sizeof (ACPI_OBJECT)); 442 Info.ObjectSpace = 0; 443 Info.NumPackages = 1; 444 445 ExternalObject->Type = ACPI_GET_OBJECT_TYPE (InternalObject); 446 ExternalObject->Package.Count = InternalObject->Package.Count; 447 ExternalObject->Package.Elements = ACPI_CAST_PTR (ACPI_OBJECT, 448 Info.FreeSpace); 449 450 /* 451 * Leave room for an array of ACPI_OBJECTS in the buffer 452 * and move the free space past it 453 */ 454 Info.Length += (ACPI_SIZE) ExternalObject->Package.Count * 455 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)); 456 Info.FreeSpace += ExternalObject->Package.Count * 457 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)); 458 459 Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject, 460 AcpiUtCopyIelementToEelement, &Info); 461 462 *SpaceUsed = Info.Length; 463 return_ACPI_STATUS (Status); 464} 465 466 467/******************************************************************************* 468 * 469 * FUNCTION: AcpiUtCopyIobjectToEobject 470 * 471 * PARAMETERS: InternalObject - The internal object to be converted 472 * BufferPtr - Where the object is returned 473 * 474 * RETURN: Status 475 * 476 * DESCRIPTION: This function is called to build an API object to be returned to 477 * the caller. 478 * 479 ******************************************************************************/ 480 481ACPI_STATUS 482AcpiUtCopyIobjectToEobject ( 483 ACPI_OPERAND_OBJECT *InternalObject, 484 ACPI_BUFFER *RetBuffer) 485{ 486 ACPI_STATUS Status; 487 488
|
489 ACPI_FUNCTION_TRACE ("UtCopyIobjectToEobject");
|
489 ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject); |
490 491 492 if (ACPI_GET_OBJECT_TYPE (InternalObject) == ACPI_TYPE_PACKAGE) 493 { 494 /* 495 * Package object: Copy all subobjects (including 496 * nested packages) 497 */ 498 Status = AcpiUtCopyIpackageToEpackage (InternalObject, 499 RetBuffer->Pointer, &RetBuffer->Length); 500 } 501 else 502 { 503 /* 504 * Build a simple object (no nested objects) 505 */ 506 Status = AcpiUtCopyIsimpleToEsimple (InternalObject,
|
507 (ACPI_OBJECT *) RetBuffer->Pointer,
508 ((UINT8 *) RetBuffer->Pointer +
509 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
|
507 ACPI_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer), 508 ACPI_ADD_PTR (UINT8, RetBuffer->Pointer, 509 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))), |
510 &RetBuffer->Length); 511 /* 512 * build simple does not include the object size in the length 513 * so we add it in here 514 */ 515 RetBuffer->Length += sizeof (ACPI_OBJECT); 516 } 517 518 return_ACPI_STATUS (Status); 519} 520 521 522/******************************************************************************* 523 * 524 * FUNCTION: AcpiUtCopyEsimpleToIsimple 525 * 526 * PARAMETERS: ExternalObject - The external object to be converted 527 * RetInternalObject - Where the internal object is returned 528 * 529 * RETURN: Status 530 * 531 * DESCRIPTION: This function copies an external object to an internal one. 532 * NOTE: Pointers can be copied, we don't need to copy data. 533 * (The pointers have to be valid in our address space no matter 534 * what we do with them!) 535 * 536 ******************************************************************************/ 537 538static ACPI_STATUS 539AcpiUtCopyEsimpleToIsimple ( 540 ACPI_OBJECT *ExternalObject, 541 ACPI_OPERAND_OBJECT **RetInternalObject) 542{ 543 ACPI_OPERAND_OBJECT *InternalObject; 544 545
|
546 ACPI_FUNCTION_TRACE ("UtCopyEsimpleToIsimple");
|
546 ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple); |
547 548 549 /* 550 * Simple types supported are: String, Buffer, Integer 551 */ 552 switch (ExternalObject->Type) 553 { 554 case ACPI_TYPE_STRING: 555 case ACPI_TYPE_BUFFER: 556 case ACPI_TYPE_INTEGER: 557 558 InternalObject = AcpiUtCreateInternalObject ( 559 (UINT8) ExternalObject->Type); 560 if (!InternalObject) 561 { 562 return_ACPI_STATUS (AE_NO_MEMORY); 563 } 564 break; 565 566 default: 567 /* All other types are not supported */ 568 569 return_ACPI_STATUS (AE_SUPPORT); 570 } 571 572 573 /* Must COPY string and buffer contents */ 574 575 switch (ExternalObject->Type) 576 { 577 case ACPI_TYPE_STRING: 578 579 InternalObject->String.Pointer =
|
580 ACPI_MEM_CALLOCATE ((ACPI_SIZE) ExternalObject->String.Length + 1);
|
580 ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) ExternalObject->String.Length + 1); |
581 if (!InternalObject->String.Pointer) 582 { 583 goto ErrorExit; 584 } 585 586 ACPI_MEMCPY (InternalObject->String.Pointer, 587 ExternalObject->String.Pointer, 588 ExternalObject->String.Length); 589 590 InternalObject->String.Length = ExternalObject->String.Length; 591 break; 592 593 594 case ACPI_TYPE_BUFFER: 595 596 InternalObject->Buffer.Pointer =
|
597 ACPI_MEM_CALLOCATE (ExternalObject->Buffer.Length);
|
597 ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length); |
598 if (!InternalObject->Buffer.Pointer) 599 { 600 goto ErrorExit; 601 } 602 603 ACPI_MEMCPY (InternalObject->Buffer.Pointer, 604 ExternalObject->Buffer.Pointer, 605 ExternalObject->Buffer.Length); 606 607 InternalObject->Buffer.Length = ExternalObject->Buffer.Length; 608 break; 609 610 611 case ACPI_TYPE_INTEGER: 612 613 InternalObject->Integer.Value = ExternalObject->Integer.Value; 614 break; 615 616 default: 617 /* Other types can't get here */ 618 break; 619 } 620 621 *RetInternalObject = InternalObject; 622 return_ACPI_STATUS (AE_OK); 623 624 625ErrorExit: 626 AcpiUtRemoveReference (InternalObject); 627 return_ACPI_STATUS (AE_NO_MEMORY); 628} 629 630 631#ifdef ACPI_FUTURE_IMPLEMENTATION 632/* Code to convert packages that are parameters to control methods */ 633 634/******************************************************************************* 635 * 636 * FUNCTION: AcpiUtCopyEpackageToIpackage 637 * 638 * PARAMETERS: *InternalObject - Pointer to the object we are returning 639 * *Buffer - Where the object is returned 640 * *SpaceUsed - Where the length of the object is returned 641 * 642 * RETURN: Status 643 * 644 * DESCRIPTION: This function is called to place a package object in a user 645 * buffer. A package object by definition contains other objects. 646 * 647 * The buffer is assumed to have sufficient space for the object. 648 * The caller must have verified the buffer length needed using the 649 * AcpiUtGetObjectSize function before calling this function. 650 * 651 ******************************************************************************/ 652 653static ACPI_STATUS 654AcpiUtCopyEpackageToIpackage ( 655 ACPI_OPERAND_OBJECT *InternalObject, 656 UINT8 *Buffer, 657 UINT32 *SpaceUsed) 658{ 659 UINT8 *FreeSpace; 660 ACPI_OBJECT *ExternalObject; 661 UINT32 Length = 0; 662 UINT32 ThisIndex; 663 UINT32 ObjectSpace = 0; 664 ACPI_OPERAND_OBJECT *ThisInternalObj; 665 ACPI_OBJECT *ThisExternalObj; 666 667
|
668 ACPI_FUNCTION_TRACE ("UtCopyEpackageToIpackage");
|
668 ACPI_FUNCTION_TRACE (UtCopyEpackageToIpackage); |
669 670 671 /* 672 * First package at head of the buffer 673 */ 674 ExternalObject = (ACPI_OBJECT *)Buffer; 675 676 /* 677 * Free space begins right after the first package 678 */ 679 FreeSpace = Buffer + sizeof(ACPI_OBJECT); 680 681 682 ExternalObject->Type = ACPI_GET_OBJECT_TYPE (InternalObject); 683 ExternalObject->Package.Count = InternalObject->Package.Count; 684 ExternalObject->Package.Elements = (ACPI_OBJECT *)FreeSpace; 685 686 /* 687 * Build an array of ACPI_OBJECTS in the buffer 688 * and move the free space past it 689 */ 690 FreeSpace += ExternalObject->Package.Count * sizeof(ACPI_OBJECT); 691 692 693 /* Call WalkPackage */ 694 695} 696 697#endif /* Future implementation */ 698 699 700/******************************************************************************* 701 * 702 * FUNCTION: AcpiUtCopyEobjectToIobject 703 * 704 * PARAMETERS: *InternalObject - The external object to be converted 705 * *BufferPtr - Where the internal object is returned 706 * 707 * RETURN: Status - the status of the call 708 * 709 * DESCRIPTION: Converts an external object to an internal object. 710 * 711 ******************************************************************************/ 712 713ACPI_STATUS 714AcpiUtCopyEobjectToIobject ( 715 ACPI_OBJECT *ExternalObject, 716 ACPI_OPERAND_OBJECT **InternalObject) 717{ 718 ACPI_STATUS Status; 719 720
|
721 ACPI_FUNCTION_TRACE ("UtCopyEobjectToIobject");
|
721 ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject); |
722 723 724 if (ExternalObject->Type == ACPI_TYPE_PACKAGE) 725 { 726 /* 727 * Packages as external input to control methods are not supported, 728 */
|
729 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
730 "Packages as parameters not implemented!\n"));
|
729 ACPI_ERROR ((AE_INFO, 730 "Packages as parameters not implemented!")); |
731 732 return_ACPI_STATUS (AE_NOT_IMPLEMENTED); 733 } 734 735 else 736 { 737 /* 738 * Build a simple object (no nested objects) 739 */ 740 Status = AcpiUtCopyEsimpleToIsimple (ExternalObject, InternalObject); 741 } 742 743 return_ACPI_STATUS (Status); 744} 745 746 747/******************************************************************************* 748 * 749 * FUNCTION: AcpiUtCopySimpleObject 750 * 751 * PARAMETERS: SourceDesc - The internal object to be copied 752 * DestDesc - New target object 753 * 754 * RETURN: Status 755 * 756 * DESCRIPTION: Simple copy of one internal object to another. Reference count 757 * of the destination object is preserved. 758 * 759 ******************************************************************************/ 760 761static ACPI_STATUS 762AcpiUtCopySimpleObject ( 763 ACPI_OPERAND_OBJECT *SourceDesc, 764 ACPI_OPERAND_OBJECT *DestDesc) 765{ 766 UINT16 ReferenceCount; 767 ACPI_OPERAND_OBJECT *NextObject; 768 769 770 /* Save fields from destination that we don't want to overwrite */ 771 772 ReferenceCount = DestDesc->Common.ReferenceCount; 773 NextObject = DestDesc->Common.NextObject; 774 775 /* Copy the entire source object over the destination object*/ 776 777 ACPI_MEMCPY ((char *) DestDesc, (char *) SourceDesc, 778 sizeof (ACPI_OPERAND_OBJECT)); 779 780 /* Restore the saved fields */ 781 782 DestDesc->Common.ReferenceCount = ReferenceCount; 783 DestDesc->Common.NextObject = NextObject; 784 785 /* New object is not static, regardless of source */ 786 787 DestDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER; 788 789 /* Handle the objects with extra data */ 790 791 switch (ACPI_GET_OBJECT_TYPE (DestDesc)) 792 { 793 case ACPI_TYPE_BUFFER: 794 /* 795 * Allocate and copy the actual buffer if and only if: 796 * 1) There is a valid buffer pointer 797 * 2) The buffer has a length > 0 798 */ 799 if ((SourceDesc->Buffer.Pointer) && 800 (SourceDesc->Buffer.Length)) 801 { 802 DestDesc->Buffer.Pointer =
|
803 ACPI_MEM_ALLOCATE (SourceDesc->Buffer.Length);
|
803 ACPI_ALLOCATE (SourceDesc->Buffer.Length); |
804 if (!DestDesc->Buffer.Pointer) 805 { 806 return (AE_NO_MEMORY); 807 } 808 809 /* Copy the actual buffer data */ 810 811 ACPI_MEMCPY (DestDesc->Buffer.Pointer, 812 SourceDesc->Buffer.Pointer, 813 SourceDesc->Buffer.Length); 814 } 815 break; 816 817 case ACPI_TYPE_STRING: 818 /* 819 * Allocate and copy the actual string if and only if: 820 * 1) There is a valid string pointer 821 * (Pointer to a NULL string is allowed) 822 */ 823 if (SourceDesc->String.Pointer) 824 { 825 DestDesc->String.Pointer =
|
826 ACPI_MEM_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1);
|
826 ACPI_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1); |
827 if (!DestDesc->String.Pointer) 828 { 829 return (AE_NO_MEMORY); 830 } 831 832 /* Copy the actual string data */ 833 834 ACPI_MEMCPY (DestDesc->String.Pointer, SourceDesc->String.Pointer, 835 (ACPI_SIZE) SourceDesc->String.Length + 1); 836 } 837 break; 838 839 case ACPI_TYPE_LOCAL_REFERENCE: 840 /* 841 * We copied the reference object, so we now must add a reference 842 * to the object pointed to by the reference 843 */ 844 AcpiUtAddReference (SourceDesc->Reference.Object); 845 break; 846
|
847 case ACPI_TYPE_REGION: 848 /* 849 * We copied the Region Handler, so we now must add a reference 850 */ 851 if (DestDesc->Region.Handler) 852 { 853 AcpiUtAddReference (DestDesc->Region.Handler); 854 } 855 break; 856 |
857 default: 858 /* Nothing to do for other simple objects */ 859 break; 860 } 861 862 return (AE_OK); 863} 864 865 866/******************************************************************************* 867 * 868 * FUNCTION: AcpiUtCopyIelementToIelement 869 * 870 * PARAMETERS: ACPI_PKG_CALLBACK 871 * 872 * RETURN: Status 873 * 874 * DESCRIPTION: Copy one package element to another package element 875 * 876 ******************************************************************************/ 877 878static ACPI_STATUS 879AcpiUtCopyIelementToIelement ( 880 UINT8 ObjectType, 881 ACPI_OPERAND_OBJECT *SourceObject, 882 ACPI_GENERIC_STATE *State, 883 void *Context) 884{ 885 ACPI_STATUS Status = AE_OK; 886 UINT32 ThisIndex; 887 ACPI_OPERAND_OBJECT **ThisTargetPtr; 888 ACPI_OPERAND_OBJECT *TargetObject; 889 890 891 ACPI_FUNCTION_ENTRY (); 892 893 894 ThisIndex = State->Pkg.Index; 895 ThisTargetPtr = (ACPI_OPERAND_OBJECT **) 896 &State->Pkg.DestObject->Package.Elements[ThisIndex]; 897 898 switch (ObjectType) 899 { 900 case ACPI_COPY_TYPE_SIMPLE: 901 902 /* A null source object indicates a (legal) null package element */ 903 904 if (SourceObject) 905 { 906 /* 907 * This is a simple object, just copy it 908 */ 909 TargetObject = AcpiUtCreateInternalObject ( 910 ACPI_GET_OBJECT_TYPE (SourceObject)); 911 if (!TargetObject) 912 { 913 return (AE_NO_MEMORY); 914 } 915 916 Status = AcpiUtCopySimpleObject (SourceObject, TargetObject); 917 if (ACPI_FAILURE (Status)) 918 { 919 goto ErrorExit; 920 } 921 922 *ThisTargetPtr = TargetObject; 923 } 924 else 925 { 926 /* Pass through a null element */ 927 928 *ThisTargetPtr = NULL; 929 } 930 break; 931 932 933 case ACPI_COPY_TYPE_PACKAGE: 934 935 /* 936 * This object is a package - go down another nesting level 937 * Create and build the package object 938 */ 939 TargetObject = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE); 940 if (!TargetObject) 941 { 942 return (AE_NO_MEMORY); 943 } 944 945 TargetObject->Package.Count = SourceObject->Package.Count; 946 TargetObject->Common.Flags = SourceObject->Common.Flags; 947 948 /* 949 * Create the object array 950 */
|
941 TargetObject->Package.Elements =
942 ACPI_MEM_CALLOCATE (((ACPI_SIZE) SourceObject->Package.Count + 1) *
943 sizeof (void *));
|
951 TargetObject->Package.Elements = ACPI_ALLOCATE_ZEROED ( 952 ((ACPI_SIZE) SourceObject->Package.Count + 1) * sizeof (void *)); |
953 if (!TargetObject->Package.Elements) 954 { 955 Status = AE_NO_MEMORY; 956 goto ErrorExit; 957 } 958 959 /* 960 * Pass the new package object back to the package walk routine 961 */ 962 State->Pkg.ThisTargetObj = TargetObject; 963 964 /* 965 * Store the object pointer in the parent package object 966 */ 967 *ThisTargetPtr = TargetObject; 968 break; 969 970 971 default: 972 return (AE_BAD_PARAMETER); 973 } 974 975 return (Status); 976 977ErrorExit: 978 AcpiUtRemoveReference (TargetObject); 979 return (Status); 980} 981 982 983/******************************************************************************* 984 * 985 * FUNCTION: AcpiUtCopyIpackageToIpackage 986 * 987 * PARAMETERS: *SourceObj - Pointer to the source package object 988 * *DestObj - Where the internal object is returned 989 * 990 * RETURN: Status - the status of the call 991 * 992 * DESCRIPTION: This function is called to copy an internal package object 993 * into another internal package object. 994 * 995 ******************************************************************************/ 996 997static ACPI_STATUS 998AcpiUtCopyIpackageToIpackage ( 999 ACPI_OPERAND_OBJECT *SourceObj, 1000 ACPI_OPERAND_OBJECT *DestObj, 1001 ACPI_WALK_STATE *WalkState) 1002{ 1003 ACPI_STATUS Status = AE_OK; 1004 1005
|
997 ACPI_FUNCTION_TRACE ("UtCopyIpackageToIpackage");
|
1006 ACPI_FUNCTION_TRACE (UtCopyIpackageToIpackage); |
1007 1008 1009 DestObj->Common.Type = ACPI_GET_OBJECT_TYPE (SourceObj); 1010 DestObj->Common.Flags = SourceObj->Common.Flags; 1011 DestObj->Package.Count = SourceObj->Package.Count; 1012 1013 /* 1014 * Create the object array and walk the source package tree 1015 */
|
1007 DestObj->Package.Elements = ACPI_MEM_CALLOCATE (
|
1016 DestObj->Package.Elements = ACPI_ALLOCATE_ZEROED ( |
1017 ((ACPI_SIZE) SourceObj->Package.Count + 1) * 1018 sizeof (void *)); 1019 if (!DestObj->Package.Elements) 1020 {
|
1012 ACPI_REPORT_ERROR (
1013 ("AmlBuildCopyInternalPackageObject: Package allocation failure\n"));
|
1021 ACPI_ERROR ((AE_INFO, "Package allocation failure")); |
1022 return_ACPI_STATUS (AE_NO_MEMORY); 1023 } 1024 1025 /* 1026 * Copy the package element-by-element by walking the package "tree". 1027 * This handles nested packages of arbitrary depth. 1028 */ 1029 Status = AcpiUtWalkPackageTree (SourceObj, DestObj,
|
1022 AcpiUtCopyIelementToIelement, WalkState);
|
1030 AcpiUtCopyIelementToIelement, WalkState); |
1031 if (ACPI_FAILURE (Status)) 1032 { 1033 /* On failure, delete the destination package object */ 1034 1035 AcpiUtRemoveReference (DestObj); 1036 } 1037 1038 return_ACPI_STATUS (Status); 1039} 1040 1041 1042/******************************************************************************* 1043 * 1044 * FUNCTION: AcpiUtCopyIobjectToIobject 1045 * 1046 * PARAMETERS: WalkState - Current walk state 1047 * SourceDesc - The internal object to be copied 1048 * DestDesc - Where the copied object is returned 1049 * 1050 * RETURN: Status 1051 * 1052 * DESCRIPTION: Copy an internal object to a new internal object 1053 * 1054 ******************************************************************************/ 1055 1056ACPI_STATUS 1057AcpiUtCopyIobjectToIobject ( 1058 ACPI_OPERAND_OBJECT *SourceDesc, 1059 ACPI_OPERAND_OBJECT **DestDesc, 1060 ACPI_WALK_STATE *WalkState) 1061{ 1062 ACPI_STATUS Status = AE_OK; 1063 1064
|
1057 ACPI_FUNCTION_TRACE ("UtCopyIobjectToIobject");
|
1065 ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject); |
1066 1067 1068 /* Create the top level object */ 1069 1070 *DestDesc = AcpiUtCreateInternalObject (ACPI_GET_OBJECT_TYPE (SourceDesc)); 1071 if (!*DestDesc) 1072 { 1073 return_ACPI_STATUS (AE_NO_MEMORY); 1074 } 1075 1076 /* Copy the object and possible subobjects */ 1077 1078 if (ACPI_GET_OBJECT_TYPE (SourceDesc) == ACPI_TYPE_PACKAGE) 1079 { 1080 Status = AcpiUtCopyIpackageToIpackage (SourceDesc, *DestDesc, 1081 WalkState); 1082 } 1083 else 1084 { 1085 Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc); 1086 } 1087 1088 return_ACPI_STATUS (Status); 1089} 1090 1091
|