1e38021177a43932cd32e674bc12eef6f77b815e
[reactos.git] / reactos / drivers / bus / acpi / acpica / namespace / nsprepkg.c
1 /******************************************************************************
2 *
3 * Module Name: nsprepkg - Validation of package objects for predefined names
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, 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.h"
45 #include "accommon.h"
46 #include "acnamesp.h"
47 #include "acpredef.h"
48
49
50 #define _COMPONENT ACPI_NAMESPACE
51 ACPI_MODULE_NAME ("nsprepkg")
52
53
54 /* Local prototypes */
55
56 static ACPI_STATUS
57 AcpiNsCheckPackageList (
58 ACPI_EVALUATE_INFO *Info,
59 const ACPI_PREDEFINED_INFO *Package,
60 ACPI_OPERAND_OBJECT **Elements,
61 UINT32 Count);
62
63 static ACPI_STATUS
64 AcpiNsCheckPackageElements (
65 ACPI_EVALUATE_INFO *Info,
66 ACPI_OPERAND_OBJECT **Elements,
67 UINT8 Type1,
68 UINT32 Count1,
69 UINT8 Type2,
70 UINT32 Count2,
71 UINT32 StartIndex);
72
73 static ACPI_STATUS
74 AcpiNsCustomPackage (
75 ACPI_EVALUATE_INFO *Info,
76 ACPI_OPERAND_OBJECT **Elements,
77 UINT32 Count);
78
79
80 /*******************************************************************************
81 *
82 * FUNCTION: AcpiNsCheckPackage
83 *
84 * PARAMETERS: Info - Method execution information block
85 * ReturnObjectPtr - Pointer to the object returned from the
86 * evaluation of a method or object
87 *
88 * RETURN: Status
89 *
90 * DESCRIPTION: Check a returned package object for the correct count and
91 * correct type of all sub-objects.
92 *
93 ******************************************************************************/
94
95 ACPI_STATUS
96 AcpiNsCheckPackage (
97 ACPI_EVALUATE_INFO *Info,
98 ACPI_OPERAND_OBJECT **ReturnObjectPtr)
99 {
100 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
101 const ACPI_PREDEFINED_INFO *Package;
102 ACPI_OPERAND_OBJECT **Elements;
103 ACPI_STATUS Status = AE_OK;
104 UINT32 ExpectedCount;
105 UINT32 Count;
106 UINT32 i;
107
108
109 ACPI_FUNCTION_NAME (NsCheckPackage);
110
111
112 /* The package info for this name is in the next table entry */
113
114 Package = Info->Predefined + 1;
115
116 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
117 "%s Validating return Package of Type %X, Count %X\n",
118 Info->FullPathname, Package->RetInfo.Type,
119 ReturnObject->Package.Count));
120
121 /*
122 * For variable-length Packages, we can safely remove all embedded
123 * and trailing NULL package elements
124 */
125 AcpiNsRemoveNullElements (Info, Package->RetInfo.Type, ReturnObject);
126
127 /* Extract package count and elements array */
128
129 Elements = ReturnObject->Package.Elements;
130 Count = ReturnObject->Package.Count;
131
132 /*
133 * Most packages must have at least one element. The only exception
134 * is the variable-length package (ACPI_PTYPE1_VAR).
135 */
136 if (!Count)
137 {
138 if (Package->RetInfo.Type == ACPI_PTYPE1_VAR)
139 {
140 return (AE_OK);
141 }
142
143 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
144 "Return Package has no elements (empty)"));
145
146 return (AE_AML_OPERAND_VALUE);
147 }
148
149 /*
150 * Decode the type of the expected package contents
151 *
152 * PTYPE1 packages contain no subpackages
153 * PTYPE2 packages contain subpackages
154 */
155 switch (Package->RetInfo.Type)
156 {
157 case ACPI_PTYPE_CUSTOM:
158
159 Status = AcpiNsCustomPackage (Info, Elements, Count);
160 break;
161
162 case ACPI_PTYPE1_FIXED:
163 /*
164 * The package count is fixed and there are no subpackages
165 *
166 * If package is too small, exit.
167 * If package is larger than expected, issue warning but continue
168 */
169 ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
170 if (Count < ExpectedCount)
171 {
172 goto PackageTooSmall;
173 }
174 else if (Count > ExpectedCount)
175 {
176 ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
177 "%s: Return Package is larger than needed - "
178 "found %u, expected %u\n",
179 Info->FullPathname, Count, ExpectedCount));
180 }
181
182 /* Validate all elements of the returned package */
183
184 Status = AcpiNsCheckPackageElements (Info, Elements,
185 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
186 Package->RetInfo.ObjectType2, Package->RetInfo.Count2, 0);
187 break;
188
189 case ACPI_PTYPE1_VAR:
190 /*
191 * The package count is variable, there are no subpackages, and all
192 * elements must be of the same type
193 */
194 for (i = 0; i < Count; i++)
195 {
196 Status = AcpiNsCheckObjectType (Info, Elements,
197 Package->RetInfo.ObjectType1, i);
198 if (ACPI_FAILURE (Status))
199 {
200 return (Status);
201 }
202
203 Elements++;
204 }
205 break;
206
207 case ACPI_PTYPE1_OPTION:
208 /*
209 * The package count is variable, there are no subpackages. There are
210 * a fixed number of required elements, and a variable number of
211 * optional elements.
212 *
213 * Check if package is at least as large as the minimum required
214 */
215 ExpectedCount = Package->RetInfo3.Count;
216 if (Count < ExpectedCount)
217 {
218 goto PackageTooSmall;
219 }
220
221 /* Variable number of sub-objects */
222
223 for (i = 0; i < Count; i++)
224 {
225 if (i < Package->RetInfo3.Count)
226 {
227 /* These are the required package elements (0, 1, or 2) */
228
229 Status = AcpiNsCheckObjectType (Info, Elements,
230 Package->RetInfo3.ObjectType[i], i);
231 if (ACPI_FAILURE (Status))
232 {
233 return (Status);
234 }
235 }
236 else
237 {
238 /* These are the optional package elements */
239
240 Status = AcpiNsCheckObjectType (Info, Elements,
241 Package->RetInfo3.TailObjectType, i);
242 if (ACPI_FAILURE (Status))
243 {
244 return (Status);
245 }
246 }
247
248 Elements++;
249 }
250 break;
251
252 case ACPI_PTYPE2_REV_FIXED:
253
254 /* First element is the (Integer) revision */
255
256 Status = AcpiNsCheckObjectType (
257 Info, Elements, ACPI_RTYPE_INTEGER, 0);
258 if (ACPI_FAILURE (Status))
259 {
260 return (Status);
261 }
262
263 Elements++;
264 Count--;
265
266 /* Examine the subpackages */
267
268 Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
269 break;
270
271 case ACPI_PTYPE2_PKG_COUNT:
272
273 /* First element is the (Integer) count of subpackages to follow */
274
275 Status = AcpiNsCheckObjectType (
276 Info, Elements, ACPI_RTYPE_INTEGER, 0);
277 if (ACPI_FAILURE (Status))
278 {
279 return (Status);
280 }
281
282 /*
283 * Count cannot be larger than the parent package length, but allow it
284 * to be smaller. The >= accounts for the Integer above.
285 */
286 ExpectedCount = (UINT32) (*Elements)->Integer.Value;
287 if (ExpectedCount >= Count)
288 {
289 goto PackageTooSmall;
290 }
291
292 Count = ExpectedCount;
293 Elements++;
294
295 /* Examine the subpackages */
296
297 Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
298 break;
299
300 case ACPI_PTYPE2:
301 case ACPI_PTYPE2_FIXED:
302 case ACPI_PTYPE2_MIN:
303 case ACPI_PTYPE2_COUNT:
304 case ACPI_PTYPE2_FIX_VAR:
305 /*
306 * These types all return a single Package that consists of a
307 * variable number of subpackages.
308 *
309 * First, ensure that the first element is a subpackage. If not,
310 * the BIOS may have incorrectly returned the object as a single
311 * package instead of a Package of Packages (a common error if
312 * there is only one entry). We may be able to repair this by
313 * wrapping the returned Package with a new outer Package.
314 */
315 if (*Elements && ((*Elements)->Common.Type != ACPI_TYPE_PACKAGE))
316 {
317 /* Create the new outer package and populate it */
318
319 Status = AcpiNsWrapWithPackage (
320 Info, ReturnObject, ReturnObjectPtr);
321 if (ACPI_FAILURE (Status))
322 {
323 return (Status);
324 }
325
326 /* Update locals to point to the new package (of 1 element) */
327
328 ReturnObject = *ReturnObjectPtr;
329 Elements = ReturnObject->Package.Elements;
330 Count = 1;
331 }
332
333 /* Examine the subpackages */
334
335 Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
336 break;
337
338 case ACPI_PTYPE2_VAR_VAR:
339 /*
340 * Returns a variable list of packages, each with a variable list
341 * of objects.
342 */
343 break;
344
345 case ACPI_PTYPE2_UUID_PAIR:
346
347 /* The package must contain pairs of (UUID + type) */
348
349 if (Count & 1)
350 {
351 ExpectedCount = Count + 1;
352 goto PackageTooSmall;
353 }
354
355 while (Count > 0)
356 {
357 Status = AcpiNsCheckObjectType(Info, Elements,
358 Package->RetInfo.ObjectType1, 0);
359 if (ACPI_FAILURE(Status))
360 {
361 return (Status);
362 }
363
364 /* Validate length of the UUID buffer */
365
366 if ((*Elements)->Buffer.Length != 16)
367 {
368 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
369 Info->NodeFlags, "Invalid length for UUID Buffer"));
370 return (AE_AML_OPERAND_VALUE);
371 }
372
373 Status = AcpiNsCheckObjectType(Info, Elements + 1,
374 Package->RetInfo.ObjectType2, 0);
375 if (ACPI_FAILURE(Status))
376 {
377 return (Status);
378 }
379
380 Elements += 2;
381 Count -= 2;
382 }
383 break;
384
385 default:
386
387 /* Should not get here if predefined info table is correct */
388
389 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
390 "Invalid internal return type in table entry: %X",
391 Package->RetInfo.Type));
392
393 return (AE_AML_INTERNAL);
394 }
395
396 return (Status);
397
398
399 PackageTooSmall:
400
401 /* Error exit for the case with an incorrect package count */
402
403 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
404 "Return Package is too small - found %u elements, expected %u",
405 Count, ExpectedCount));
406
407 return (AE_AML_OPERAND_VALUE);
408 }
409
410
411 /*******************************************************************************
412 *
413 * FUNCTION: AcpiNsCheckPackageList
414 *
415 * PARAMETERS: Info - Method execution information block
416 * Package - Pointer to package-specific info for method
417 * Elements - Element list of parent package. All elements
418 * of this list should be of type Package.
419 * Count - Count of subpackages
420 *
421 * RETURN: Status
422 *
423 * DESCRIPTION: Examine a list of subpackages
424 *
425 ******************************************************************************/
426
427 static ACPI_STATUS
428 AcpiNsCheckPackageList (
429 ACPI_EVALUATE_INFO *Info,
430 const ACPI_PREDEFINED_INFO *Package,
431 ACPI_OPERAND_OBJECT **Elements,
432 UINT32 Count)
433 {
434 ACPI_OPERAND_OBJECT *SubPackage;
435 ACPI_OPERAND_OBJECT **SubElements;
436 ACPI_STATUS Status;
437 UINT32 ExpectedCount;
438 UINT32 i;
439 UINT32 j;
440
441
442 /*
443 * Validate each subpackage in the parent Package
444 *
445 * NOTE: assumes list of subpackages contains no NULL elements.
446 * Any NULL elements should have been removed by earlier call
447 * to AcpiNsRemoveNullElements.
448 */
449 for (i = 0; i < Count; i++)
450 {
451 SubPackage = *Elements;
452 SubElements = SubPackage->Package.Elements;
453 Info->ParentPackage = SubPackage;
454
455 /* Each sub-object must be of type Package */
456
457 Status = AcpiNsCheckObjectType (Info, &SubPackage,
458 ACPI_RTYPE_PACKAGE, i);
459 if (ACPI_FAILURE (Status))
460 {
461 return (Status);
462 }
463
464 /* Examine the different types of expected subpackages */
465
466 Info->ParentPackage = SubPackage;
467 switch (Package->RetInfo.Type)
468 {
469 case ACPI_PTYPE2:
470 case ACPI_PTYPE2_PKG_COUNT:
471 case ACPI_PTYPE2_REV_FIXED:
472
473 /* Each subpackage has a fixed number of elements */
474
475 ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
476 if (SubPackage->Package.Count < ExpectedCount)
477 {
478 goto PackageTooSmall;
479 }
480
481 Status = AcpiNsCheckPackageElements (Info, SubElements,
482 Package->RetInfo.ObjectType1,
483 Package->RetInfo.Count1,
484 Package->RetInfo.ObjectType2,
485 Package->RetInfo.Count2, 0);
486 if (ACPI_FAILURE (Status))
487 {
488 return (Status);
489 }
490 break;
491
492 case ACPI_PTYPE2_FIX_VAR:
493 /*
494 * Each subpackage has a fixed number of elements and an
495 * optional element
496 */
497 ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
498 if (SubPackage->Package.Count < ExpectedCount)
499 {
500 goto PackageTooSmall;
501 }
502
503 Status = AcpiNsCheckPackageElements (Info, SubElements,
504 Package->RetInfo.ObjectType1,
505 Package->RetInfo.Count1,
506 Package->RetInfo.ObjectType2,
507 SubPackage->Package.Count - Package->RetInfo.Count1, 0);
508 if (ACPI_FAILURE (Status))
509 {
510 return (Status);
511 }
512 break;
513
514 case ACPI_PTYPE2_VAR_VAR:
515 /*
516 * Each subpackage has a fixed or variable number of elements
517 */
518 break;
519
520 case ACPI_PTYPE2_FIXED:
521
522 /* Each subpackage has a fixed length */
523
524 ExpectedCount = Package->RetInfo2.Count;
525 if (SubPackage->Package.Count < ExpectedCount)
526 {
527 goto PackageTooSmall;
528 }
529
530 /* Check the type of each subpackage element */
531
532 for (j = 0; j < ExpectedCount; j++)
533 {
534 Status = AcpiNsCheckObjectType (Info, &SubElements[j],
535 Package->RetInfo2.ObjectType[j], j);
536 if (ACPI_FAILURE (Status))
537 {
538 return (Status);
539 }
540 }
541 break;
542
543 case ACPI_PTYPE2_MIN:
544
545 /* Each subpackage has a variable but minimum length */
546
547 ExpectedCount = Package->RetInfo.Count1;
548 if (SubPackage->Package.Count < ExpectedCount)
549 {
550 goto PackageTooSmall;
551 }
552
553 /* Check the type of each subpackage element */
554
555 Status = AcpiNsCheckPackageElements (Info, SubElements,
556 Package->RetInfo.ObjectType1,
557 SubPackage->Package.Count, 0, 0, 0);
558 if (ACPI_FAILURE (Status))
559 {
560 return (Status);
561 }
562 break;
563
564 case ACPI_PTYPE2_COUNT:
565 /*
566 * First element is the (Integer) count of elements, including
567 * the count field (the ACPI name is NumElements)
568 */
569 Status = AcpiNsCheckObjectType (Info, SubElements,
570 ACPI_RTYPE_INTEGER, 0);
571 if (ACPI_FAILURE (Status))
572 {
573 return (Status);
574 }
575
576 /*
577 * Make sure package is large enough for the Count and is
578 * is as large as the minimum size
579 */
580 ExpectedCount = (UINT32) (*SubElements)->Integer.Value;
581 if (SubPackage->Package.Count < ExpectedCount)
582 {
583 goto PackageTooSmall;
584 }
585
586 if (SubPackage->Package.Count < Package->RetInfo.Count1)
587 {
588 ExpectedCount = Package->RetInfo.Count1;
589 goto PackageTooSmall;
590 }
591
592 if (ExpectedCount == 0)
593 {
594 /*
595 * Either the NumEntries element was originally zero or it was
596 * a NULL element and repaired to an Integer of value zero.
597 * In either case, repair it by setting NumEntries to be the
598 * actual size of the subpackage.
599 */
600 ExpectedCount = SubPackage->Package.Count;
601 (*SubElements)->Integer.Value = ExpectedCount;
602 }
603
604 /* Check the type of each subpackage element */
605
606 Status = AcpiNsCheckPackageElements (Info, (SubElements + 1),
607 Package->RetInfo.ObjectType1,
608 (ExpectedCount - 1), 0, 0, 1);
609 if (ACPI_FAILURE (Status))
610 {
611 return (Status);
612 }
613 break;
614
615 default: /* Should not get here, type was validated by caller */
616
617 return (AE_AML_INTERNAL);
618 }
619
620 Elements++;
621 }
622
623 return (AE_OK);
624
625
626 PackageTooSmall:
627
628 /* The subpackage count was smaller than required */
629
630 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
631 "Return SubPackage[%u] is too small - found %u elements, expected %u",
632 i, SubPackage->Package.Count, ExpectedCount));
633
634 return (AE_AML_OPERAND_VALUE);
635 }
636
637
638 /*******************************************************************************
639 *
640 * FUNCTION: AcpiNsCustomPackage
641 *
642 * PARAMETERS: Info - Method execution information block
643 * Elements - Pointer to the package elements array
644 * Count - Element count for the package
645 *
646 * RETURN: Status
647 *
648 * DESCRIPTION: Check a returned package object for the correct count and
649 * correct type of all sub-objects.
650 *
651 * NOTE: Currently used for the _BIX method only. When needed for two or more
652 * methods, probably a detect/dispatch mechanism will be required.
653 *
654 ******************************************************************************/
655
656 static ACPI_STATUS
657 AcpiNsCustomPackage (
658 ACPI_EVALUATE_INFO *Info,
659 ACPI_OPERAND_OBJECT **Elements,
660 UINT32 Count)
661 {
662 UINT32 ExpectedCount;
663 UINT32 Version;
664 ACPI_STATUS Status = AE_OK;
665
666
667 ACPI_FUNCTION_NAME (NsCustomPackage);
668
669
670 /* Get version number, must be Integer */
671
672 if ((*Elements)->Common.Type != ACPI_TYPE_INTEGER)
673 {
674 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
675 "Return Package has invalid object type for version number"));
676 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
677 }
678
679 Version = (UINT32) (*Elements)->Integer.Value;
680 ExpectedCount = 21; /* Version 1 */
681
682 if (Version == 0)
683 {
684 ExpectedCount = 20; /* Version 0 */
685 }
686
687 if (Count < ExpectedCount)
688 {
689 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
690 "Return Package is too small - found %u elements, expected %u",
691 Count, ExpectedCount));
692 return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
693 }
694 else if (Count > ExpectedCount)
695 {
696 ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
697 "%s: Return Package is larger than needed - "
698 "found %u, expected %u\n",
699 Info->FullPathname, Count, ExpectedCount));
700 }
701
702 /* Validate all elements of the returned package */
703
704 Status = AcpiNsCheckPackageElements (Info, Elements,
705 ACPI_RTYPE_INTEGER, 16,
706 ACPI_RTYPE_STRING, 4, 0);
707 if (ACPI_FAILURE (Status))
708 {
709 return_ACPI_STATUS (Status);
710 }
711
712 /* Version 1 has a single trailing integer */
713
714 if (Version > 0)
715 {
716 Status = AcpiNsCheckPackageElements (Info, Elements + 20,
717 ACPI_RTYPE_INTEGER, 1, 0, 0, 20);
718 }
719
720 return_ACPI_STATUS (Status);
721 }
722
723
724 /*******************************************************************************
725 *
726 * FUNCTION: AcpiNsCheckPackageElements
727 *
728 * PARAMETERS: Info - Method execution information block
729 * Elements - Pointer to the package elements array
730 * Type1 - Object type for first group
731 * Count1 - Count for first group
732 * Type2 - Object type for second group
733 * Count2 - Count for second group
734 * StartIndex - Start of the first group of elements
735 *
736 * RETURN: Status
737 *
738 * DESCRIPTION: Check that all elements of a package are of the correct object
739 * type. Supports up to two groups of different object types.
740 *
741 ******************************************************************************/
742
743 static ACPI_STATUS
744 AcpiNsCheckPackageElements (
745 ACPI_EVALUATE_INFO *Info,
746 ACPI_OPERAND_OBJECT **Elements,
747 UINT8 Type1,
748 UINT32 Count1,
749 UINT8 Type2,
750 UINT32 Count2,
751 UINT32 StartIndex)
752 {
753 ACPI_OPERAND_OBJECT **ThisElement = Elements;
754 ACPI_STATUS Status;
755 UINT32 i;
756
757
758 /*
759 * Up to two groups of package elements are supported by the data
760 * structure. All elements in each group must be of the same type.
761 * The second group can have a count of zero.
762 */
763 for (i = 0; i < Count1; i++)
764 {
765 Status = AcpiNsCheckObjectType (Info, ThisElement,
766 Type1, i + StartIndex);
767 if (ACPI_FAILURE (Status))
768 {
769 return (Status);
770 }
771
772 ThisElement++;
773 }
774
775 for (i = 0; i < Count2; i++)
776 {
777 Status = AcpiNsCheckObjectType (Info, ThisElement,
778 Type2, (i + Count1 + StartIndex));
779 if (ACPI_FAILURE (Status))
780 {
781 return (Status);
782 }
783
784 ThisElement++;
785 }
786
787 return (AE_OK);
788 }