arch/all-pc/acpica/source/components/utilities/utcopy.c

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