Warning, cross-references for /kernel/drivers/acpica/nspredef.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 __NSPREDEF_C__
0117
0118 #include "acpi.h"
0119 #include "accommon.h"
0120 #include "acnamesp.h"
0121 #include "acpredef.h"
0122
0123
0124 #define _COMPONENT ACPI_NAMESPACE
0125 ACPI_MODULE_NAME ("nspredef")
0126
0127
0128
0129
0130
0131
0132
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152 static ACPI_STATUS
0153 AcpiNsCheckPackage (
0154 ACPI_PREDEFINED_DATA *Data,
0155 ACPI_OPERAND_OBJECT **ReturnObjectPtr);
0156
0157 static ACPI_STATUS
0158 AcpiNsCheckPackageElements (
0159 ACPI_PREDEFINED_DATA *Data,
0160 ACPI_OPERAND_OBJECT **Elements,
0161 UINT8 Type1,
0162 UINT32 Count1,
0163 UINT8 Type2,
0164 UINT32 Count2,
0165 UINT32 StartIndex);
0166
0167 static ACPI_STATUS
0168 AcpiNsCheckObjectType (
0169 ACPI_PREDEFINED_DATA *Data,
0170 ACPI_OPERAND_OBJECT **ReturnObjectPtr,
0171 UINT32 ExpectedBtypes,
0172 UINT32 PackageIndex);
0173
0174 static ACPI_STATUS
0175 AcpiNsCheckReference (
0176 ACPI_PREDEFINED_DATA *Data,
0177 ACPI_OPERAND_OBJECT *ReturnObject);
0178
0179 static ACPI_STATUS
0180 AcpiNsRepairObject (
0181 ACPI_PREDEFINED_DATA *Data,
0182 UINT32 ExpectedBtypes,
0183 UINT32 PackageIndex,
0184 ACPI_OPERAND_OBJECT **ReturnObjectPtr);
0185
0186 static void
0187 AcpiNsGetExpectedTypes (
0188 char *Buffer,
0189 UINT32 ExpectedBtypes);
0190
0191
0192
0193
0194
0195 static const char *AcpiRtypeNames[] =
0196 {
0197 "/Integer",
0198 "/String",
0199 "/Buffer",
0200 "/Package",
0201 "/Reference",
0202 };
0203
0204
0205
0206 #define ACPI_NOT_PACKAGE_ELEMENT ACPI_UINT32_MAX
0207
0208
0209
0210 #define ACPI_WARN_ALWAYS 0
0211
0212
0213
0214
0215
0216
0217
0218
0219
0220
0221
0222
0223
0224
0225
0226
0227
0228
0229 ACPI_STATUS
0230 AcpiNsCheckPredefinedNames (
0231 ACPI_NAMESPACE_NODE *Node,
0232 UINT32 UserParamCount,
0233 ACPI_STATUS ReturnStatus,
0234 ACPI_OPERAND_OBJECT **ReturnObjectPtr)
0235 {
0236 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
0237 ACPI_STATUS Status = AE_OK;
0238 const ACPI_PREDEFINED_INFO *Predefined;
0239 char *Pathname;
0240 ACPI_PREDEFINED_DATA *Data;
0241
0242
0243
0244
0245 Predefined = AcpiNsCheckForPredefinedName (Node);
0246
0247
0248
0249 Pathname = AcpiNsGetExternalPathname (Node);
0250 if (!Pathname)
0251 {
0252 return (AE_OK);
0253 }
0254
0255
0256
0257
0258
0259
0260 AcpiNsCheckParameterCount (Pathname, Node, UserParamCount, Predefined);
0261
0262
0263
0264 if (!Predefined)
0265 {
0266 goto Cleanup;
0267 }
0268
0269
0270
0271
0272
0273 if ((ReturnStatus != AE_OK) && (ReturnStatus != AE_CTRL_RETURN_VALUE))
0274 {
0275 goto Cleanup;
0276 }
0277
0278
0279
0280
0281
0282
0283
0284
0285 if (!ReturnObject)
0286 {
0287 if ((Predefined->Info.ExpectedBtypes) &&
0288 (!(Predefined->Info.ExpectedBtypes & ACPI_RTYPE_NONE)))
0289 {
0290 ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
0291 "Missing expected return value"));
0292
0293 Status = AE_AML_NO_RETURN_VALUE;
0294 }
0295 goto Cleanup;
0296 }
0297
0298
0299
0300
0301
0302
0303 if (!Predefined->Info.ExpectedBtypes)
0304 {
0305 goto Cleanup;
0306 }
0307
0308
0309
0310 Data = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PREDEFINED_DATA));
0311 if (!Data)
0312 {
0313 goto Cleanup;
0314 }
0315 Data->Predefined = Predefined;
0316 Data->NodeFlags = Node->Flags;
0317 Data->Pathname = Pathname;
0318
0319
0320
0321
0322
0323 Status = AcpiNsCheckObjectType (Data, ReturnObjectPtr,
0324 Predefined->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT);
0325 if (ACPI_FAILURE (Status))
0326 {
0327 goto CheckValidationStatus;
0328 }
0329
0330
0331
0332 if (ReturnObject->Common.Type == ACPI_TYPE_PACKAGE)
0333 {
0334 Status = AcpiNsCheckPackage (Data, ReturnObjectPtr);
0335 }
0336
0337
0338 CheckValidationStatus:
0339
0340
0341
0342
0343
0344 if (ACPI_FAILURE (Status) || (Data->Flags & ACPI_OBJECT_REPAIRED))
0345 {
0346 Node->Flags |= ANOBJ_EVALUATED;
0347 }
0348 ACPI_FREE (Data);
0349
0350
0351 Cleanup:
0352 ACPI_FREE (Pathname);
0353 return (Status);
0354 }
0355
0356
0357
0358
0359
0360
0361
0362
0363
0364
0365
0366
0367
0368
0369
0370
0371
0372
0373
0374 void
0375 AcpiNsCheckParameterCount (
0376 char *Pathname,
0377 ACPI_NAMESPACE_NODE *Node,
0378 UINT32 UserParamCount,
0379 const ACPI_PREDEFINED_INFO *Predefined)
0380 {
0381 UINT32 ParamCount;
0382 UINT32 RequiredParamsCurrent;
0383 UINT32 RequiredParamsOld;
0384
0385
0386
0387
0388 ParamCount = 0;
0389 if (Node->Type == ACPI_TYPE_METHOD)
0390 {
0391 ParamCount = Node->Object->Method.ParamCount;
0392 }
0393
0394 if (!Predefined)
0395 {
0396
0397
0398
0399
0400
0401
0402
0403
0404 if (UserParamCount < ParamCount)
0405 {
0406 ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
0407 "Insufficient arguments - needs %u, found %u",
0408 ParamCount, UserParamCount));
0409 }
0410 else if (UserParamCount > ParamCount)
0411 {
0412 ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
0413 "Excess arguments - needs %u, found %u",
0414 ParamCount, UserParamCount));
0415 }
0416 return;
0417 }
0418
0419
0420
0421
0422
0423 RequiredParamsCurrent = Predefined->Info.ParamCount & 0x0F;
0424 RequiredParamsOld = Predefined->Info.ParamCount >> 4;
0425
0426 if (UserParamCount != ACPI_UINT32_MAX)
0427 {
0428 if ((UserParamCount != RequiredParamsCurrent) &&
0429 (UserParamCount != RequiredParamsOld))
0430 {
0431 ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
0432 "Parameter count mismatch - "
0433 "caller passed %u, ACPI requires %u",
0434 UserParamCount, RequiredParamsCurrent));
0435 }
0436 }
0437
0438
0439
0440
0441
0442
0443 if ((ParamCount != RequiredParamsCurrent) &&
0444 (ParamCount != RequiredParamsOld))
0445 {
0446 ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, Node->Flags,
0447 "Parameter count mismatch - ASL declared %u, ACPI requires %u",
0448 ParamCount, RequiredParamsCurrent));
0449 }
0450 }
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463
0464
0465 const ACPI_PREDEFINED_INFO *
0466 AcpiNsCheckForPredefinedName (
0467 ACPI_NAMESPACE_NODE *Node)
0468 {
0469 const ACPI_PREDEFINED_INFO *ThisName;
0470
0471
0472
0473
0474 if (Node->Name.Ascii[0] != '_')
0475 {
0476 return (NULL);
0477 }
0478
0479
0480
0481 ThisName = PredefinedNames;
0482 while (ThisName->Info.Name[0])
0483 {
0484 if (ACPI_COMPARE_NAME (Node->Name.Ascii, ThisName->Info.Name))
0485 {
0486 return (ThisName);
0487 }
0488
0489
0490
0491
0492
0493 if (ThisName->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
0494 {
0495 ThisName++;
0496 }
0497
0498 ThisName++;
0499 }
0500
0501 return (NULL);
0502 }
0503
0504
0505
0506
0507
0508
0509
0510
0511
0512
0513
0514
0515
0516
0517
0518
0519
0520 static ACPI_STATUS
0521 AcpiNsCheckPackage (
0522 ACPI_PREDEFINED_DATA *Data,
0523 ACPI_OPERAND_OBJECT **ReturnObjectPtr)
0524 {
0525 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
0526 const ACPI_PREDEFINED_INFO *Package;
0527 ACPI_OPERAND_OBJECT *SubPackage;
0528 ACPI_OPERAND_OBJECT **Elements;
0529 ACPI_OPERAND_OBJECT **SubElements;
0530 ACPI_STATUS Status;
0531 UINT32 ExpectedCount;
0532 UINT32 Count;
0533 UINT32 i;
0534 UINT32 j;
0535
0536
0537 ACPI_FUNCTION_NAME (NsCheckPackage);
0538
0539
0540
0541
0542 Package = Data->Predefined + 1;
0543
0544 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
0545 "%s Validating return Package of Type %X, Count %X\n",
0546 Data->Pathname, Package->RetInfo.Type, ReturnObject->Package.Count));
0547
0548
0549
0550 Elements = ReturnObject->Package.Elements;
0551 Count = ReturnObject->Package.Count;
0552
0553
0554
0555 if (!Count)
0556 {
0557 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
0558 "Return Package has no elements (empty)"));
0559
0560 return (AE_AML_OPERAND_VALUE);
0561 }
0562
0563
0564
0565
0566
0567
0568
0569 switch (Package->RetInfo.Type)
0570 {
0571 case ACPI_PTYPE1_FIXED:
0572
0573
0574
0575
0576
0577
0578
0579 ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
0580 if (Count < ExpectedCount)
0581 {
0582 goto PackageTooSmall;
0583 }
0584 else if (Count > ExpectedCount)
0585 {
0586 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
0587 "Return Package is larger than needed - "
0588 "found %u, expected %u", Count, ExpectedCount));
0589 }
0590
0591
0592
0593 Status = AcpiNsCheckPackageElements (Data, Elements,
0594 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
0595 Package->RetInfo.ObjectType2, Package->RetInfo.Count2, 0);
0596 if (ACPI_FAILURE (Status))
0597 {
0598 return (Status);
0599 }
0600 break;
0601
0602
0603 case ACPI_PTYPE1_VAR:
0604
0605
0606
0607
0608
0609 for (i = 0; i < Count; i++)
0610 {
0611 Status = AcpiNsCheckObjectType (Data, Elements,
0612 Package->RetInfo.ObjectType1, i);
0613 if (ACPI_FAILURE (Status))
0614 {
0615 return (Status);
0616 }
0617 Elements++;
0618 }
0619 break;
0620
0621
0622 case ACPI_PTYPE1_OPTION:
0623
0624
0625
0626
0627
0628
0629
0630
0631 ExpectedCount = Package->RetInfo3.Count;
0632 if (Count < ExpectedCount)
0633 {
0634 goto PackageTooSmall;
0635 }
0636
0637
0638
0639 for (i = 0; i < Count; i++)
0640 {
0641 if (i < Package->RetInfo3.Count)
0642 {
0643
0644
0645 Status = AcpiNsCheckObjectType (Data, Elements,
0646 Package->RetInfo3.ObjectType[i], i);
0647 if (ACPI_FAILURE (Status))
0648 {
0649 return (Status);
0650 }
0651 }
0652 else
0653 {
0654
0655
0656 Status = AcpiNsCheckObjectType (Data, Elements,
0657 Package->RetInfo3.TailObjectType, i);
0658 if (ACPI_FAILURE (Status))
0659 {
0660 return (Status);
0661 }
0662 }
0663 Elements++;
0664 }
0665 break;
0666
0667
0668 case ACPI_PTYPE2_PKG_COUNT:
0669
0670
0671
0672 Status = AcpiNsCheckObjectType (Data, Elements,
0673 ACPI_RTYPE_INTEGER, 0);
0674 if (ACPI_FAILURE (Status))
0675 {
0676 return (Status);
0677 }
0678
0679
0680
0681
0682
0683 ExpectedCount = (UINT32) (*Elements)->Integer.Value;
0684 if (ExpectedCount >= Count)
0685 {
0686 goto PackageTooSmall;
0687 }
0688
0689 Count = ExpectedCount;
0690 Elements++;
0691
0692
0693
0694
0695
0696
0697 case ACPI_PTYPE2:
0698 case ACPI_PTYPE2_FIXED:
0699 case ACPI_PTYPE2_MIN:
0700 case ACPI_PTYPE2_COUNT:
0701
0702
0703
0704
0705
0706 for (i = 0; i < Count; i++)
0707 {
0708 SubPackage = *Elements;
0709 SubElements = SubPackage->Package.Elements;
0710
0711
0712
0713 Status = AcpiNsCheckObjectType (Data, &SubPackage,
0714 ACPI_RTYPE_PACKAGE, i);
0715 if (ACPI_FAILURE (Status))
0716 {
0717 return (Status);
0718 }
0719
0720
0721
0722 switch (Package->RetInfo.Type)
0723 {
0724 case ACPI_PTYPE2:
0725 case ACPI_PTYPE2_PKG_COUNT:
0726
0727
0728
0729 ExpectedCount =
0730 Package->RetInfo.Count1 + Package->RetInfo.Count2;
0731 if (SubPackage->Package.Count != ExpectedCount)
0732 {
0733 Count = SubPackage->Package.Count;
0734 goto PackageTooSmall;
0735 }
0736
0737 Status = AcpiNsCheckPackageElements (Data, SubElements,
0738 Package->RetInfo.ObjectType1,
0739 Package->RetInfo.Count1,
0740 Package->RetInfo.ObjectType2,
0741 Package->RetInfo.Count2, 0);
0742 if (ACPI_FAILURE (Status))
0743 {
0744 return (Status);
0745 }
0746 break;
0747
0748 case ACPI_PTYPE2_FIXED:
0749
0750
0751
0752 ExpectedCount = Package->RetInfo2.Count;
0753 if (SubPackage->Package.Count < ExpectedCount)
0754 {
0755 Count = SubPackage->Package.Count;
0756 goto PackageTooSmall;
0757 }
0758
0759
0760
0761 for (j = 0; j < ExpectedCount; j++)
0762 {
0763 Status = AcpiNsCheckObjectType (Data, &SubElements[j],
0764 Package->RetInfo2.ObjectType[j], j);
0765 if (ACPI_FAILURE (Status))
0766 {
0767 return (Status);
0768 }
0769 }
0770 break;
0771
0772 case ACPI_PTYPE2_MIN:
0773
0774
0775
0776 ExpectedCount = Package->RetInfo.Count1;
0777 if (SubPackage->Package.Count < ExpectedCount)
0778 {
0779 Count = SubPackage->Package.Count;
0780 goto PackageTooSmall;
0781 }
0782
0783
0784
0785 Status = AcpiNsCheckPackageElements (Data, SubElements,
0786 Package->RetInfo.ObjectType1,
0787 SubPackage->Package.Count, 0, 0, 0);
0788 if (ACPI_FAILURE (Status))
0789 {
0790 return (Status);
0791 }
0792 break;
0793
0794 case ACPI_PTYPE2_COUNT:
0795
0796
0797
0798 Status = AcpiNsCheckObjectType (Data, SubElements,
0799 ACPI_RTYPE_INTEGER, 0);
0800 if (ACPI_FAILURE (Status))
0801 {
0802 return (Status);
0803 }
0804
0805
0806
0807 ExpectedCount = (UINT32) (*SubElements)->Integer.Value;
0808 if (SubPackage->Package.Count < ExpectedCount)
0809 {
0810 Count = SubPackage->Package.Count;
0811 goto PackageTooSmall;
0812 }
0813
0814
0815
0816 Status = AcpiNsCheckPackageElements (Data, (SubElements + 1),
0817 Package->RetInfo.ObjectType1,
0818 (ExpectedCount - 1), 0, 0, 1);
0819 if (ACPI_FAILURE (Status))
0820 {
0821 return (Status);
0822 }
0823 break;
0824
0825 default:
0826 break;
0827 }
0828
0829 Elements++;
0830 }
0831 break;
0832
0833
0834 default:
0835
0836
0837
0838 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
0839 "Invalid internal return type in table entry: %X",
0840 Package->RetInfo.Type));
0841
0842 return (AE_AML_INTERNAL);
0843 }
0844
0845 return (AE_OK);
0846
0847
0848 PackageTooSmall:
0849
0850
0851
0852 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
0853 "Return Package is too small - found %u, expected %u",
0854 Count, ExpectedCount));
0855
0856 return (AE_AML_OPERAND_VALUE);
0857 }
0858
0859
0860
0861
0862
0863
0864
0865
0866
0867
0868
0869
0870
0871
0872
0873
0874
0875
0876
0877
0878
0879 static ACPI_STATUS
0880 AcpiNsCheckPackageElements (
0881 ACPI_PREDEFINED_DATA *Data,
0882 ACPI_OPERAND_OBJECT **Elements,
0883 UINT8 Type1,
0884 UINT32 Count1,
0885 UINT8 Type2,
0886 UINT32 Count2,
0887 UINT32 StartIndex)
0888 {
0889 ACPI_OPERAND_OBJECT **ThisElement = Elements;
0890 ACPI_STATUS Status;
0891 UINT32 i;
0892
0893
0894
0895
0896
0897
0898
0899 for (i = 0; i < Count1; i++)
0900 {
0901 Status = AcpiNsCheckObjectType (Data, ThisElement,
0902 Type1, i + StartIndex);
0903 if (ACPI_FAILURE (Status))
0904 {
0905 return (Status);
0906 }
0907 ThisElement++;
0908 }
0909
0910 for (i = 0; i < Count2; i++)
0911 {
0912 Status = AcpiNsCheckObjectType (Data, ThisElement,
0913 Type2, (i + Count1 + StartIndex));
0914 if (ACPI_FAILURE (Status))
0915 {
0916 return (Status);
0917 }
0918 ThisElement++;
0919 }
0920
0921 return (AE_OK);
0922 }
0923
0924
0925
0926
0927
0928
0929
0930
0931
0932
0933
0934
0935
0936
0937
0938
0939
0940
0941
0942
0943
0944 static ACPI_STATUS
0945 AcpiNsCheckObjectType (
0946 ACPI_PREDEFINED_DATA *Data,
0947 ACPI_OPERAND_OBJECT **ReturnObjectPtr,
0948 UINT32 ExpectedBtypes,
0949 UINT32 PackageIndex)
0950 {
0951 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
0952 ACPI_STATUS Status = AE_OK;
0953 UINT32 ReturnBtype;
0954 char TypeBuffer[48];
0955
0956
0957
0958
0959
0960
0961 if (!ReturnObject)
0962 {
0963 goto TypeErrorExit;
0964 }
0965
0966
0967
0968 if (ACPI_GET_DESCRIPTOR_TYPE (ReturnObject) == ACPI_DESC_TYPE_NAMED)
0969 {
0970 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
0971 "Invalid return type - Found a Namespace node [%4.4s] type %s",
0972 ReturnObject->Node.Name.Ascii,
0973 AcpiUtGetTypeName (ReturnObject->Node.Type)));
0974 return (AE_AML_OPERAND_TYPE);
0975 }
0976
0977
0978
0979
0980
0981
0982
0983
0984
0985 switch (ReturnObject->Common.Type)
0986 {
0987 case ACPI_TYPE_INTEGER:
0988 ReturnBtype = ACPI_RTYPE_INTEGER;
0989 break;
0990
0991 case ACPI_TYPE_BUFFER:
0992 ReturnBtype = ACPI_RTYPE_BUFFER;
0993 break;
0994
0995 case ACPI_TYPE_STRING:
0996 ReturnBtype = ACPI_RTYPE_STRING;
0997 break;
0998
0999 case ACPI_TYPE_PACKAGE:
1000 ReturnBtype = ACPI_RTYPE_PACKAGE;
1001 break;
1002
1003 case ACPI_TYPE_LOCAL_REFERENCE:
1004 ReturnBtype = ACPI_RTYPE_REFERENCE;
1005 break;
1006
1007 default:
1008
1009
1010 goto TypeErrorExit;
1011 }
1012
1013
1014
1015 if (!(ReturnBtype & ExpectedBtypes))
1016 {
1017
1018
1019 Status = AcpiNsRepairObject (Data, ExpectedBtypes,
1020 PackageIndex, ReturnObjectPtr);
1021 if (ACPI_SUCCESS (Status))
1022 {
1023 return (AE_OK);
1024 }
1025 goto TypeErrorExit;
1026 }
1027
1028
1029
1030 if (ReturnObject->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)
1031 {
1032 Status = AcpiNsCheckReference (Data, ReturnObject);
1033 }
1034
1035 return (Status);
1036
1037
1038 TypeErrorExit:
1039
1040
1041
1042 AcpiNsGetExpectedTypes (TypeBuffer, ExpectedBtypes);
1043
1044 if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT)
1045 {
1046 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
1047 "Return type mismatch - found %s, expected %s",
1048 AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
1049 }
1050 else
1051 {
1052 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
1053 "Return Package type mismatch at index %u - "
1054 "found %s, expected %s", PackageIndex,
1055 AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
1056 }
1057
1058 return (AE_AML_OPERAND_TYPE);
1059 }
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078 static ACPI_STATUS
1079 AcpiNsCheckReference (
1080 ACPI_PREDEFINED_DATA *Data,
1081 ACPI_OPERAND_OBJECT *ReturnObject)
1082 {
1083
1084
1085
1086
1087
1088
1089 if (ReturnObject->Reference.Class == ACPI_REFCLASS_NAME)
1090 {
1091 return (AE_OK);
1092 }
1093
1094 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
1095 "Return type mismatch - unexpected reference object type [%s] %2.2X",
1096 AcpiUtGetReferenceName (ReturnObject),
1097 ReturnObject->Reference.Class));
1098
1099 return (AE_AML_OPERAND_TYPE);
1100 }
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122 static ACPI_STATUS
1123 AcpiNsRepairObject (
1124 ACPI_PREDEFINED_DATA *Data,
1125 UINT32 ExpectedBtypes,
1126 UINT32 PackageIndex,
1127 ACPI_OPERAND_OBJECT **ReturnObjectPtr)
1128 {
1129 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
1130 ACPI_OPERAND_OBJECT *NewObject;
1131 ACPI_SIZE Length;
1132
1133
1134 switch (ReturnObject->Common.Type)
1135 {
1136 case ACPI_TYPE_BUFFER:
1137
1138
1139
1140 if (!(ExpectedBtypes & ACPI_RTYPE_STRING))
1141 {
1142 return (AE_AML_OPERAND_TYPE);
1143 }
1144
1145
1146
1147
1148
1149
1150
1151 Length = 0;
1152 while ((Length < ReturnObject->Buffer.Length) &&
1153 (ReturnObject->Buffer.Pointer[Length]))
1154 {
1155 Length++;
1156 }
1157
1158
1159
1160 NewObject = AcpiUtCreateStringObject (Length);
1161 if (!NewObject)
1162 {
1163 return (AE_NO_MEMORY);
1164 }
1165
1166
1167
1168
1169
1170 ACPI_MEMCPY (NewObject->String.Pointer,
1171 ReturnObject->Buffer.Pointer, Length);
1172
1173
1174
1175
1176
1177
1178
1179 if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
1180 {
1181 NewObject->Common.ReferenceCount =
1182 ReturnObject->Common.ReferenceCount;
1183
1184 if (ReturnObject->Common.ReferenceCount > 1)
1185 {
1186 ReturnObject->Common.ReferenceCount--;
1187 }
1188
1189 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
1190 "Converted Buffer to expected String at index %u",
1191 PackageIndex));
1192 }
1193 else
1194 {
1195 ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
1196 "Converted Buffer to expected String"));
1197 }
1198
1199
1200
1201 AcpiUtRemoveReference (ReturnObject);
1202 *ReturnObjectPtr = NewObject;
1203 Data->Flags |= ACPI_OBJECT_REPAIRED;
1204 return (AE_OK);
1205
1206 default:
1207 break;
1208 }
1209
1210 return (AE_AML_OPERAND_TYPE);
1211 }
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228 static void
1229 AcpiNsGetExpectedTypes (
1230 char *Buffer,
1231 UINT32 ExpectedBtypes)
1232 {
1233 UINT32 ThisRtype;
1234 UINT32 i;
1235 UINT32 j;
1236
1237
1238 j = 1;
1239 Buffer[0] = 0;
1240 ThisRtype = ACPI_RTYPE_INTEGER;
1241
1242 for (i = 0; i < ACPI_NUM_RTYPES; i++)
1243 {
1244
1245
1246 if (ExpectedBtypes & ThisRtype)
1247 {
1248 ACPI_STRCAT (Buffer, &AcpiRtypeNames[i][j]);
1249 j = 0;
1250 }
1251 ThisRtype <<= 1;
1252 }
1253 }