Warning, cross-references for /kernel/drivers/acpica/exoparg1.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
0117 #define __EXOPARG1_C__
0118
0119 #include "acpi.h"
0120 #include "accommon.h"
0121 #include "acparser.h"
0122 #include "acdispat.h"
0123 #include "acinterp.h"
0124 #include "amlcode.h"
0125 #include "acnamesp.h"
0126
0127
0128 #define _COMPONENT ACPI_EXECUTER
0129 ACPI_MODULE_NAME ("exoparg1")
0130
0131
0132
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152
0153
0154
0155
0156
0157
0158
0159
0160
0161
0162
0163
0164
0165
0166 ACPI_STATUS
0167 AcpiExOpcode_0A_0T_1R (
0168 ACPI_WALK_STATE *WalkState)
0169 {
0170 ACPI_STATUS Status = AE_OK;
0171 ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
0172
0173
0174 ACPI_FUNCTION_TRACE_STR (ExOpcode_0A_0T_1R,
0175 AcpiPsGetOpcodeName (WalkState->Opcode));
0176
0177
0178
0179
0180 switch (WalkState->Opcode)
0181 {
0182 case AML_TIMER_OP:
0183
0184
0185
0186 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0187 if (!ReturnDesc)
0188 {
0189 Status = AE_NO_MEMORY;
0190 goto Cleanup;
0191 }
0192 ReturnDesc->Integer.Value = AcpiOsGetTimer ();
0193 break;
0194
0195 default:
0196
0197 ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
0198 WalkState->Opcode));
0199 Status = AE_AML_BAD_OPCODE;
0200 break;
0201 }
0202
0203 Cleanup:
0204
0205
0206
0207 if ((ACPI_FAILURE (Status)) || WalkState->ResultObj)
0208 {
0209 AcpiUtRemoveReference (ReturnDesc);
0210 WalkState->ResultObj = NULL;
0211 }
0212 else
0213 {
0214
0215
0216 WalkState->ResultObj = ReturnDesc;
0217 }
0218
0219 return_ACPI_STATUS (Status);
0220 }
0221
0222
0223
0224
0225
0226
0227
0228
0229
0230
0231
0232
0233
0234
0235
0236 ACPI_STATUS
0237 AcpiExOpcode_1A_0T_0R (
0238 ACPI_WALK_STATE *WalkState)
0239 {
0240 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
0241 ACPI_STATUS Status = AE_OK;
0242
0243
0244 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_0R,
0245 AcpiPsGetOpcodeName (WalkState->Opcode));
0246
0247
0248
0249
0250 switch (WalkState->Opcode)
0251 {
0252 case AML_RELEASE_OP:
0253
0254 Status = AcpiExReleaseMutex (Operand[0], WalkState);
0255 break;
0256
0257
0258 case AML_RESET_OP:
0259
0260 Status = AcpiExSystemResetEvent (Operand[0]);
0261 break;
0262
0263
0264 case AML_SIGNAL_OP:
0265
0266 Status = AcpiExSystemSignalEvent (Operand[0]);
0267 break;
0268
0269
0270 case AML_SLEEP_OP:
0271
0272 Status = AcpiExSystemDoSuspend (Operand[0]->Integer.Value);
0273 break;
0274
0275
0276 case AML_STALL_OP:
0277
0278 Status = AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value);
0279 break;
0280
0281
0282 case AML_UNLOAD_OP:
0283
0284 Status = AcpiExUnloadTable (Operand[0]);
0285 break;
0286
0287
0288 default:
0289
0290 ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
0291 WalkState->Opcode));
0292 Status = AE_AML_BAD_OPCODE;
0293 break;
0294 }
0295
0296 return_ACPI_STATUS (Status);
0297 }
0298
0299
0300
0301
0302
0303
0304
0305
0306
0307
0308
0309
0310
0311
0312
0313 ACPI_STATUS
0314 AcpiExOpcode_1A_1T_0R (
0315 ACPI_WALK_STATE *WalkState)
0316 {
0317 ACPI_STATUS Status = AE_OK;
0318 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
0319
0320
0321 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_0R,
0322 AcpiPsGetOpcodeName (WalkState->Opcode));
0323
0324
0325
0326
0327 switch (WalkState->Opcode)
0328 {
0329 case AML_LOAD_OP:
0330
0331 Status = AcpiExLoadOp (Operand[0], Operand[1], WalkState);
0332 break;
0333
0334 default:
0335
0336 ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
0337 WalkState->Opcode));
0338 Status = AE_AML_BAD_OPCODE;
0339 goto Cleanup;
0340 }
0341
0342
0343 Cleanup:
0344
0345 return_ACPI_STATUS (Status);
0346 }
0347
0348
0349
0350
0351
0352
0353
0354
0355
0356
0357
0358
0359
0360
0361
0362 ACPI_STATUS
0363 AcpiExOpcode_1A_1T_1R (
0364 ACPI_WALK_STATE *WalkState)
0365 {
0366 ACPI_STATUS Status = AE_OK;
0367 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
0368 ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
0369 ACPI_OPERAND_OBJECT *ReturnDesc2 = NULL;
0370 UINT32 Temp32;
0371 UINT32 i;
0372 ACPI_INTEGER PowerOfTen;
0373 ACPI_INTEGER Digit;
0374
0375
0376 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_1R,
0377 AcpiPsGetOpcodeName (WalkState->Opcode));
0378
0379
0380
0381
0382 switch (WalkState->Opcode)
0383 {
0384 case AML_BIT_NOT_OP:
0385 case AML_FIND_SET_LEFT_BIT_OP:
0386 case AML_FIND_SET_RIGHT_BIT_OP:
0387 case AML_FROM_BCD_OP:
0388 case AML_TO_BCD_OP:
0389 case AML_COND_REF_OF_OP:
0390
0391
0392
0393 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0394 if (!ReturnDesc)
0395 {
0396 Status = AE_NO_MEMORY;
0397 goto Cleanup;
0398 }
0399
0400 switch (WalkState->Opcode)
0401 {
0402 case AML_BIT_NOT_OP:
0403
0404 ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value;
0405 break;
0406
0407
0408 case AML_FIND_SET_LEFT_BIT_OP:
0409
0410 ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
0411
0412
0413
0414
0415
0416 for (Temp32 = 0; ReturnDesc->Integer.Value &&
0417 Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
0418 {
0419 ReturnDesc->Integer.Value >>= 1;
0420 }
0421
0422 ReturnDesc->Integer.Value = Temp32;
0423 break;
0424
0425
0426 case AML_FIND_SET_RIGHT_BIT_OP:
0427
0428 ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
0429
0430
0431
0432
0433
0434 for (Temp32 = 0; ReturnDesc->Integer.Value &&
0435 Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
0436 {
0437 ReturnDesc->Integer.Value <<= 1;
0438 }
0439
0440
0441
0442 ReturnDesc->Integer.Value =
0443 Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32;
0444 break;
0445
0446
0447 case AML_FROM_BCD_OP:
0448
0449
0450
0451
0452
0453
0454 PowerOfTen = 1;
0455 ReturnDesc->Integer.Value = 0;
0456 Digit = Operand[0]->Integer.Value;
0457
0458
0459
0460 for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)
0461 {
0462
0463
0464 Temp32 = ((UINT32) Digit) & 0xF;
0465
0466
0467
0468 if (Temp32 > 9)
0469 {
0470 ACPI_ERROR ((AE_INFO,
0471 "BCD digit too large (not decimal): 0x%X",
0472 Temp32));
0473
0474 Status = AE_AML_NUMERIC_OVERFLOW;
0475 goto Cleanup;
0476 }
0477
0478
0479
0480 ReturnDesc->Integer.Value +=
0481 (((ACPI_INTEGER) Temp32) * PowerOfTen);
0482
0483
0484
0485 Digit >>= 4;
0486
0487
0488
0489 PowerOfTen *= 10;
0490 }
0491 break;
0492
0493
0494 case AML_TO_BCD_OP:
0495
0496 ReturnDesc->Integer.Value = 0;
0497 Digit = Operand[0]->Integer.Value;
0498
0499
0500
0501 for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)
0502 {
0503 (void) AcpiUtShortDivide (Digit, 10, &Digit, &Temp32);
0504
0505
0506
0507
0508
0509 ReturnDesc->Integer.Value |=
0510 (((ACPI_INTEGER) Temp32) << ACPI_MUL_4 (i));
0511 }
0512
0513
0514
0515 if (Digit > 0)
0516 {
0517 ACPI_ERROR ((AE_INFO,
0518 "Integer too large to convert to BCD: %8.8X%8.8X",
0519 ACPI_FORMAT_UINT64 (Operand[0]->Integer.Value)));
0520 Status = AE_AML_NUMERIC_OVERFLOW;
0521 goto Cleanup;
0522 }
0523 break;
0524
0525
0526 case AML_COND_REF_OF_OP:
0527
0528
0529
0530
0531
0532
0533 if ((ACPI_NAMESPACE_NODE *) Operand[0] == AcpiGbl_RootNode)
0534 {
0535
0536
0537
0538
0539 ReturnDesc->Integer.Value = 0;
0540 goto Cleanup;
0541 }
0542
0543
0544
0545 Status = AcpiExGetObjectReference (Operand[0],
0546 &ReturnDesc2, WalkState);
0547 if (ACPI_FAILURE (Status))
0548 {
0549 goto Cleanup;
0550 }
0551
0552 Status = AcpiExStore (ReturnDesc2, Operand[1], WalkState);
0553 AcpiUtRemoveReference (ReturnDesc2);
0554
0555
0556
0557 ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
0558 goto Cleanup;
0559
0560
0561 default:
0562
0563 break;
0564 }
0565 break;
0566
0567
0568 case AML_STORE_OP:
0569
0570
0571
0572
0573
0574
0575 Status = AcpiExStore (Operand[0], Operand[1], WalkState);
0576 if (ACPI_FAILURE (Status))
0577 {
0578 return_ACPI_STATUS (Status);
0579 }
0580
0581
0582
0583 if (!WalkState->ResultObj)
0584 {
0585
0586
0587
0588
0589
0590
0591 WalkState->ResultObj = Operand[0];
0592 WalkState->Operands[0] = NULL;
0593 }
0594 return_ACPI_STATUS (Status);
0595
0596
0597
0598
0599
0600 case AML_COPY_OP:
0601
0602 Status = AcpiUtCopyIobjectToIobject (Operand[0], &ReturnDesc,
0603 WalkState);
0604 break;
0605
0606
0607 case AML_TO_DECSTRING_OP:
0608
0609 Status = AcpiExConvertToString (Operand[0], &ReturnDesc,
0610 ACPI_EXPLICIT_CONVERT_DECIMAL);
0611 if (ReturnDesc == Operand[0])
0612 {
0613
0614 AcpiUtAddReference (ReturnDesc);
0615 }
0616 break;
0617
0618
0619 case AML_TO_HEXSTRING_OP:
0620
0621 Status = AcpiExConvertToString (Operand[0], &ReturnDesc,
0622 ACPI_EXPLICIT_CONVERT_HEX);
0623 if (ReturnDesc == Operand[0])
0624 {
0625
0626 AcpiUtAddReference (ReturnDesc);
0627 }
0628 break;
0629
0630
0631 case AML_TO_BUFFER_OP:
0632
0633 Status = AcpiExConvertToBuffer (Operand[0], &ReturnDesc);
0634 if (ReturnDesc == Operand[0])
0635 {
0636
0637 AcpiUtAddReference (ReturnDesc);
0638 }
0639 break;
0640
0641
0642 case AML_TO_INTEGER_OP:
0643
0644 Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc,
0645 ACPI_ANY_BASE);
0646 if (ReturnDesc == Operand[0])
0647 {
0648
0649 AcpiUtAddReference (ReturnDesc);
0650 }
0651 break;
0652
0653
0654 case AML_SHIFT_LEFT_BIT_OP:
0655 case AML_SHIFT_RIGHT_BIT_OP:
0656
0657
0658
0659 ACPI_ERROR ((AE_INFO,
0660 "%s is obsolete and not implemented",
0661 AcpiPsGetOpcodeName (WalkState->Opcode)));
0662 Status = AE_SUPPORT;
0663 goto Cleanup;
0664
0665
0666 default:
0667
0668 ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
0669 WalkState->Opcode));
0670 Status = AE_AML_BAD_OPCODE;
0671 goto Cleanup;
0672 }
0673
0674 if (ACPI_SUCCESS (Status))
0675 {
0676
0677
0678 Status = AcpiExStore (ReturnDesc, Operand[1], WalkState);
0679 }
0680
0681
0682 Cleanup:
0683
0684
0685
0686 if (ACPI_FAILURE (Status))
0687 {
0688 AcpiUtRemoveReference (ReturnDesc);
0689 }
0690
0691
0692
0693 else if (!WalkState->ResultObj)
0694 {
0695 WalkState->ResultObj = ReturnDesc;
0696 }
0697
0698 return_ACPI_STATUS (Status);
0699 }
0700
0701
0702
0703
0704
0705
0706
0707
0708
0709
0710
0711
0712
0713
0714 ACPI_STATUS
0715 AcpiExOpcode_1A_0T_1R (
0716 ACPI_WALK_STATE *WalkState)
0717 {
0718 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
0719 ACPI_OPERAND_OBJECT *TempDesc;
0720 ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
0721 ACPI_STATUS Status = AE_OK;
0722 UINT32 Type;
0723 ACPI_INTEGER Value;
0724
0725
0726 ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R,
0727 AcpiPsGetOpcodeName (WalkState->Opcode));
0728
0729
0730
0731
0732 switch (WalkState->Opcode)
0733 {
0734 case AML_LNOT_OP:
0735
0736 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0737 if (!ReturnDesc)
0738 {
0739 Status = AE_NO_MEMORY;
0740 goto Cleanup;
0741 }
0742
0743
0744
0745
0746
0747 if (!Operand[0]->Integer.Value)
0748 {
0749 ReturnDesc->Integer.Value = ACPI_INTEGER_MAX;
0750 }
0751 break;
0752
0753
0754 case AML_DECREMENT_OP:
0755 case AML_INCREMENT_OP:
0756
0757
0758
0759
0760
0761 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0762 if (!ReturnDesc)
0763 {
0764 Status = AE_NO_MEMORY;
0765 goto Cleanup;
0766 }
0767
0768
0769
0770
0771
0772 TempDesc = Operand[0];
0773 if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND)
0774 {
0775
0776
0777 AcpiUtAddReference (TempDesc);
0778 }
0779
0780
0781
0782
0783
0784
0785
0786
0787 Status = AcpiExResolveOperands (AML_LNOT_OP, &TempDesc, WalkState);
0788 if (ACPI_FAILURE (Status))
0789 {
0790 ACPI_EXCEPTION ((AE_INFO, Status,
0791 "While resolving operands for [%s]",
0792 AcpiPsGetOpcodeName (WalkState->Opcode)));
0793
0794 goto Cleanup;
0795 }
0796
0797
0798
0799
0800
0801 if (WalkState->Opcode == AML_INCREMENT_OP)
0802 {
0803 ReturnDesc->Integer.Value = TempDesc->Integer.Value +1;
0804 }
0805 else
0806 {
0807 ReturnDesc->Integer.Value = TempDesc->Integer.Value -1;
0808 }
0809
0810
0811
0812 AcpiUtRemoveReference (TempDesc);
0813
0814
0815
0816
0817
0818 Status = AcpiExStore (ReturnDesc, Operand[0], WalkState);
0819 break;
0820
0821
0822 case AML_TYPE_OP:
0823
0824
0825
0826
0827
0828
0829
0830
0831
0832
0833 Status = AcpiExResolveMultiple (WalkState, Operand[0], &Type, NULL);
0834 if (ACPI_FAILURE (Status))
0835 {
0836 goto Cleanup;
0837 }
0838
0839
0840
0841 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0842 if (!ReturnDesc)
0843 {
0844 Status = AE_NO_MEMORY;
0845 goto Cleanup;
0846 }
0847
0848 ReturnDesc->Integer.Value = Type;
0849 break;
0850
0851
0852 case AML_SIZE_OF_OP:
0853
0854
0855
0856
0857
0858
0859
0860
0861 Status = AcpiExResolveMultiple (WalkState,
0862 Operand[0], &Type, &TempDesc);
0863 if (ACPI_FAILURE (Status))
0864 {
0865 goto Cleanup;
0866 }
0867
0868
0869
0870
0871
0872
0873
0874
0875
0876
0877 switch (Type)
0878 {
0879 case ACPI_TYPE_INTEGER:
0880 Value = AcpiGbl_IntegerByteWidth;
0881 break;
0882
0883 case ACPI_TYPE_STRING:
0884 Value = TempDesc->String.Length;
0885 break;
0886
0887 case ACPI_TYPE_BUFFER:
0888
0889
0890
0891 Status = AcpiDsGetBufferArguments (TempDesc);
0892 Value = TempDesc->Buffer.Length;
0893 break;
0894
0895 case ACPI_TYPE_PACKAGE:
0896
0897
0898
0899 Status = AcpiDsGetPackageArguments (TempDesc);
0900 Value = TempDesc->Package.Count;
0901 break;
0902
0903 default:
0904 ACPI_ERROR ((AE_INFO,
0905 "Operand must be Buffer/Integer/String/Package - found type %s",
0906 AcpiUtGetTypeName (Type)));
0907 Status = AE_AML_OPERAND_TYPE;
0908 goto Cleanup;
0909 }
0910
0911 if (ACPI_FAILURE (Status))
0912 {
0913 goto Cleanup;
0914 }
0915
0916
0917
0918
0919
0920 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
0921 if (!ReturnDesc)
0922 {
0923 Status = AE_NO_MEMORY;
0924 goto Cleanup;
0925 }
0926
0927 ReturnDesc->Integer.Value = Value;
0928 break;
0929
0930
0931 case AML_REF_OF_OP:
0932
0933 Status = AcpiExGetObjectReference (Operand[0], &ReturnDesc, WalkState);
0934 if (ACPI_FAILURE (Status))
0935 {
0936 goto Cleanup;
0937 }
0938 break;
0939
0940
0941 case AML_DEREF_OF_OP:
0942
0943
0944
0945 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
0946 {
0947 TempDesc = AcpiNsGetAttachedObject (
0948 (ACPI_NAMESPACE_NODE *) Operand[0]);
0949 if (TempDesc &&
0950 ((TempDesc->Common.Type == ACPI_TYPE_STRING) ||
0951 (TempDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)))
0952 {
0953 Operand[0] = TempDesc;
0954 AcpiUtAddReference (TempDesc);
0955 }
0956 else
0957 {
0958 Status = AE_AML_OPERAND_TYPE;
0959 goto Cleanup;
0960 }
0961 }
0962 else
0963 {
0964 switch ((Operand[0])->Common.Type)
0965 {
0966 case ACPI_TYPE_LOCAL_REFERENCE:
0967
0968
0969
0970
0971
0972 switch (Operand[0]->Reference.Class)
0973 {
0974 case ACPI_REFCLASS_LOCAL:
0975 case ACPI_REFCLASS_ARG:
0976
0977
0978
0979 Status = AcpiDsMethodDataGetValue (
0980 Operand[0]->Reference.Class,
0981 Operand[0]->Reference.Value,
0982 WalkState, &TempDesc);
0983 if (ACPI_FAILURE (Status))
0984 {
0985 goto Cleanup;
0986 }
0987
0988
0989
0990
0991
0992 AcpiUtRemoveReference (Operand[0]);
0993 Operand[0] = TempDesc;
0994 break;
0995
0996 case ACPI_REFCLASS_REFOF:
0997
0998
0999
1000 TempDesc = Operand[0]->Reference.Object;
1001 AcpiUtRemoveReference (Operand[0]);
1002 Operand[0] = TempDesc;
1003 break;
1004
1005 default:
1006
1007
1008 break;
1009 }
1010 break;
1011
1012 case ACPI_TYPE_STRING:
1013 break;
1014
1015 default:
1016 Status = AE_AML_OPERAND_TYPE;
1017 goto Cleanup;
1018 }
1019 }
1020
1021 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) != ACPI_DESC_TYPE_NAMED)
1022 {
1023 if ((Operand[0])->Common.Type == ACPI_TYPE_STRING)
1024 {
1025
1026
1027
1028
1029
1030
1031
1032
1033 Status = AcpiNsGetNode (WalkState->ScopeInfo->Scope.Node,
1034 Operand[0]->String.Pointer,
1035 ACPI_NS_SEARCH_PARENT,
1036 ACPI_CAST_INDIRECT_PTR (
1037 ACPI_NAMESPACE_NODE, &ReturnDesc));
1038 if (ACPI_FAILURE (Status))
1039 {
1040 goto Cleanup;
1041 }
1042
1043 Status = AcpiExResolveNodeToValue (
1044 ACPI_CAST_INDIRECT_PTR (
1045 ACPI_NAMESPACE_NODE, &ReturnDesc),
1046 WalkState);
1047 goto Cleanup;
1048 }
1049 }
1050
1051
1052
1053 if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
1054 {
1055
1056
1057
1058
1059
1060
1061 ReturnDesc = AcpiNsGetAttachedObject (
1062 (ACPI_NAMESPACE_NODE *) Operand[0]);
1063 AcpiUtAddReference (ReturnDesc);
1064 }
1065 else
1066 {
1067
1068
1069
1070
1071 switch (Operand[0]->Reference.Class)
1072 {
1073 case ACPI_REFCLASS_INDEX:
1074
1075
1076
1077
1078
1079 switch (Operand[0]->Reference.TargetType)
1080 {
1081 case ACPI_TYPE_BUFFER_FIELD:
1082
1083 TempDesc = Operand[0]->Reference.Object;
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
1094 if (!ReturnDesc)
1095 {
1096 Status = AE_NO_MEMORY;
1097 goto Cleanup;
1098 }
1099
1100
1101
1102
1103
1104
1105 ReturnDesc->Integer.Value =
1106 TempDesc->Buffer.Pointer[Operand[0]->Reference.Value];
1107 break;
1108
1109
1110 case ACPI_TYPE_PACKAGE:
1111
1112
1113
1114
1115
1116 ReturnDesc = *(Operand[0]->Reference.Where);
1117 if (ReturnDesc)
1118 {
1119 AcpiUtAddReference (ReturnDesc);
1120 }
1121 break;
1122
1123
1124 default:
1125
1126 ACPI_ERROR ((AE_INFO,
1127 "Unknown Index TargetType %X in reference object %p",
1128 Operand[0]->Reference.TargetType, Operand[0]));
1129 Status = AE_AML_OPERAND_TYPE;
1130 goto Cleanup;
1131 }
1132 break;
1133
1134
1135 case ACPI_REFCLASS_REFOF:
1136
1137 ReturnDesc = Operand[0]->Reference.Object;
1138
1139 if (ACPI_GET_DESCRIPTOR_TYPE (ReturnDesc) ==
1140 ACPI_DESC_TYPE_NAMED)
1141 {
1142 ReturnDesc = AcpiNsGetAttachedObject (
1143 (ACPI_NAMESPACE_NODE *) ReturnDesc);
1144 }
1145
1146
1147
1148 AcpiUtAddReference (ReturnDesc);
1149 break;
1150
1151
1152 default:
1153 ACPI_ERROR ((AE_INFO,
1154 "Unknown class in reference(%p) - %2.2X",
1155 Operand[0], Operand[0]->Reference.Class));
1156
1157 Status = AE_TYPE;
1158 goto Cleanup;
1159 }
1160 }
1161 break;
1162
1163
1164 default:
1165
1166 ACPI_ERROR ((AE_INFO, "Unknown AML opcode %X",
1167 WalkState->Opcode));
1168 Status = AE_AML_BAD_OPCODE;
1169 goto Cleanup;
1170 }
1171
1172
1173 Cleanup:
1174
1175
1176
1177 if (ACPI_FAILURE (Status))
1178 {
1179 AcpiUtRemoveReference (ReturnDesc);
1180 }
1181
1182
1183
1184 else
1185 {
1186 WalkState->ResultObj = ReturnDesc;
1187 }
1188
1189 return_ACPI_STATUS (Status);
1190 }
1191