reactos/drivers/bus/acpi/acpica/utilities/utcopy.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utcopy - Internal to external object translation utilities
   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 "acpi.h"
  45 #include "accommon.h"
  46 #include "acnamesp.h"
  47
  48
  49 #define _COMPONENT          ACPI_UTILITIES
  50         ACPI_MODULE_NAME    ("utcopy")
  51
  52 /* Local prototypes */
  53
  54 static ACPI_STATUS
  55 AcpiUtCopyIsimpleToEsimple (
  56     ACPI_OPERAND_OBJECT     *InternalObject,
  57     ACPI_OBJECT             *ExternalObject,
  58     UINT8                   *DataSpace,
  59     ACPI_SIZE               *BufferSpaceUsed);
  60
  61 static ACPI_STATUS
  62 AcpiUtCopyIelementToIelement (
  63     UINT8                   ObjectType,
  64     ACPI_OPERAND_OBJECT     *SourceObject,
  65     ACPI_GENERIC_STATE      *State,
  66     void                    *Context);
  67
  68 static ACPI_STATUS
  69 AcpiUtCopyIpackageToEpackage (
  70     ACPI_OPERAND_OBJECT     *InternalObject,
  71     UINT8                   *Buffer,
  72     ACPI_SIZE               *SpaceUsed);
  73
  74 static ACPI_STATUS
  75 AcpiUtCopyEsimpleToIsimple(
  76     ACPI_OBJECT             *UserObj,
  77     ACPI_OPERAND_OBJECT     **ReturnObj);
  78
  79 static ACPI_STATUS
  80 AcpiUtCopyEpackageToIpackage (
  81     ACPI_OBJECT             *ExternalObject,
  82     ACPI_OPERAND_OBJECT     **InternalObject);
  83
  84 static ACPI_STATUS
  85 AcpiUtCopySimpleObject (
  86     ACPI_OPERAND_OBJECT     *SourceDesc,
  87     ACPI_OPERAND_OBJECT     *DestDesc);
  88
  89 static ACPI_STATUS
  90 AcpiUtCopyIelementToEelement (
  91     UINT8                   ObjectType,
  92     ACPI_OPERAND_OBJECT     *SourceObject,
  93     ACPI_GENERIC_STATE      *State,
  94     void                    *Context);
  95
  96 static ACPI_STATUS
  97 AcpiUtCopyIpackageToIpackage (
  98     ACPI_OPERAND_OBJECT     *SourceObj,
  99     ACPI_OPERAND_OBJECT     *DestObj,
 100     ACPI_WALK_STATE         *WalkState);
 101
 102
 103 /*******************************************************************************
 104  *
 105  * FUNCTION:    AcpiUtCopyIsimpleToEsimple
 106  *
 107  * PARAMETERS:  InternalObject      - Source object to be copied
 108  *              ExternalObject      - Where to return the copied object
 109  *              DataSpace           - Where object data is returned (such as
 110  *                                    buffer and string data)
 111  *              BufferSpaceUsed     - Length of DataSpace that was used
 112  *
 113  * RETURN:      Status
 114  *
 115  * DESCRIPTION: This function is called to copy a simple internal object to
 116  *              an external object.
 117  *
 118  *              The DataSpace buffer is assumed to have sufficient space for
 119  *              the object.
 120  *
 121  ******************************************************************************/
 122
 123 static ACPI_STATUS
 124 AcpiUtCopyIsimpleToEsimple (
 125     ACPI_OPERAND_OBJECT     *InternalObject,
 126     ACPI_OBJECT             *ExternalObject,
 127     UINT8                   *DataSpace,
 128     ACPI_SIZE               *BufferSpaceUsed)
 129 {
 130     ACPI_STATUS             Status = AE_OK;
 131
 132
 133     ACPI_FUNCTION_TRACE (UtCopyIsimpleToEsimple);
 134
 135
 136     *BufferSpaceUsed = 0;
 137
 138     /*
 139      * Check for NULL object case (could be an uninitialized
 140      * package element)
 141      */
 142     if (!InternalObject)
 143     {
 144         return_ACPI_STATUS (AE_OK);
 145     }
 146
 147     /* Always clear the external object */
 148
 149     memset (ExternalObject, 0, sizeof (ACPI_OBJECT));
 150
 151     /*
 152      * In general, the external object will be the same type as
 153      * the internal object
 154      */
 155     ExternalObject->Type = InternalObject->Common.Type;
 156
 157     /* However, only a limited number of external types are supported */
 158
 159     switch (InternalObject->Common.Type)
 160     {
 161     case ACPI_TYPE_STRING:
 162
 163         ExternalObject->String.Pointer = (char *) DataSpace;
 164         ExternalObject->String.Length  = InternalObject->String.Length;
 165         *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
 166             (ACPI_SIZE) InternalObject->String.Length + 1);
 167
 168         memcpy ((void *) DataSpace,
 169             (void *) InternalObject->String.Pointer,
 170             (ACPI_SIZE) InternalObject->String.Length + 1);
 171         break;
 172
 173     case ACPI_TYPE_BUFFER:
 174
 175         ExternalObject->Buffer.Pointer = DataSpace;
 176         ExternalObject->Buffer.Length  = InternalObject->Buffer.Length;
 177         *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
 178             InternalObject->String.Length);
 179
 180         memcpy ((void *) DataSpace,
 181             (void *) InternalObject->Buffer.Pointer,
 182             InternalObject->Buffer.Length);
 183         break;
 184
 185     case ACPI_TYPE_INTEGER:
 186
 187         ExternalObject->Integer.Value = InternalObject->Integer.Value;
 188         break;
 189
 190     case ACPI_TYPE_LOCAL_REFERENCE:
 191
 192         /* This is an object reference. */
 193
 194         switch (InternalObject->Reference.Class)
 195         {
 196         case ACPI_REFCLASS_NAME:
 197             /*
 198              * For namepath, return the object handle ("reference")
 199              * We are referring to the namespace node
 200              */
 201             ExternalObject->Reference.Handle =
 202                 InternalObject->Reference.Node;
 203             ExternalObject->Reference.ActualType =
 204                 AcpiNsGetType (InternalObject->Reference.Node);
 205             break;
 206
 207         default:
 208
 209             /* All other reference types are unsupported */
 210
 211             return_ACPI_STATUS (AE_TYPE);
 212         }
 213         break;
 214
 215     case ACPI_TYPE_PROCESSOR:
 216
 217         ExternalObject->Processor.ProcId =
 218             InternalObject->Processor.ProcId;
 219         ExternalObject->Processor.PblkAddress =
 220             InternalObject->Processor.Address;
 221         ExternalObject->Processor.PblkLength =
 222             InternalObject->Processor.Length;
 223         break;
 224
 225     case ACPI_TYPE_POWER:
 226
 227         ExternalObject->PowerResource.SystemLevel =
 228             InternalObject->PowerResource.SystemLevel;
 229
 230         ExternalObject->PowerResource.ResourceOrder =
 231             InternalObject->PowerResource.ResourceOrder;
 232         break;
 233
 234     default:
 235         /*
 236          * There is no corresponding external object type
 237          */
 238         ACPI_ERROR ((AE_INFO,
 239             "Unsupported object type, cannot convert to external object: %s",
 240             AcpiUtGetTypeName (InternalObject->Common.Type)));
 241
 242         return_ACPI_STATUS (AE_SUPPORT);
 243     }
 244
 245     return_ACPI_STATUS (Status);
 246 }
 247
 248
 249 /*******************************************************************************
 250  *
 251  * FUNCTION:    AcpiUtCopyIelementToEelement
 252  *
 253  * PARAMETERS:  ACPI_PKG_CALLBACK
 254  *
 255  * RETURN:      Status
 256  *
 257  * DESCRIPTION: Copy one package element to another package element
 258  *
 259  ******************************************************************************/
 260
 261 static ACPI_STATUS
 262 AcpiUtCopyIelementToEelement (
 263     UINT8                   ObjectType,
 264     ACPI_OPERAND_OBJECT     *SourceObject,
 265     ACPI_GENERIC_STATE      *State,
 266     void                    *Context)
 267 {
 268     ACPI_STATUS             Status = AE_OK;
 269     ACPI_PKG_INFO           *Info = (ACPI_PKG_INFO *) Context;
 270     ACPI_SIZE               ObjectSpace;
 271     UINT32                  ThisIndex;
 272     ACPI_OBJECT             *TargetObject;
 273
 274
 275     ACPI_FUNCTION_ENTRY ();
 276
 277
 278     ThisIndex = State->Pkg.Index;
 279     TargetObject = (ACPI_OBJECT *) &((ACPI_OBJECT *)
 280         (State->Pkg.DestObject))->Package.Elements[ThisIndex];
 281
 282     switch (ObjectType)
 283     {
 284     case ACPI_COPY_TYPE_SIMPLE:
 285         /*
 286          * This is a simple or null object
 287          */
 288         Status = AcpiUtCopyIsimpleToEsimple (SourceObject,
 289             TargetObject, Info->FreeSpace, &ObjectSpace);
 290         if (ACPI_FAILURE (Status))
 291         {
 292             return (Status);
 293         }
 294         break;
 295
 296     case ACPI_COPY_TYPE_PACKAGE:
 297         /*
 298          * Build the package object
 299          */
 300         TargetObject->Type = ACPI_TYPE_PACKAGE;
 301         TargetObject->Package.Count = SourceObject->Package.Count;
 302         TargetObject->Package.Elements =
 303             ACPI_CAST_PTR (ACPI_OBJECT, Info->FreeSpace);
 304
 305         /*
 306          * Pass the new package object back to the package walk routine
 307          */
 308         State->Pkg.ThisTargetObj = TargetObject;
 309
 310         /*
 311          * Save space for the array of objects (Package elements)
 312          * update the buffer length counter
 313          */
 314         ObjectSpace = ACPI_ROUND_UP_TO_NATIVE_WORD (
 315             (ACPI_SIZE) TargetObject->Package.Count *
 316             sizeof (ACPI_OBJECT));
 317         break;
 318
 319     default:
 320
 321         return (AE_BAD_PARAMETER);
 322     }
 323
 324     Info->FreeSpace += ObjectSpace;
 325     Info->Length += ObjectSpace;
 326     return (Status);
 327 }
 328
 329
 330 /*******************************************************************************
 331  *
 332  * FUNCTION:    AcpiUtCopyIpackageToEpackage
 333  *
 334  * PARAMETERS:  InternalObject      - Pointer to the object we are returning
 335  *              Buffer              - Where the object is returned
 336  *              SpaceUsed           - Where the object length is returned
 337  *
 338  * RETURN:      Status
 339  *
 340  * DESCRIPTION: This function is called to place a package object in a user
 341  *              buffer. A package object by definition contains other objects.
 342  *
 343  *              The buffer is assumed to have sufficient space for the object.
 344  *              The caller must have verified the buffer length needed using
 345  *              the AcpiUtGetObjectSize function before calling this function.
 346  *
 347  ******************************************************************************/
 348
 349 static ACPI_STATUS
 350 AcpiUtCopyIpackageToEpackage (
 351     ACPI_OPERAND_OBJECT     *InternalObject,
 352     UINT8                   *Buffer,
 353     ACPI_SIZE               *SpaceUsed)
 354 {
 355     ACPI_OBJECT             *ExternalObject;
 356     ACPI_STATUS             Status;
 357     ACPI_PKG_INFO           Info;
 358
 359
 360     ACPI_FUNCTION_TRACE (UtCopyIpackageToEpackage);
 361
 362
 363     /*
 364      * First package at head of the buffer
 365      */
 366     ExternalObject = ACPI_CAST_PTR (ACPI_OBJECT, Buffer);
 367
 368     /*
 369      * Free space begins right after the first package
 370      */
 371     Info.Length = ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
 372     Info.FreeSpace = Buffer +
 373         ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
 374     Info.ObjectSpace = 0;
 375     Info.NumPackages = 1;
 376
 377     ExternalObject->Type = InternalObject->Common.Type;
 378     ExternalObject->Package.Count = InternalObject->Package.Count;
 379     ExternalObject->Package.Elements =
 380         ACPI_CAST_PTR (ACPI_OBJECT, Info.FreeSpace);
 381
 382     /*
 383      * Leave room for an array of ACPI_OBJECTS in the buffer
 384      * and move the free space past it
 385      */
 386     Info.Length += (ACPI_SIZE) ExternalObject->Package.Count *
 387         ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
 388     Info.FreeSpace += ExternalObject->Package.Count *
 389         ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
 390
 391     Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject,
 392         AcpiUtCopyIelementToEelement, &Info);
 393
 394     *SpaceUsed = Info.Length;
 395     return_ACPI_STATUS (Status);
 396 }
 397
 398
 399 /*******************************************************************************
 400  *
 401  * FUNCTION:    AcpiUtCopyIobjectToEobject
 402  *
 403  * PARAMETERS:  InternalObject      - The internal object to be converted
 404  *              RetBuffer           - Where the object is returned
 405  *
 406  * RETURN:      Status
 407  *
 408  * DESCRIPTION: This function is called to build an API object to be returned
 409  *              to the caller.
 410  *
 411  ******************************************************************************/
 412
 413 ACPI_STATUS
 414 AcpiUtCopyIobjectToEobject (
 415     ACPI_OPERAND_OBJECT     *InternalObject,
 416     ACPI_BUFFER             *RetBuffer)
 417 {
 418     ACPI_STATUS             Status;
 419
 420
 421     ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject);
 422
 423
 424     if (InternalObject->Common.Type == ACPI_TYPE_PACKAGE)
 425     {
 426         /*
 427          * Package object:  Copy all subobjects (including
 428          * nested packages)
 429          */
 430         Status = AcpiUtCopyIpackageToEpackage (InternalObject,
 431             RetBuffer->Pointer, &RetBuffer->Length);
 432     }
 433     else
 434     {
 435         /*
 436          * Build a simple object (no nested objects)
 437          */
 438         Status = AcpiUtCopyIsimpleToEsimple (InternalObject,
 439             ACPI_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer),
 440             ACPI_ADD_PTR (UINT8, RetBuffer->Pointer,
 441                 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
 442             &RetBuffer->Length);
 443         /*
 444          * build simple does not include the object size in the length
 445          * so we add it in here
 446          */
 447         RetBuffer->Length += sizeof (ACPI_OBJECT);
 448     }
 449
 450     return_ACPI_STATUS (Status);
 451 }
 452
 453
 454 /*******************************************************************************
 455  *
 456  * FUNCTION:    AcpiUtCopyEsimpleToIsimple
 457  *
 458  * PARAMETERS:  ExternalObject      - The external object to be converted
 459  *              RetInternalObject   - Where the internal object is returned
 460  *
 461  * RETURN:      Status
 462  *
 463  * DESCRIPTION: This function copies an external object to an internal one.
 464  *              NOTE: Pointers can be copied, we don't need to copy data.
 465  *              (The pointers have to be valid in our address space no matter
 466  *              what we do with them!)
 467  *
 468  ******************************************************************************/
 469
 470 static ACPI_STATUS
 471 AcpiUtCopyEsimpleToIsimple (
 472     ACPI_OBJECT             *ExternalObject,
 473     ACPI_OPERAND_OBJECT     **RetInternalObject)
 474 {
 475     ACPI_OPERAND_OBJECT     *InternalObject;
 476
 477
 478     ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple);
 479
 480
 481     /*
 482      * Simple types supported are: String, Buffer, Integer
 483      */
 484     switch (ExternalObject->Type)
 485     {
 486     case ACPI_TYPE_STRING:
 487     case ACPI_TYPE_BUFFER:
 488     case ACPI_TYPE_INTEGER:
 489     case ACPI_TYPE_LOCAL_REFERENCE:
 490
 491         InternalObject = AcpiUtCreateInternalObject (
 492             (UINT8) ExternalObject->Type);
 493         if (!InternalObject)
 494         {
 495             return_ACPI_STATUS (AE_NO_MEMORY);
 496         }
 497         break;
 498
 499     case ACPI_TYPE_ANY: /* This is the case for a NULL object */
 500
 501         *RetInternalObject = NULL;
 502         return_ACPI_STATUS (AE_OK);
 503
 504     default:
 505
 506         /* All other types are not supported */
 507
 508         ACPI_ERROR ((AE_INFO,
 509             "Unsupported object type, cannot convert to internal object: %s",
 510             AcpiUtGetTypeName (ExternalObject->Type)));
 511
 512         return_ACPI_STATUS (AE_SUPPORT);
 513     }
 514
 515
 516     /* Must COPY string and buffer contents */
 517
 518     switch (ExternalObject->Type)
 519     {
 520     case ACPI_TYPE_STRING:
 521
 522         InternalObject->String.Pointer =
 523             ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)
 524                 ExternalObject->String.Length + 1);
 525
 526         if (!InternalObject->String.Pointer)
 527         {
 528             goto ErrorExit;
 529         }
 530
 531         memcpy (InternalObject->String.Pointer,
 532             ExternalObject->String.Pointer,
 533             ExternalObject->String.Length);
 534
 535         InternalObject->String.Length = ExternalObject->String.Length;
 536         break;
 537
 538     case ACPI_TYPE_BUFFER:
 539
 540         InternalObject->Buffer.Pointer =
 541             ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length);
 542         if (!InternalObject->Buffer.Pointer)
 543         {
 544             goto ErrorExit;
 545         }
 546
 547         memcpy (InternalObject->Buffer.Pointer,
 548             ExternalObject->Buffer.Pointer,
 549             ExternalObject->Buffer.Length);
 550
 551         InternalObject->Buffer.Length = ExternalObject->Buffer.Length;
 552
 553         /* Mark buffer data valid */
 554
 555         InternalObject->Buffer.Flags |= AOPOBJ_DATA_VALID;
 556         break;
 557
 558     case ACPI_TYPE_INTEGER:
 559
 560         InternalObject->Integer.Value = ExternalObject->Integer.Value;
 561         break;
 562
 563     case ACPI_TYPE_LOCAL_REFERENCE:
 564
 565         /* An incoming reference is defined to be a namespace node */
 566
 567         InternalObject->Reference.Class = ACPI_REFCLASS_REFOF;
 568         InternalObject->Reference.Object = ExternalObject->Reference.Handle;
 569         break;
 570
 571     default:
 572
 573         /* Other types can't get here */
 574
 575         break;
 576     }
 577
 578     *RetInternalObject = InternalObject;
 579     return_ACPI_STATUS (AE_OK);
 580
 581
 582 ErrorExit:
 583     AcpiUtRemoveReference (InternalObject);
 584     return_ACPI_STATUS (AE_NO_MEMORY);
 585 }
 586
 587
 588 /*******************************************************************************
 589  *
 590  * FUNCTION:    AcpiUtCopyEpackageToIpackage
 591  *
 592  * PARAMETERS:  ExternalObject      - The external object to be converted
 593  *              InternalObject      - Where the internal object is returned
 594  *
 595  * RETURN:      Status
 596  *
 597  * DESCRIPTION: Copy an external package object to an internal package.
 598  *              Handles nested packages.
 599  *
 600  ******************************************************************************/
 601
 602 static ACPI_STATUS
 603 AcpiUtCopyEpackageToIpackage (
 604     ACPI_OBJECT             *ExternalObject,
 605     ACPI_OPERAND_OBJECT     **InternalObject)
 606 {
 607     ACPI_STATUS             Status = AE_OK;
 608     ACPI_OPERAND_OBJECT     *PackageObject;
 609     ACPI_OPERAND_OBJECT     **PackageElements;
 610     UINT32                  i;
 611
 612
 613     ACPI_FUNCTION_TRACE (UtCopyEpackageToIpackage);
 614
 615
 616     /* Create the package object */
 617
 618     PackageObject = AcpiUtCreatePackageObject (
 619         ExternalObject->Package.Count);
 620     if (!PackageObject)
 621     {
 622         return_ACPI_STATUS (AE_NO_MEMORY);
 623     }
 624
 625     PackageElements = PackageObject->Package.Elements;
 626
 627     /*
 628      * Recursive implementation. Probably ok, since nested external
 629      * packages as parameters should be very rare.
 630      */
 631     for (i = 0; i < ExternalObject->Package.Count; i++)
 632     {
 633         Status = AcpiUtCopyEobjectToIobject (
 634             &ExternalObject->Package.Elements[i],
 635             &PackageElements[i]);
 636         if (ACPI_FAILURE (Status))
 637         {
 638             /* Truncate package and delete it */
 639
 640             PackageObject->Package.Count = i;
 641             PackageElements[i] = NULL;
 642             AcpiUtRemoveReference (PackageObject);
 643             return_ACPI_STATUS (Status);
 644         }
 645     }
 646
 647     /* Mark package data valid */
 648
 649     PackageObject->Package.Flags |= AOPOBJ_DATA_VALID;
 650
 651     *InternalObject = PackageObject;
 652     return_ACPI_STATUS (Status);
 653 }
 654
 655
 656 /*******************************************************************************
 657  *
 658  * FUNCTION:    AcpiUtCopyEobjectToIobject
 659  *
 660  * PARAMETERS:  ExternalObject      - The external object to be converted
 661  *              InternalObject      - Where the internal object is returned
 662  *
 663  * RETURN:      Status
 664  *
 665  * DESCRIPTION: Converts an external object to an internal object.
 666  *
 667  ******************************************************************************/
 668
 669 ACPI_STATUS
 670 AcpiUtCopyEobjectToIobject (
 671     ACPI_OBJECT             *ExternalObject,
 672     ACPI_OPERAND_OBJECT     **InternalObject)
 673 {
 674     ACPI_STATUS             Status;
 675
 676
 677     ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject);
 678
 679
 680     if (ExternalObject->Type == ACPI_TYPE_PACKAGE)
 681     {
 682         Status = AcpiUtCopyEpackageToIpackage (
 683             ExternalObject, InternalObject);
 684     }
 685     else
 686     {
 687         /*
 688          * Build a simple object (no nested objects)
 689          */
 690         Status = AcpiUtCopyEsimpleToIsimple (ExternalObject,
 691             InternalObject);
 692     }
 693
 694     return_ACPI_STATUS (Status);
 695 }
 696
 697
 698 /*******************************************************************************
 699  *
 700  * FUNCTION:    AcpiUtCopySimpleObject
 701  *
 702  * PARAMETERS:  SourceDesc          - The internal object to be copied
 703  *              DestDesc            - New target object
 704  *
 705  * RETURN:      Status
 706  *
 707  * DESCRIPTION: Simple copy of one internal object to another. Reference count
 708  *              of the destination object is preserved.
 709  *
 710  ******************************************************************************/
 711
 712 static ACPI_STATUS
 713 AcpiUtCopySimpleObject (
 714     ACPI_OPERAND_OBJECT     *SourceDesc,
 715     ACPI_OPERAND_OBJECT     *DestDesc)
 716 {
 717     UINT16                  ReferenceCount;
 718     ACPI_OPERAND_OBJECT     *NextObject;
 719     ACPI_STATUS             Status;
 720     ACPI_SIZE               CopySize;
 721
 722
 723     /* Save fields from destination that we don't want to overwrite */
 724
 725     ReferenceCount = DestDesc->Common.ReferenceCount;
 726     NextObject = DestDesc->Common.NextObject;
 727
 728     /*
 729      * Copy the entire source object over the destination object.
 730      * Note: Source can be either an operand object or namespace node.
 731      */
 732     CopySize = sizeof (ACPI_OPERAND_OBJECT);
 733     if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_NAMED)
 734     {
 735         CopySize = sizeof (ACPI_NAMESPACE_NODE);
 736     }
 737
 738     memcpy (ACPI_CAST_PTR (char, DestDesc),
 739         ACPI_CAST_PTR (char, SourceDesc), CopySize);
 740
 741     /* Restore the saved fields */
 742
 743     DestDesc->Common.ReferenceCount = ReferenceCount;
 744     DestDesc->Common.NextObject = NextObject;
 745
 746     /* New object is not static, regardless of source */
 747
 748     DestDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
 749
 750     /* Handle the objects with extra data */
 751
 752     switch (DestDesc->Common.Type)
 753     {
 754     case ACPI_TYPE_BUFFER:
 755         /*
 756          * Allocate and copy the actual buffer if and only if:
 757          * 1) There is a valid buffer pointer
 758          * 2) The buffer has a length > 0
 759          */
 760         if ((SourceDesc->Buffer.Pointer) &&
 761             (SourceDesc->Buffer.Length))
 762         {
 763             DestDesc->Buffer.Pointer =
 764                 ACPI_ALLOCATE (SourceDesc->Buffer.Length);
 765             if (!DestDesc->Buffer.Pointer)
 766             {
 767                 return (AE_NO_MEMORY);
 768             }
 769
 770             /* Copy the actual buffer data */
 771
 772             memcpy (DestDesc->Buffer.Pointer,
 773                 SourceDesc->Buffer.Pointer, SourceDesc->Buffer.Length);
 774         }
 775         break;
 776
 777     case ACPI_TYPE_STRING:
 778         /*
 779          * Allocate and copy the actual string if and only if:
 780          * 1) There is a valid string pointer
 781          * (Pointer to a NULL string is allowed)
 782          */
 783         if (SourceDesc->String.Pointer)
 784         {
 785             DestDesc->String.Pointer =
 786                 ACPI_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1);
 787             if (!DestDesc->String.Pointer)
 788             {
 789                 return (AE_NO_MEMORY);
 790             }
 791
 792             /* Copy the actual string data */
 793
 794             memcpy (DestDesc->String.Pointer, SourceDesc->String.Pointer,
 795                 (ACPI_SIZE) SourceDesc->String.Length + 1);
 796         }
 797         break;
 798
 799     case ACPI_TYPE_LOCAL_REFERENCE:
 800         /*
 801          * We copied the reference object, so we now must add a reference
 802          * to the object pointed to by the reference
 803          *
 804          * DDBHandle reference (from Load/LoadTable) is a special reference,
 805          * it does not have a Reference.Object, so does not need to
 806          * increase the reference count
 807          */
 808         if (SourceDesc->Reference.Class == ACPI_REFCLASS_TABLE)
 809         {
 810             break;
 811         }
 812
 813         AcpiUtAddReference (SourceDesc->Reference.Object);
 814         break;
 815
 816     case ACPI_TYPE_REGION:
 817         /*
 818          * We copied the Region Handler, so we now must add a reference
 819          */
 820         if (DestDesc->Region.Handler)
 821         {
 822             AcpiUtAddReference (DestDesc->Region.Handler);
 823         }
 824         break;
 825
 826     /*
 827      * For Mutex and Event objects, we cannot simply copy the underlying
 828      * OS object. We must create a new one.
 829      */
 830     case ACPI_TYPE_MUTEX:
 831
 832         Status = AcpiOsCreateMutex (&DestDesc->Mutex.OsMutex);
 833         if (ACPI_FAILURE (Status))
 834         {
 835             return (Status);
 836         }
 837         break;
 838
 839     case ACPI_TYPE_EVENT:
 840
 841         Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
 842             &DestDesc->Event.OsSemaphore);
 843         if (ACPI_FAILURE (Status))
 844         {
 845             return (Status);
 846         }
 847         break;
 848
 849     default:
 850
 851         /* Nothing to do for other simple objects */
 852
 853         break;
 854     }
 855
 856     return (AE_OK);
 857 }
 858
 859
 860 /*******************************************************************************
 861  *
 862  * FUNCTION:    AcpiUtCopyIelementToIelement
 863  *
 864  * PARAMETERS:  ACPI_PKG_CALLBACK
 865  *
 866  * RETURN:      Status
 867  *
 868  * DESCRIPTION: Copy one package element to another package element
 869  *
 870  ******************************************************************************/
 871
 872 static ACPI_STATUS
 873 AcpiUtCopyIelementToIelement (
 874     UINT8                   ObjectType,
 875     ACPI_OPERAND_OBJECT     *SourceObject,
 876     ACPI_GENERIC_STATE      *State,
 877     void                    *Context)
 878 {
 879     ACPI_STATUS             Status = AE_OK;
 880     UINT32                  ThisIndex;
 881     ACPI_OPERAND_OBJECT     **ThisTargetPtr;
 882     ACPI_OPERAND_OBJECT     *TargetObject;
 883
 884
 885     ACPI_FUNCTION_ENTRY ();
 886
 887
 888     ThisIndex = State->Pkg.Index;
 889     ThisTargetPtr = (ACPI_OPERAND_OBJECT **)
 890         &State->Pkg.DestObject->Package.Elements[ThisIndex];
 891
 892     switch (ObjectType)
 893     {
 894     case ACPI_COPY_TYPE_SIMPLE:
 895
 896         /* A null source object indicates a (legal) null package element */
 897
 898         if (SourceObject)
 899         {
 900             /*
 901              * This is a simple object, just copy it
 902              */
 903             TargetObject = AcpiUtCreateInternalObject (
 904                 SourceObject->Common.Type);
 905             if (!TargetObject)
 906             {
 907                 return (AE_NO_MEMORY);
 908             }
 909
 910             Status = AcpiUtCopySimpleObject (SourceObject, TargetObject);
 911             if (ACPI_FAILURE (Status))
 912             {
 913                 goto ErrorExit;
 914             }
 915
 916             *ThisTargetPtr = TargetObject;
 917         }
 918         else
 919         {
 920             /* Pass through a null element */
 921
 922             *ThisTargetPtr = NULL;
 923         }
 924         break;
 925
 926     case ACPI_COPY_TYPE_PACKAGE:
 927         /*
 928          * This object is a package - go down another nesting level
 929          * Create and build the package object
 930          */
 931         TargetObject = AcpiUtCreatePackageObject (
 932             SourceObject->Package.Count);
 933         if (!TargetObject)
 934         {
 935             return (AE_NO_MEMORY);
 936         }
 937
 938         TargetObject->Common.Flags = SourceObject->Common.Flags;
 939
 940         /* Pass the new package object back to the package walk routine */
 941
 942         State->Pkg.ThisTargetObj = TargetObject;
 943
 944         /* Store the object pointer in the parent package object */
 945
 946         *ThisTargetPtr = TargetObject;
 947         break;
 948
 949     default:
 950
 951         return (AE_BAD_PARAMETER);
 952     }
 953
 954     return (Status);
 955
 956 ErrorExit:
 957     AcpiUtRemoveReference (TargetObject);
 958     return (Status);
 959 }
 960
 961
 962 /*******************************************************************************
 963  *
 964  * FUNCTION:    AcpiUtCopyIpackageToIpackage
 965  *
 966  * PARAMETERS:  SourceObj       - Pointer to the source package object
 967  *              DestObj         - Where the internal object is returned
 968  *              WalkState       - Current Walk state descriptor
 969  *
 970  * RETURN:      Status
 971  *
 972  * DESCRIPTION: This function is called to copy an internal package object
 973  *              into another internal package object.
 974  *
 975  ******************************************************************************/
 976
 977 static ACPI_STATUS
 978 AcpiUtCopyIpackageToIpackage (
 979     ACPI_OPERAND_OBJECT     *SourceObj,
 980     ACPI_OPERAND_OBJECT     *DestObj,
 981     ACPI_WALK_STATE         *WalkState)
 982 {
 983     ACPI_STATUS             Status = AE_OK;
 984
 985
 986     ACPI_FUNCTION_TRACE (UtCopyIpackageToIpackage);
 987
 988
 989     DestObj->Common.Type = SourceObj->Common.Type;
 990     DestObj->Common.Flags = SourceObj->Common.Flags;
 991     DestObj->Package.Count = SourceObj->Package.Count;
 992
 993     /*
 994      * Create the object array and walk the source package tree
 995      */
 996     DestObj->Package.Elements = ACPI_ALLOCATE_ZEROED (
 997         ((ACPI_SIZE) SourceObj->Package.Count + 1) *
 998         sizeof (void *));
 999     if (!DestObj->Package.Elements)
1000     {
1001         ACPI_ERROR ((AE_INFO, "Package allocation failure"));
1002         return_ACPI_STATUS (AE_NO_MEMORY);
1003     }
1004
1005     /*
1006      * Copy the package element-by-element by walking the package "tree".
1007      * This handles nested packages of arbitrary depth.
1008      */
1009     Status = AcpiUtWalkPackageTree (SourceObj, DestObj,
1010         AcpiUtCopyIelementToIelement, WalkState);
1011     if (ACPI_FAILURE (Status))
1012     {
1013         /* On failure, delete the destination package object */
1014
1015         AcpiUtRemoveReference (DestObj);
1016     }
1017
1018     return_ACPI_STATUS (Status);
1019 }
1020
1021
1022 /*******************************************************************************
1023  *
1024  * FUNCTION:    AcpiUtCopyIobjectToIobject
1025  *
1026  * PARAMETERS:  SourceDesc          - The internal object to be copied
1027  *              DestDesc            - Where the copied object is returned
1028  *              WalkState           - Current walk state
1029  *
1030  * RETURN:      Status
1031  *
1032  * DESCRIPTION: Copy an internal object to a new internal object
1033  *
1034  ******************************************************************************/
1035
1036 ACPI_STATUS
1037 AcpiUtCopyIobjectToIobject (
1038     ACPI_OPERAND_OBJECT     *SourceDesc,
1039     ACPI_OPERAND_OBJECT     **DestDesc,
1040     ACPI_WALK_STATE         *WalkState)
1041 {
1042     ACPI_STATUS             Status = AE_OK;
1043
1044
1045     ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject);
1046
1047
1048     /* Create the top level object */
1049
1050     *DestDesc = AcpiUtCreateInternalObject (SourceDesc->Common.Type);
1051     if (!*DestDesc)
1052     {
1053         return_ACPI_STATUS (AE_NO_MEMORY);
1054     }
1055
1056     /* Copy the object and possible subobjects */
1057
1058     if (SourceDesc->Common.Type == ACPI_TYPE_PACKAGE)
1059     {
1060         Status = AcpiUtCopyIpackageToIpackage (
1061             SourceDesc, *DestDesc, WalkState);
1062     }
1063     else
1064     {
1065         Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc);
1066     }
1067
1068     /* Delete the allocated object if copy failed */
1069
1070     if (ACPI_FAILURE (Status))
1071     {
1072         AcpiUtRemoveReference (*DestDesc);
1073     }
1074
1075     return_ACPI_STATUS (Status);
1076 }