git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/utilities/utcopy.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utcopy - Internal to external object translation utilities
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2008, 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/acpi.h>
  45 #include <acpi/amlcode.h>
  46 #include <acpi/acnamesp.h>
  47
  48
  49 #define _COMPONENT          ACPI_UTILITIES
  50 ACPI_MODULE_NAME("utcopy")
  51
  52 /* Local prototypes */
  53 static acpi_status
  54 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
  55                                 union acpi_object *external_object,
  56                                 u8 * data_space, acpi_size * buffer_space_used);
  57
  58 static acpi_status
  59 acpi_ut_copy_ielement_to_ielement(u8 object_type,
  60                                   union acpi_operand_object *source_object,
  61                                   union acpi_generic_state *state,
  62                                   void *context);
  63
  64 static acpi_status
  65 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
  66                                   u8 * buffer, acpi_size * space_used);
  67
  68 static acpi_status
  69 acpi_ut_copy_esimple_to_isimple(union acpi_object *user_obj,
  70                                 union acpi_operand_object **return_obj);
  71
  72 static acpi_status
  73 acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
  74                                   union acpi_operand_object **internal_object);
  75
  76 static acpi_status
  77 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
  78                            union acpi_operand_object *dest_desc);
  79
  80 static acpi_status
  81 acpi_ut_copy_ielement_to_eelement(u8 object_type,
  82                                   union acpi_operand_object *source_object,
  83                                   union acpi_generic_state *state,
  84                                   void *context);
  85
  86 static acpi_status
  87 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
  88                                   union acpi_operand_object *dest_obj,
  89                                   struct acpi_walk_state *walk_state);
  90
  91 /*******************************************************************************
  92  *
  93  * FUNCTION:    acpi_ut_copy_isimple_to_esimple
  94  *
  95  * PARAMETERS:  internal_object     - Source object to be copied
  96  *              external_object     - Where to return the copied object
  97  *              data_space          - Where object data is returned (such as
  98  *                                    buffer and string data)
  99  *              buffer_space_used   - Length of data_space that was used
 100  *
 101  * RETURN:      Status
 102  *
 103  * DESCRIPTION: This function is called to copy a simple internal object to
 104  *              an external object.
 105  *
 106  *              The data_space buffer is assumed to have sufficient space for
 107  *              the object.
 108  *
 109  ******************************************************************************/
 110
 111 static acpi_status
 112 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
 113                                 union acpi_object *external_object,
 114                                 u8 * data_space, acpi_size * buffer_space_used)
 115 {
 116         acpi_status status = AE_OK;
 117
 118         ACPI_FUNCTION_TRACE(ut_copy_isimple_to_esimple);
 119
 120         *buffer_space_used = 0;
 121
 122         /*
 123          * Check for NULL object case (could be an uninitialized
 124          * package element)
 125          */
 126         if (!internal_object) {
 127                 return_ACPI_STATUS(AE_OK);
 128         }
 129
 130         /* Always clear the external object */
 131
 132         ACPI_MEMSET(external_object, 0, sizeof(union acpi_object));
 133
 134         /*
 135          * In general, the external object will be the same type as
 136          * the internal object
 137          */
 138         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
 139
 140         /* However, only a limited number of external types are supported */
 141
 142         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
 143         case ACPI_TYPE_STRING:
 144
 145                 external_object->string.pointer = (char *)data_space;
 146                 external_object->string.length = internal_object->string.length;
 147                 *buffer_space_used = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
 148                                                                   internal_object->
 149                                                                   string.
 150                                                                   length + 1);
 151
 152                 ACPI_MEMCPY((void *)data_space,
 153                             (void *)internal_object->string.pointer,
 154                             (acpi_size) internal_object->string.length + 1);
 155                 break;
 156
 157         case ACPI_TYPE_BUFFER:
 158
 159                 external_object->buffer.pointer = data_space;
 160                 external_object->buffer.length = internal_object->buffer.length;
 161                 *buffer_space_used =
 162                     ACPI_ROUND_UP_TO_NATIVE_WORD(internal_object->string.
 163                                                  length);
 164
 165                 ACPI_MEMCPY((void *)data_space,
 166                             (void *)internal_object->buffer.pointer,
 167                             internal_object->buffer.length);
 168                 break;
 169
 170         case ACPI_TYPE_INTEGER:
 171
 172                 external_object->integer.value = internal_object->integer.value;
 173                 break;
 174
 175         case ACPI_TYPE_LOCAL_REFERENCE:
 176
 177                 /* This is an object reference. */
 178
 179                 switch (internal_object->reference.opcode) {
 180                 case AML_INT_NAMEPATH_OP:
 181
 182                         /* For namepath, return the object handle ("reference") */
 183
 184                 default:
 185
 186                         /* We are referring to the namespace node */
 187
 188                         external_object->reference.handle =
 189                             internal_object->reference.node;
 190                         external_object->reference.actual_type =
 191                             acpi_ns_get_type(internal_object->reference.node);
 192                         break;
 193                 }
 194                 break;
 195
 196         case ACPI_TYPE_PROCESSOR:
 197
 198                 external_object->processor.proc_id =
 199                     internal_object->processor.proc_id;
 200                 external_object->processor.pblk_address =
 201                     internal_object->processor.address;
 202                 external_object->processor.pblk_length =
 203                     internal_object->processor.length;
 204                 break;
 205
 206         case ACPI_TYPE_POWER:
 207
 208                 external_object->power_resource.system_level =
 209                     internal_object->power_resource.system_level;
 210
 211                 external_object->power_resource.resource_order =
 212                     internal_object->power_resource.resource_order;
 213                 break;
 214
 215         default:
 216                 /*
 217                  * There is no corresponding external object type
 218                  */
 219                 ACPI_ERROR((AE_INFO,
 220                             "Unsupported object type, cannot convert to external object: %s",
 221                             acpi_ut_get_type_name(ACPI_GET_OBJECT_TYPE
 222                                                   (internal_object))));
 223
 224                 return_ACPI_STATUS(AE_SUPPORT);
 225         }
 226
 227         return_ACPI_STATUS(status);
 228 }
 229
 230 /*******************************************************************************
 231  *
 232  * FUNCTION:    acpi_ut_copy_ielement_to_eelement
 233  *
 234  * PARAMETERS:  acpi_pkg_callback
 235  *
 236  * RETURN:      Status
 237  *
 238  * DESCRIPTION: Copy one package element to another package element
 239  *
 240  ******************************************************************************/
 241
 242 static acpi_status
 243 acpi_ut_copy_ielement_to_eelement(u8 object_type,
 244                                   union acpi_operand_object *source_object,
 245                                   union acpi_generic_state *state,
 246                                   void *context)
 247 {
 248         acpi_status status = AE_OK;
 249         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
 250         acpi_size object_space;
 251         u32 this_index;
 252         union acpi_object *target_object;
 253
 254         ACPI_FUNCTION_ENTRY();
 255
 256         this_index = state->pkg.index;
 257         target_object = (union acpi_object *)
 258             &((union acpi_object *)(state->pkg.dest_object))->package.
 259             elements[this_index];
 260
 261         switch (object_type) {
 262         case ACPI_COPY_TYPE_SIMPLE:
 263
 264                 /*
 265                  * This is a simple or null object
 266                  */
 267                 status = acpi_ut_copy_isimple_to_esimple(source_object,
 268                                                          target_object,
 269                                                          info->free_space,
 270                                                          &object_space);
 271                 if (ACPI_FAILURE(status)) {
 272                         return (status);
 273                 }
 274                 break;
 275
 276         case ACPI_COPY_TYPE_PACKAGE:
 277
 278                 /*
 279                  * Build the package object
 280                  */
 281                 target_object->type = ACPI_TYPE_PACKAGE;
 282                 target_object->package.count = source_object->package.count;
 283                 target_object->package.elements =
 284                     ACPI_CAST_PTR(union acpi_object, info->free_space);
 285
 286                 /*
 287                  * Pass the new package object back to the package walk routine
 288                  */
 289                 state->pkg.this_target_obj = target_object;
 290
 291                 /*
 292                  * Save space for the array of objects (Package elements)
 293                  * update the buffer length counter
 294                  */
 295                 object_space = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
 296                                                             target_object->
 297                                                             package.count *
 298                                                             sizeof(union
 299                                                                    acpi_object));
 300                 break;
 301
 302         default:
 303                 return (AE_BAD_PARAMETER);
 304         }
 305
 306         info->free_space += object_space;
 307         info->length += object_space;
 308         return (status);
 309 }
 310
 311 /*******************************************************************************
 312  *
 313  * FUNCTION:    acpi_ut_copy_ipackage_to_epackage
 314  *
 315  * PARAMETERS:  internal_object     - Pointer to the object we are returning
 316  *              Buffer              - Where the object is returned
 317  *              space_used          - Where the object length is returned
 318  *
 319  * RETURN:      Status
 320  *
 321  * DESCRIPTION: This function is called to place a package object in a user
 322  *              buffer.  A package object by definition contains other objects.
 323  *
 324  *              The buffer is assumed to have sufficient space for the object.
 325  *              The caller must have verified the buffer length needed using the
 326  *              acpi_ut_get_object_size function before calling this function.
 327  *
 328  ******************************************************************************/
 329
 330 static acpi_status
 331 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
 332                                   u8 * buffer, acpi_size * space_used)
 333 {
 334         union acpi_object *external_object;
 335         acpi_status status;
 336         struct acpi_pkg_info info;
 337
 338         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_epackage);
 339
 340         /*
 341          * First package at head of the buffer
 342          */
 343         external_object = ACPI_CAST_PTR(union acpi_object, buffer);
 344
 345         /*
 346          * Free space begins right after the first package
 347          */
 348         info.length = ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 349         info.free_space =
 350             buffer + ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 351         info.object_space = 0;
 352         info.num_packages = 1;
 353
 354         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
 355         external_object->package.count = internal_object->package.count;
 356         external_object->package.elements = ACPI_CAST_PTR(union acpi_object,
 357                                                           info.free_space);
 358
 359         /*
 360          * Leave room for an array of ACPI_OBJECTS in the buffer
 361          * and move the free space past it
 362          */
 363         info.length += (acpi_size) external_object->package.count *
 364             ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 365         info.free_space += external_object->package.count *
 366             ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 367
 368         status = acpi_ut_walk_package_tree(internal_object, external_object,
 369                                            acpi_ut_copy_ielement_to_eelement,
 370                                            &info);
 371
 372         *space_used = info.length;
 373         return_ACPI_STATUS(status);
 374 }
 375
 376 /*******************************************************************************
 377  *
 378  * FUNCTION:    acpi_ut_copy_iobject_to_eobject
 379  *
 380  * PARAMETERS:  internal_object     - The internal object to be converted
 381  *              buffer_ptr          - Where the object is returned
 382  *
 383  * RETURN:      Status
 384  *
 385  * DESCRIPTION: This function is called to build an API object to be returned to
 386  *              the caller.
 387  *
 388  ******************************************************************************/
 389
 390 acpi_status
 391 acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *internal_object,
 392                                 struct acpi_buffer *ret_buffer)
 393 {
 394         acpi_status status;
 395
 396         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_eobject);
 397
 398         if (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE) {
 399                 /*
 400                  * Package object:  Copy all subobjects (including
 401                  * nested packages)
 402                  */
 403                 status = acpi_ut_copy_ipackage_to_epackage(internal_object,
 404                                                            ret_buffer->pointer,
 405                                                            &ret_buffer->length);
 406         } else {
 407                 /*
 408                  * Build a simple object (no nested objects)
 409                  */
 410                 status = acpi_ut_copy_isimple_to_esimple(internal_object,
 411                                                          ACPI_CAST_PTR(union
 412                                                                        acpi_object,
 413                                                                        ret_buffer->
 414                                                                        pointer),
 415                                                          ACPI_ADD_PTR(u8,
 416                                                                       ret_buffer->
 417                                                                       pointer,
 418                                                                       ACPI_ROUND_UP_TO_NATIVE_WORD
 419                                                                       (sizeof
 420                                                                        (union
 421                                                                         acpi_object))),
 422                                                          &ret_buffer->length);
 423                 /*
 424                  * build simple does not include the object size in the length
 425                  * so we add it in here
 426                  */
 427                 ret_buffer->length += sizeof(union acpi_object);
 428         }
 429
 430         return_ACPI_STATUS(status);
 431 }
 432
 433 /*******************************************************************************
 434  *
 435  * FUNCTION:    acpi_ut_copy_esimple_to_isimple
 436  *
 437  * PARAMETERS:  external_object     - The external object to be converted
 438  *              ret_internal_object - Where the internal object is returned
 439  *
 440  * RETURN:      Status
 441  *
 442  * DESCRIPTION: This function copies an external object to an internal one.
 443  *              NOTE: Pointers can be copied, we don't need to copy data.
 444  *              (The pointers have to be valid in our address space no matter
 445  *              what we do with them!)
 446  *
 447  ******************************************************************************/
 448
 449 static acpi_status
 450 acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
 451                                 union acpi_operand_object **ret_internal_object)
 452 {
 453         union acpi_operand_object *internal_object;
 454
 455         ACPI_FUNCTION_TRACE(ut_copy_esimple_to_isimple);
 456
 457         /*
 458          * Simple types supported are: String, Buffer, Integer
 459          */
 460         switch (external_object->type) {
 461         case ACPI_TYPE_STRING:
 462         case ACPI_TYPE_BUFFER:
 463         case ACPI_TYPE_INTEGER:
 464         case ACPI_TYPE_LOCAL_REFERENCE:
 465
 466                 internal_object = acpi_ut_create_internal_object((u8)
 467                                                                  external_object->
 468                                                                  type);
 469                 if (!internal_object) {
 470                         return_ACPI_STATUS(AE_NO_MEMORY);
 471                 }
 472                 break;
 473
 474         case ACPI_TYPE_ANY:     /* This is the case for a NULL object */
 475
 476                 *ret_internal_object = NULL;
 477                 return_ACPI_STATUS(AE_OK);
 478
 479         default:
 480                 /* All other types are not supported */
 481
 482                 ACPI_ERROR((AE_INFO,
 483                             "Unsupported object type, cannot convert to internal object: %s",
 484                             acpi_ut_get_type_name(external_object->type)));
 485
 486                 return_ACPI_STATUS(AE_SUPPORT);
 487         }
 488
 489         /* Must COPY string and buffer contents */
 490
 491         switch (external_object->type) {
 492         case ACPI_TYPE_STRING:
 493
 494                 internal_object->string.pointer =
 495                     ACPI_ALLOCATE_ZEROED((acpi_size) external_object->string.
 496                                          length + 1);
 497                 if (!internal_object->string.pointer) {
 498                         goto error_exit;
 499                 }
 500
 501                 ACPI_MEMCPY(internal_object->string.pointer,
 502                             external_object->string.pointer,
 503                             external_object->string.length);
 504
 505                 internal_object->string.length = external_object->string.length;
 506                 break;
 507
 508         case ACPI_TYPE_BUFFER:
 509
 510                 internal_object->buffer.pointer =
 511                     ACPI_ALLOCATE_ZEROED(external_object->buffer.length);
 512                 if (!internal_object->buffer.pointer) {
 513                         goto error_exit;
 514                 }
 515
 516                 ACPI_MEMCPY(internal_object->buffer.pointer,
 517                             external_object->buffer.pointer,
 518                             external_object->buffer.length);
 519
 520                 internal_object->buffer.length = external_object->buffer.length;
 521
 522                 /* Mark buffer data valid */
 523
 524                 internal_object->buffer.flags |= AOPOBJ_DATA_VALID;
 525                 break;
 526
 527         case ACPI_TYPE_INTEGER:
 528
 529                 internal_object->integer.value = external_object->integer.value;
 530                 break;
 531
 532         case ACPI_TYPE_LOCAL_REFERENCE:
 533
 534                 /* TBD: should validate incoming handle */
 535
 536                 internal_object->reference.opcode = AML_INT_NAMEPATH_OP;
 537                 internal_object->reference.node =
 538                     external_object->reference.handle;
 539                 break;
 540
 541         default:
 542                 /* Other types can't get here */
 543                 break;
 544         }
 545
 546         *ret_internal_object = internal_object;
 547         return_ACPI_STATUS(AE_OK);
 548
 549       error_exit:
 550         acpi_ut_remove_reference(internal_object);
 551         return_ACPI_STATUS(AE_NO_MEMORY);
 552 }
 553
 554 /*******************************************************************************
 555  *
 556  * FUNCTION:    acpi_ut_copy_epackage_to_ipackage
 557  *
 558  * PARAMETERS:  external_object     - The external object to be converted
 559  *              internal_object     - Where the internal object is returned
 560  *
 561  * RETURN:      Status
 562  *
 563  * DESCRIPTION: Copy an external package object to an internal package.
 564  *              Handles nested packages.
 565  *
 566  ******************************************************************************/
 567
 568 static acpi_status
 569 acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
 570                                   union acpi_operand_object **internal_object)
 571 {
 572         acpi_status status = AE_OK;
 573         union acpi_operand_object *package_object;
 574         union acpi_operand_object **package_elements;
 575         acpi_native_uint i;
 576
 577         ACPI_FUNCTION_TRACE(ut_copy_epackage_to_ipackage);
 578
 579         /* Create the package object */
 580
 581         package_object =
 582             acpi_ut_create_package_object(external_object->package.count);
 583         if (!package_object) {
 584                 return_ACPI_STATUS(AE_NO_MEMORY);
 585         }
 586
 587         package_elements = package_object->package.elements;
 588
 589         /*
 590          * Recursive implementation. Probably ok, since nested external packages
 591          * as parameters should be very rare.
 592          */
 593         for (i = 0; i < external_object->package.count; i++) {
 594                 status =
 595                     acpi_ut_copy_eobject_to_iobject(&external_object->package.
 596                                                     elements[i],
 597                                                     &package_elements[i]);
 598                 if (ACPI_FAILURE(status)) {
 599
 600                         /* Truncate package and delete it */
 601
 602                         package_object->package.count = (u32) i;
 603                         package_elements[i] = NULL;
 604                         acpi_ut_remove_reference(package_object);
 605                         return_ACPI_STATUS(status);
 606                 }
 607         }
 608
 609         /* Mark package data valid */
 610
 611         package_object->package.flags |= AOPOBJ_DATA_VALID;
 612
 613         *internal_object = package_object;
 614         return_ACPI_STATUS(status);
 615 }
 616
 617 /*******************************************************************************
 618  *
 619  * FUNCTION:    acpi_ut_copy_eobject_to_iobject
 620  *
 621  * PARAMETERS:  external_object     - The external object to be converted
 622  *              internal_object     - Where the internal object is returned
 623  *
 624  * RETURN:      Status              - the status of the call
 625  *
 626  * DESCRIPTION: Converts an external object to an internal object.
 627  *
 628  ******************************************************************************/
 629
 630 acpi_status
 631 acpi_ut_copy_eobject_to_iobject(union acpi_object *external_object,
 632                                 union acpi_operand_object **internal_object)
 633 {
 634         acpi_status status;
 635
 636         ACPI_FUNCTION_TRACE(ut_copy_eobject_to_iobject);
 637
 638         if (external_object->type == ACPI_TYPE_PACKAGE) {
 639                 status =
 640                     acpi_ut_copy_epackage_to_ipackage(external_object,
 641                                                       internal_object);
 642         } else {
 643                 /*
 644                  * Build a simple object (no nested objects)
 645                  */
 646                 status =
 647                     acpi_ut_copy_esimple_to_isimple(external_object,
 648                                                     internal_object);
 649         }
 650
 651         return_ACPI_STATUS(status);
 652 }
 653
 654 /*******************************************************************************
 655  *
 656  * FUNCTION:    acpi_ut_copy_simple_object
 657  *
 658  * PARAMETERS:  source_desc         - The internal object to be copied
 659  *              dest_desc           - New target object
 660  *
 661  * RETURN:      Status
 662  *
 663  * DESCRIPTION: Simple copy of one internal object to another.  Reference count
 664  *              of the destination object is preserved.
 665  *
 666  ******************************************************************************/
 667
 668 static acpi_status
 669 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
 670                            union acpi_operand_object *dest_desc)
 671 {
 672         u16 reference_count;
 673         union acpi_operand_object *next_object;
 674
 675         /* Save fields from destination that we don't want to overwrite */
 676
 677         reference_count = dest_desc->common.reference_count;
 678         next_object = dest_desc->common.next_object;
 679
 680         /* Copy the entire source object over the destination object */
 681
 682         ACPI_MEMCPY((char *)dest_desc, (char *)source_desc,
 683                     sizeof(union acpi_operand_object));
 684
 685         /* Restore the saved fields */
 686
 687         dest_desc->common.reference_count = reference_count;
 688         dest_desc->common.next_object = next_object;
 689
 690         /* New object is not static, regardless of source */
 691
 692         dest_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;
 693
 694         /* Handle the objects with extra data */
 695
 696         switch (ACPI_GET_OBJECT_TYPE(dest_desc)) {
 697         case ACPI_TYPE_BUFFER:
 698                 /*
 699                  * Allocate and copy the actual buffer if and only if:
 700                  * 1) There is a valid buffer pointer
 701                  * 2) The buffer has a length > 0
 702                  */
 703                 if ((source_desc->buffer.pointer) &&
 704                     (source_desc->buffer.length)) {
 705                         dest_desc->buffer.pointer =
 706                             ACPI_ALLOCATE(source_desc->buffer.length);
 707                         if (!dest_desc->buffer.pointer) {
 708                                 return (AE_NO_MEMORY);
 709                         }
 710
 711                         /* Copy the actual buffer data */
 712
 713                         ACPI_MEMCPY(dest_desc->buffer.pointer,
 714                                     source_desc->buffer.pointer,
 715                                     source_desc->buffer.length);
 716                 }
 717                 break;
 718
 719         case ACPI_TYPE_STRING:
 720                 /*
 721                  * Allocate and copy the actual string if and only if:
 722                  * 1) There is a valid string pointer
 723                  * (Pointer to a NULL string is allowed)
 724                  */
 725                 if (source_desc->string.pointer) {
 726                         dest_desc->string.pointer =
 727                             ACPI_ALLOCATE((acpi_size) source_desc->string.
 728                                           length + 1);
 729                         if (!dest_desc->string.pointer) {
 730                                 return (AE_NO_MEMORY);
 731                         }
 732
 733                         /* Copy the actual string data */
 734
 735                         ACPI_MEMCPY(dest_desc->string.pointer,
 736                                     source_desc->string.pointer,
 737                                     (acpi_size) source_desc->string.length + 1);
 738                 }
 739                 break;
 740
 741         case ACPI_TYPE_LOCAL_REFERENCE:
 742                 /*
 743                  * We copied the reference object, so we now must add a reference
 744                  * to the object pointed to by the reference
 745                  *
 746                  * DDBHandle reference (from Load/load_table is a special reference,
 747                  * it's Reference.Object is the table index, so does not need to
 748                  * increase the reference count
 749                  */
 750                 if (source_desc->reference.opcode == AML_LOAD_OP) {
 751                         break;
 752                 }
 753
 754                 acpi_ut_add_reference(source_desc->reference.object);
 755                 break;
 756
 757         case ACPI_TYPE_REGION:
 758                 /*
 759                  * We copied the Region Handler, so we now must add a reference
 760                  */
 761                 if (dest_desc->region.handler) {
 762                         acpi_ut_add_reference(dest_desc->region.handler);
 763                 }
 764                 break;
 765
 766         default:
 767                 /* Nothing to do for other simple objects */
 768                 break;
 769         }
 770
 771         return (AE_OK);
 772 }
 773
 774 /*******************************************************************************
 775  *
 776  * FUNCTION:    acpi_ut_copy_ielement_to_ielement
 777  *
 778  * PARAMETERS:  acpi_pkg_callback
 779  *
 780  * RETURN:      Status
 781  *
 782  * DESCRIPTION: Copy one package element to another package element
 783  *
 784  ******************************************************************************/
 785
 786 static acpi_status
 787 acpi_ut_copy_ielement_to_ielement(u8 object_type,
 788                                   union acpi_operand_object *source_object,
 789                                   union acpi_generic_state *state,
 790                                   void *context)
 791 {
 792         acpi_status status = AE_OK;
 793         u32 this_index;
 794         union acpi_operand_object **this_target_ptr;
 795         union acpi_operand_object *target_object;
 796
 797         ACPI_FUNCTION_ENTRY();
 798
 799         this_index = state->pkg.index;
 800         this_target_ptr = (union acpi_operand_object **)
 801             &state->pkg.dest_object->package.elements[this_index];
 802
 803         switch (object_type) {
 804         case ACPI_COPY_TYPE_SIMPLE:
 805
 806                 /* A null source object indicates a (legal) null package element */
 807
 808                 if (source_object) {
 809                         /*
 810                          * This is a simple object, just copy it
 811                          */
 812                         target_object =
 813                             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE
 814                                                            (source_object));
 815                         if (!target_object) {
 816                                 return (AE_NO_MEMORY);
 817                         }
 818
 819                         status =
 820                             acpi_ut_copy_simple_object(source_object,
 821                                                        target_object);
 822                         if (ACPI_FAILURE(status)) {
 823                                 goto error_exit;
 824                         }
 825
 826                         *this_target_ptr = target_object;
 827                 } else {
 828                         /* Pass through a null element */
 829
 830                         *this_target_ptr = NULL;
 831                 }
 832                 break;
 833
 834         case ACPI_COPY_TYPE_PACKAGE:
 835
 836                 /*
 837                  * This object is a package - go down another nesting level
 838                  * Create and build the package object
 839                  */
 840                 target_object =
 841                     acpi_ut_create_package_object(source_object->package.count);
 842                 if (!target_object) {
 843                         return (AE_NO_MEMORY);
 844                 }
 845
 846                 target_object->common.flags = source_object->common.flags;
 847
 848                 /* Pass the new package object back to the package walk routine */
 849
 850                 state->pkg.this_target_obj = target_object;
 851
 852                 /* Store the object pointer in the parent package object */
 853
 854                 *this_target_ptr = target_object;
 855                 break;
 856
 857         default:
 858                 return (AE_BAD_PARAMETER);
 859         }
 860
 861         return (status);
 862
 863       error_exit:
 864         acpi_ut_remove_reference(target_object);
 865         return (status);
 866 }
 867
 868 /*******************************************************************************
 869  *
 870  * FUNCTION:    acpi_ut_copy_ipackage_to_ipackage
 871  *
 872  * PARAMETERS:  *source_obj     - Pointer to the source package object
 873  *              *dest_obj       - Where the internal object is returned
 874  *
 875  * RETURN:      Status          - the status of the call
 876  *
 877  * DESCRIPTION: This function is called to copy an internal package object
 878  *              into another internal package object.
 879  *
 880  ******************************************************************************/
 881
 882 static acpi_status
 883 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
 884                                   union acpi_operand_object *dest_obj,
 885                                   struct acpi_walk_state *walk_state)
 886 {
 887         acpi_status status = AE_OK;
 888
 889         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_ipackage);
 890
 891         dest_obj->common.type = ACPI_GET_OBJECT_TYPE(source_obj);
 892         dest_obj->common.flags = source_obj->common.flags;
 893         dest_obj->package.count = source_obj->package.count;
 894
 895         /*
 896          * Create the object array and walk the source package tree
 897          */
 898         dest_obj->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
 899                                                            source_obj->package.
 900                                                            count +
 901                                                            1) * sizeof(void *));
 902         if (!dest_obj->package.elements) {
 903                 ACPI_ERROR((AE_INFO, "Package allocation failure"));
 904                 return_ACPI_STATUS(AE_NO_MEMORY);
 905         }
 906
 907         /*
 908          * Copy the package element-by-element by walking the package "tree".
 909          * This handles nested packages of arbitrary depth.
 910          */
 911         status = acpi_ut_walk_package_tree(source_obj, dest_obj,
 912                                            acpi_ut_copy_ielement_to_ielement,
 913                                            walk_state);
 914         if (ACPI_FAILURE(status)) {
 915
 916                 /* On failure, delete the destination package object */
 917
 918                 acpi_ut_remove_reference(dest_obj);
 919         }
 920
 921         return_ACPI_STATUS(status);
 922 }
 923
 924 /*******************************************************************************
 925  *
 926  * FUNCTION:    acpi_ut_copy_iobject_to_iobject
 927  *
 928  * PARAMETERS:  walk_state          - Current walk state
 929  *              source_desc         - The internal object to be copied
 930  *              dest_desc           - Where the copied object is returned
 931  *
 932  * RETURN:      Status
 933  *
 934  * DESCRIPTION: Copy an internal object to a new internal object
 935  *
 936  ******************************************************************************/
 937
 938 acpi_status
 939 acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
 940                                 union acpi_operand_object **dest_desc,
 941                                 struct acpi_walk_state *walk_state)
 942 {
 943         acpi_status status = AE_OK;
 944
 945         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_iobject);
 946
 947         /* Create the top level object */
 948
 949         *dest_desc =
 950             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE(source_desc));
 951         if (!*dest_desc) {
 952                 return_ACPI_STATUS(AE_NO_MEMORY);
 953         }
 954
 955         /* Copy the object and possible subobjects */
 956
 957         if (ACPI_GET_OBJECT_TYPE(source_desc) == ACPI_TYPE_PACKAGE) {
 958                 status =
 959                     acpi_ut_copy_ipackage_to_ipackage(source_desc, *dest_desc,
 960                                                       walk_state);
 961         } else {
 962                 status = acpi_ut_copy_simple_object(source_desc, *dest_desc);
 963         }
 964
 965         return_ACPI_STATUS(status);
 966 }