Warning, cross-references for /kernel/drivers/acpica/utcopy.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116 #define __UTCOPY_C__
0117
0118 #include "acpi.h"
0119 #include "accommon.h"
0120 #include "acnamesp.h"
0121
0122
0123 #define _COMPONENT ACPI_UTILITIES
0124 ACPI_MODULE_NAME ("utcopy")
0125
0126
0127
0128 static ACPI_STATUS
0129 AcpiUtCopyIsimpleToEsimple (
0130 ACPI_OPERAND_OBJECT *InternalObject,
0131 ACPI_OBJECT *ExternalObject,
0132 UINT8 *DataSpace,
0133 ACPI_SIZE *BufferSpaceUsed);
0134
0135 static ACPI_STATUS
0136 AcpiUtCopyIelementToIelement (
0137 UINT8 ObjectType,
0138 ACPI_OPERAND_OBJECT *SourceObject,
0139 ACPI_GENERIC_STATE *State,
0140 void *Context);
0141
0142 static ACPI_STATUS
0143 AcpiUtCopyIpackageToEpackage (
0144 ACPI_OPERAND_OBJECT *InternalObject,
0145 UINT8 *Buffer,
0146 ACPI_SIZE *SpaceUsed);
0147
0148 static ACPI_STATUS
0149 AcpiUtCopyEsimpleToIsimple(
0150 ACPI_OBJECT *UserObj,
0151 ACPI_OPERAND_OBJECT **ReturnObj);
0152
0153 static ACPI_STATUS
0154 AcpiUtCopyEpackageToIpackage (
0155 ACPI_OBJECT *ExternalObject,
0156 ACPI_OPERAND_OBJECT **InternalObject);
0157
0158 static ACPI_STATUS
0159 AcpiUtCopySimpleObject (
0160 ACPI_OPERAND_OBJECT *SourceDesc,
0161 ACPI_OPERAND_OBJECT *DestDesc);
0162
0163 static ACPI_STATUS
0164 AcpiUtCopyIelementToEelement (
0165 UINT8 ObjectType,
0166 ACPI_OPERAND_OBJECT *SourceObject,
0167 ACPI_GENERIC_STATE *State,
0168 void *Context);
0169
0170 static ACPI_STATUS
0171 AcpiUtCopyIpackageToIpackage (
0172 ACPI_OPERAND_OBJECT *SourceObj,
0173 ACPI_OPERAND_OBJECT *DestObj,
0174 ACPI_WALK_STATE *WalkState);
0175
0176
0177
0178
0179
0180
0181
0182
0183
0184
0185
0186
0187
0188
0189
0190
0191
0192
0193
0194
0195
0196
0197 static ACPI_STATUS
0198 AcpiUtCopyIsimpleToEsimple (
0199 ACPI_OPERAND_OBJECT *InternalObject,
0200 ACPI_OBJECT *ExternalObject,
0201 UINT8 *DataSpace,
0202 ACPI_SIZE *BufferSpaceUsed)
0203 {
0204 ACPI_STATUS Status = AE_OK;
0205
0206
0207 ACPI_FUNCTION_TRACE (UtCopyIsimpleToEsimple);
0208
0209
0210 *BufferSpaceUsed = 0;
0211
0212
0213
0214
0215
0216 if (!InternalObject)
0217 {
0218 return_ACPI_STATUS (AE_OK);
0219 }
0220
0221
0222
0223 ACPI_MEMSET (ExternalObject, 0, sizeof (ACPI_OBJECT));
0224
0225
0226
0227
0228
0229 ExternalObject->Type = InternalObject->Common.Type;
0230
0231
0232
0233 switch (InternalObject->Common.Type)
0234 {
0235 case ACPI_TYPE_STRING:
0236
0237 ExternalObject->String.Pointer = (char *) DataSpace;
0238 ExternalObject->String.Length = InternalObject->String.Length;
0239 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
0240 (ACPI_SIZE) InternalObject->String.Length + 1);
0241
0242 ACPI_MEMCPY ((void *) DataSpace,
0243 (void *) InternalObject->String.Pointer,
0244 (ACPI_SIZE) InternalObject->String.Length + 1);
0245 break;
0246
0247
0248 case ACPI_TYPE_BUFFER:
0249
0250 ExternalObject->Buffer.Pointer = DataSpace;
0251 ExternalObject->Buffer.Length = InternalObject->Buffer.Length;
0252 *BufferSpaceUsed = ACPI_ROUND_UP_TO_NATIVE_WORD (
0253 InternalObject->String.Length);
0254
0255 ACPI_MEMCPY ((void *) DataSpace,
0256 (void *) InternalObject->Buffer.Pointer,
0257 InternalObject->Buffer.Length);
0258 break;
0259
0260
0261 case ACPI_TYPE_INTEGER:
0262
0263 ExternalObject->Integer.Value = InternalObject->Integer.Value;
0264 break;
0265
0266
0267 case ACPI_TYPE_LOCAL_REFERENCE:
0268
0269
0270
0271 switch (InternalObject->Reference.Class)
0272 {
0273 case ACPI_REFCLASS_NAME:
0274
0275
0276
0277
0278
0279 ExternalObject->Reference.Handle =
0280 InternalObject->Reference.Node;
0281 ExternalObject->Reference.ActualType =
0282 AcpiNsGetType (InternalObject->Reference.Node);
0283 break;
0284
0285 default:
0286
0287
0288
0289 return_ACPI_STATUS (AE_TYPE);
0290 }
0291 break;
0292
0293
0294 case ACPI_TYPE_PROCESSOR:
0295
0296 ExternalObject->Processor.ProcId =
0297 InternalObject->Processor.ProcId;
0298 ExternalObject->Processor.PblkAddress =
0299 InternalObject->Processor.Address;
0300 ExternalObject->Processor.PblkLength =
0301 InternalObject->Processor.Length;
0302 break;
0303
0304
0305 case ACPI_TYPE_POWER:
0306
0307 ExternalObject->PowerResource.SystemLevel =
0308 InternalObject->PowerResource.SystemLevel;
0309
0310 ExternalObject->PowerResource.ResourceOrder =
0311 InternalObject->PowerResource.ResourceOrder;
0312 break;
0313
0314
0315 default:
0316
0317
0318
0319 ACPI_ERROR ((AE_INFO,
0320 "Unsupported object type, cannot convert to external object: %s",
0321 AcpiUtGetTypeName (InternalObject->Common.Type)));
0322
0323 return_ACPI_STATUS (AE_SUPPORT);
0324 }
0325
0326 return_ACPI_STATUS (Status);
0327 }
0328
0329
0330
0331
0332
0333
0334
0335
0336
0337
0338
0339
0340
0341
0342 static ACPI_STATUS
0343 AcpiUtCopyIelementToEelement (
0344 UINT8 ObjectType,
0345 ACPI_OPERAND_OBJECT *SourceObject,
0346 ACPI_GENERIC_STATE *State,
0347 void *Context)
0348 {
0349 ACPI_STATUS Status = AE_OK;
0350 ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context;
0351 ACPI_SIZE ObjectSpace;
0352 UINT32 ThisIndex;
0353 ACPI_OBJECT *TargetObject;
0354
0355
0356 ACPI_FUNCTION_ENTRY ();
0357
0358
0359 ThisIndex = State->Pkg.Index;
0360 TargetObject = (ACPI_OBJECT *)
0361 &((ACPI_OBJECT *)(State->Pkg.DestObject))->Package.Elements[ThisIndex];
0362
0363 switch (ObjectType)
0364 {
0365 case ACPI_COPY_TYPE_SIMPLE:
0366
0367
0368
0369
0370 Status = AcpiUtCopyIsimpleToEsimple (SourceObject,
0371 TargetObject, Info->FreeSpace, &ObjectSpace);
0372 if (ACPI_FAILURE (Status))
0373 {
0374 return (Status);
0375 }
0376 break;
0377
0378
0379 case ACPI_COPY_TYPE_PACKAGE:
0380
0381
0382
0383
0384 TargetObject->Type = ACPI_TYPE_PACKAGE;
0385 TargetObject->Package.Count = SourceObject->Package.Count;
0386 TargetObject->Package.Elements =
0387 ACPI_CAST_PTR (ACPI_OBJECT, Info->FreeSpace);
0388
0389
0390
0391
0392 State->Pkg.ThisTargetObj = TargetObject;
0393
0394
0395
0396
0397
0398 ObjectSpace = ACPI_ROUND_UP_TO_NATIVE_WORD (
0399 (ACPI_SIZE) TargetObject->Package.Count *
0400 sizeof (ACPI_OBJECT));
0401 break;
0402
0403
0404 default:
0405 return (AE_BAD_PARAMETER);
0406 }
0407
0408 Info->FreeSpace += ObjectSpace;
0409 Info->Length += ObjectSpace;
0410 return (Status);
0411 }
0412
0413
0414
0415
0416
0417
0418
0419
0420
0421
0422
0423
0424
0425
0426
0427
0428
0429
0430
0431
0432
0433 static ACPI_STATUS
0434 AcpiUtCopyIpackageToEpackage (
0435 ACPI_OPERAND_OBJECT *InternalObject,
0436 UINT8 *Buffer,
0437 ACPI_SIZE *SpaceUsed)
0438 {
0439 ACPI_OBJECT *ExternalObject;
0440 ACPI_STATUS Status;
0441 ACPI_PKG_INFO Info;
0442
0443
0444 ACPI_FUNCTION_TRACE (UtCopyIpackageToEpackage);
0445
0446
0447
0448
0449
0450 ExternalObject = ACPI_CAST_PTR (ACPI_OBJECT, Buffer);
0451
0452
0453
0454
0455 Info.Length = ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
0456 Info.FreeSpace = Buffer + ACPI_ROUND_UP_TO_NATIVE_WORD (
0457 sizeof (ACPI_OBJECT));
0458 Info.ObjectSpace = 0;
0459 Info.NumPackages = 1;
0460
0461 ExternalObject->Type = InternalObject->Common.Type;
0462 ExternalObject->Package.Count = InternalObject->Package.Count;
0463 ExternalObject->Package.Elements = ACPI_CAST_PTR (ACPI_OBJECT,
0464 Info.FreeSpace);
0465
0466
0467
0468
0469
0470 Info.Length += (ACPI_SIZE) ExternalObject->Package.Count *
0471 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
0472 Info.FreeSpace += ExternalObject->Package.Count *
0473 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT));
0474
0475 Status = AcpiUtWalkPackageTree (InternalObject, ExternalObject,
0476 AcpiUtCopyIelementToEelement, &Info);
0477
0478 *SpaceUsed = Info.Length;
0479 return_ACPI_STATUS (Status);
0480 }
0481
0482
0483
0484
0485
0486
0487
0488
0489
0490
0491
0492
0493
0494
0495
0496
0497 ACPI_STATUS
0498 AcpiUtCopyIobjectToEobject (
0499 ACPI_OPERAND_OBJECT *InternalObject,
0500 ACPI_BUFFER *RetBuffer)
0501 {
0502 ACPI_STATUS Status;
0503
0504
0505 ACPI_FUNCTION_TRACE (UtCopyIobjectToEobject);
0506
0507
0508 if (InternalObject->Common.Type == ACPI_TYPE_PACKAGE)
0509 {
0510
0511
0512
0513
0514 Status = AcpiUtCopyIpackageToEpackage (InternalObject,
0515 RetBuffer->Pointer, &RetBuffer->Length);
0516 }
0517 else
0518 {
0519
0520
0521
0522 Status = AcpiUtCopyIsimpleToEsimple (InternalObject,
0523 ACPI_CAST_PTR (ACPI_OBJECT, RetBuffer->Pointer),
0524 ACPI_ADD_PTR (UINT8, RetBuffer->Pointer,
0525 ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
0526 &RetBuffer->Length);
0527
0528
0529
0530
0531 RetBuffer->Length += sizeof (ACPI_OBJECT);
0532 }
0533
0534 return_ACPI_STATUS (Status);
0535 }
0536
0537
0538
0539
0540
0541
0542
0543
0544
0545
0546
0547
0548
0549
0550
0551
0552
0553
0554 static ACPI_STATUS
0555 AcpiUtCopyEsimpleToIsimple (
0556 ACPI_OBJECT *ExternalObject,
0557 ACPI_OPERAND_OBJECT **RetInternalObject)
0558 {
0559 ACPI_OPERAND_OBJECT *InternalObject;
0560
0561
0562 ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple);
0563
0564
0565
0566
0567
0568 switch (ExternalObject->Type)
0569 {
0570 case ACPI_TYPE_STRING:
0571 case ACPI_TYPE_BUFFER:
0572 case ACPI_TYPE_INTEGER:
0573 case ACPI_TYPE_LOCAL_REFERENCE:
0574
0575 InternalObject = AcpiUtCreateInternalObject (
0576 (UINT8) ExternalObject->Type);
0577 if (!InternalObject)
0578 {
0579 return_ACPI_STATUS (AE_NO_MEMORY);
0580 }
0581 break;
0582
0583 case ACPI_TYPE_ANY:
0584
0585 *RetInternalObject = NULL;
0586 return_ACPI_STATUS (AE_OK);
0587
0588 default:
0589
0590
0591 ACPI_ERROR ((AE_INFO,
0592 "Unsupported object type, cannot convert to internal object: %s",
0593 AcpiUtGetTypeName (ExternalObject->Type)));
0594
0595 return_ACPI_STATUS (AE_SUPPORT);
0596 }
0597
0598
0599
0600
0601 switch (ExternalObject->Type)
0602 {
0603 case ACPI_TYPE_STRING:
0604
0605 InternalObject->String.Pointer =
0606 ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)
0607 ExternalObject->String.Length + 1);
0608
0609 if (!InternalObject->String.Pointer)
0610 {
0611 goto ErrorExit;
0612 }
0613
0614 ACPI_MEMCPY (InternalObject->String.Pointer,
0615 ExternalObject->String.Pointer,
0616 ExternalObject->String.Length);
0617
0618 InternalObject->String.Length = ExternalObject->String.Length;
0619 break;
0620
0621
0622 case ACPI_TYPE_BUFFER:
0623
0624 InternalObject->Buffer.Pointer =
0625 ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length);
0626 if (!InternalObject->Buffer.Pointer)
0627 {
0628 goto ErrorExit;
0629 }
0630
0631 ACPI_MEMCPY (InternalObject->Buffer.Pointer,
0632 ExternalObject->Buffer.Pointer,
0633 ExternalObject->Buffer.Length);
0634
0635 InternalObject->Buffer.Length = ExternalObject->Buffer.Length;
0636
0637
0638
0639 InternalObject->Buffer.Flags |= AOPOBJ_DATA_VALID;
0640 break;
0641
0642
0643 case ACPI_TYPE_INTEGER:
0644
0645 InternalObject->Integer.Value = ExternalObject->Integer.Value;
0646 break;
0647
0648 case ACPI_TYPE_LOCAL_REFERENCE:
0649
0650
0651
0652 InternalObject->Reference.Class = ACPI_REFCLASS_NAME;
0653 InternalObject->Reference.Node = ExternalObject->Reference.Handle;
0654 break;
0655
0656 default:
0657
0658 break;
0659 }
0660
0661 *RetInternalObject = InternalObject;
0662 return_ACPI_STATUS (AE_OK);
0663
0664
0665 ErrorExit:
0666 AcpiUtRemoveReference (InternalObject);
0667 return_ACPI_STATUS (AE_NO_MEMORY);
0668 }
0669
0670
0671
0672
0673
0674
0675
0676
0677
0678
0679
0680
0681
0682
0683
0684
0685 static ACPI_STATUS
0686 AcpiUtCopyEpackageToIpackage (
0687 ACPI_OBJECT *ExternalObject,
0688 ACPI_OPERAND_OBJECT **InternalObject)
0689 {
0690 ACPI_STATUS Status = AE_OK;
0691 ACPI_OPERAND_OBJECT *PackageObject;
0692 ACPI_OPERAND_OBJECT **PackageElements;
0693 UINT32 i;
0694
0695
0696 ACPI_FUNCTION_TRACE (UtCopyEpackageToIpackage);
0697
0698
0699
0700
0701 PackageObject = AcpiUtCreatePackageObject (ExternalObject->Package.Count);
0702 if (!PackageObject)
0703 {
0704 return_ACPI_STATUS (AE_NO_MEMORY);
0705 }
0706
0707 PackageElements = PackageObject->Package.Elements;
0708
0709
0710
0711
0712
0713 for (i = 0; i < ExternalObject->Package.Count; i++)
0714 {
0715 Status = AcpiUtCopyEobjectToIobject (
0716 &ExternalObject->Package.Elements[i],
0717 &PackageElements[i]);
0718 if (ACPI_FAILURE (Status))
0719 {
0720
0721
0722 PackageObject->Package.Count = i;
0723 PackageElements[i] = NULL;
0724 AcpiUtRemoveReference (PackageObject);
0725 return_ACPI_STATUS (Status);
0726 }
0727 }
0728
0729
0730
0731 PackageObject->Package.Flags |= AOPOBJ_DATA_VALID;
0732
0733 *InternalObject = PackageObject;
0734 return_ACPI_STATUS (Status);
0735 }
0736
0737
0738
0739
0740
0741
0742
0743
0744
0745
0746
0747
0748
0749
0750
0751 ACPI_STATUS
0752 AcpiUtCopyEobjectToIobject (
0753 ACPI_OBJECT *ExternalObject,
0754 ACPI_OPERAND_OBJECT **InternalObject)
0755 {
0756 ACPI_STATUS Status;
0757
0758
0759 ACPI_FUNCTION_TRACE (UtCopyEobjectToIobject);
0760
0761
0762 if (ExternalObject->Type == ACPI_TYPE_PACKAGE)
0763 {
0764 Status = AcpiUtCopyEpackageToIpackage (ExternalObject, InternalObject);
0765 }
0766 else
0767 {
0768
0769
0770
0771 Status = AcpiUtCopyEsimpleToIsimple (ExternalObject, InternalObject);
0772 }
0773
0774 return_ACPI_STATUS (Status);
0775 }
0776
0777
0778
0779
0780
0781
0782
0783
0784
0785
0786
0787
0788
0789
0790
0791
0792 static ACPI_STATUS
0793 AcpiUtCopySimpleObject (
0794 ACPI_OPERAND_OBJECT *SourceDesc,
0795 ACPI_OPERAND_OBJECT *DestDesc)
0796 {
0797 UINT16 ReferenceCount;
0798 ACPI_OPERAND_OBJECT *NextObject;
0799 ACPI_STATUS Status;
0800
0801
0802
0803
0804 ReferenceCount = DestDesc->Common.ReferenceCount;
0805 NextObject = DestDesc->Common.NextObject;
0806
0807
0808
0809 ACPI_MEMCPY ((char *) DestDesc, (char *) SourceDesc,
0810 sizeof (ACPI_OPERAND_OBJECT));
0811
0812
0813
0814 DestDesc->Common.ReferenceCount = ReferenceCount;
0815 DestDesc->Common.NextObject = NextObject;
0816
0817
0818
0819 DestDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
0820
0821
0822
0823 switch (DestDesc->Common.Type)
0824 {
0825 case ACPI_TYPE_BUFFER:
0826
0827
0828
0829
0830
0831 if ((SourceDesc->Buffer.Pointer) &&
0832 (SourceDesc->Buffer.Length))
0833 {
0834 DestDesc->Buffer.Pointer =
0835 ACPI_ALLOCATE (SourceDesc->Buffer.Length);
0836 if (!DestDesc->Buffer.Pointer)
0837 {
0838 return (AE_NO_MEMORY);
0839 }
0840
0841
0842
0843 ACPI_MEMCPY (DestDesc->Buffer.Pointer,
0844 SourceDesc->Buffer.Pointer,
0845 SourceDesc->Buffer.Length);
0846 }
0847 break;
0848
0849 case ACPI_TYPE_STRING:
0850
0851
0852
0853
0854
0855 if (SourceDesc->String.Pointer)
0856 {
0857 DestDesc->String.Pointer =
0858 ACPI_ALLOCATE ((ACPI_SIZE) SourceDesc->String.Length + 1);
0859 if (!DestDesc->String.Pointer)
0860 {
0861 return (AE_NO_MEMORY);
0862 }
0863
0864
0865
0866 ACPI_MEMCPY (DestDesc->String.Pointer, SourceDesc->String.Pointer,
0867 (ACPI_SIZE) SourceDesc->String.Length + 1);
0868 }
0869 break;
0870
0871 case ACPI_TYPE_LOCAL_REFERENCE:
0872
0873
0874
0875
0876
0877
0878
0879
0880 if (SourceDesc->Reference.Class == ACPI_REFCLASS_TABLE)
0881 {
0882 break;
0883 }
0884
0885 AcpiUtAddReference (SourceDesc->Reference.Object);
0886 break;
0887
0888 case ACPI_TYPE_REGION:
0889
0890
0891
0892 if (DestDesc->Region.Handler)
0893 {
0894 AcpiUtAddReference (DestDesc->Region.Handler);
0895 }
0896 break;
0897
0898
0899
0900
0901
0902 case ACPI_TYPE_MUTEX:
0903
0904 Status = AcpiOsCreateMutex (&DestDesc->Mutex.OsMutex);
0905 if (ACPI_FAILURE (Status))
0906 {
0907 return (Status);
0908 }
0909 break;
0910
0911 case ACPI_TYPE_EVENT:
0912
0913 Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
0914 &DestDesc->Event.OsSemaphore);
0915 if (ACPI_FAILURE (Status))
0916 {
0917 return (Status);
0918 }
0919 break;
0920
0921 default:
0922
0923 break;
0924 }
0925
0926 return (AE_OK);
0927 }
0928
0929
0930
0931
0932
0933
0934
0935
0936
0937
0938
0939
0940
0941
0942 static ACPI_STATUS
0943 AcpiUtCopyIelementToIelement (
0944 UINT8 ObjectType,
0945 ACPI_OPERAND_OBJECT *SourceObject,
0946 ACPI_GENERIC_STATE *State,
0947 void *Context)
0948 {
0949 ACPI_STATUS Status = AE_OK;
0950 UINT32 ThisIndex;
0951 ACPI_OPERAND_OBJECT **ThisTargetPtr;
0952 ACPI_OPERAND_OBJECT *TargetObject;
0953
0954
0955 ACPI_FUNCTION_ENTRY ();
0956
0957
0958 ThisIndex = State->Pkg.Index;
0959 ThisTargetPtr = (ACPI_OPERAND_OBJECT **)
0960 &State->Pkg.DestObject->Package.Elements[ThisIndex];
0961
0962 switch (ObjectType)
0963 {
0964 case ACPI_COPY_TYPE_SIMPLE:
0965
0966
0967
0968 if (SourceObject)
0969 {
0970
0971
0972
0973 TargetObject = AcpiUtCreateInternalObject (
0974 SourceObject->Common.Type);
0975 if (!TargetObject)
0976 {
0977 return (AE_NO_MEMORY);
0978 }
0979
0980 Status = AcpiUtCopySimpleObject (SourceObject, TargetObject);
0981 if (ACPI_FAILURE (Status))
0982 {
0983 goto ErrorExit;
0984 }
0985
0986 *ThisTargetPtr = TargetObject;
0987 }
0988 else
0989 {
0990
0991
0992 *ThisTargetPtr = NULL;
0993 }
0994 break;
0995
0996
0997 case ACPI_COPY_TYPE_PACKAGE:
0998
0999
1000
1001
1002
1003 TargetObject = AcpiUtCreatePackageObject (SourceObject->Package.Count);
1004 if (!TargetObject)
1005 {
1006 return (AE_NO_MEMORY);
1007 }
1008
1009 TargetObject->Common.Flags = SourceObject->Common.Flags;
1010
1011
1012
1013 State->Pkg.ThisTargetObj = TargetObject;
1014
1015
1016
1017 *ThisTargetPtr = TargetObject;
1018 break;
1019
1020
1021 default:
1022 return (AE_BAD_PARAMETER);
1023 }
1024
1025 return (Status);
1026
1027 ErrorExit:
1028 AcpiUtRemoveReference (TargetObject);
1029 return (Status);
1030 }
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047 static ACPI_STATUS
1048 AcpiUtCopyIpackageToIpackage (
1049 ACPI_OPERAND_OBJECT *SourceObj,
1050 ACPI_OPERAND_OBJECT *DestObj,
1051 ACPI_WALK_STATE *WalkState)
1052 {
1053 ACPI_STATUS Status = AE_OK;
1054
1055
1056 ACPI_FUNCTION_TRACE (UtCopyIpackageToIpackage);
1057
1058
1059 DestObj->Common.Type = SourceObj->Common.Type;
1060 DestObj->Common.Flags = SourceObj->Common.Flags;
1061 DestObj->Package.Count = SourceObj->Package.Count;
1062
1063
1064
1065
1066 DestObj->Package.Elements = ACPI_ALLOCATE_ZEROED (
1067 ((ACPI_SIZE) SourceObj->Package.Count + 1) *
1068 sizeof (void *));
1069 if (!DestObj->Package.Elements)
1070 {
1071 ACPI_ERROR ((AE_INFO, "Package allocation failure"));
1072 return_ACPI_STATUS (AE_NO_MEMORY);
1073 }
1074
1075
1076
1077
1078
1079 Status = AcpiUtWalkPackageTree (SourceObj, DestObj,
1080 AcpiUtCopyIelementToIelement, WalkState);
1081 if (ACPI_FAILURE (Status))
1082 {
1083
1084
1085 AcpiUtRemoveReference (DestObj);
1086 }
1087
1088 return_ACPI_STATUS (Status);
1089 }
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106 ACPI_STATUS
1107 AcpiUtCopyIobjectToIobject (
1108 ACPI_OPERAND_OBJECT *SourceDesc,
1109 ACPI_OPERAND_OBJECT **DestDesc,
1110 ACPI_WALK_STATE *WalkState)
1111 {
1112 ACPI_STATUS Status = AE_OK;
1113
1114
1115 ACPI_FUNCTION_TRACE (UtCopyIobjectToIobject);
1116
1117
1118
1119
1120 *DestDesc = AcpiUtCreateInternalObject (SourceDesc->Common.Type);
1121 if (!*DestDesc)
1122 {
1123 return_ACPI_STATUS (AE_NO_MEMORY);
1124 }
1125
1126
1127
1128 if (SourceDesc->Common.Type == ACPI_TYPE_PACKAGE)
1129 {
1130 Status = AcpiUtCopyIpackageToIpackage (SourceDesc, *DestDesc,
1131 WalkState);
1132 }
1133 else
1134 {
1135 Status = AcpiUtCopySimpleObject (SourceDesc, *DestDesc);
1136 }
1137
1138 return_ACPI_STATUS (Status);
1139 }
1140
1141