1 /******************************************************************************
3 * Module Name: aslrestype2d - Large DWord address resource descriptors
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
45 #include "aslcompiler.y.h"
47 #define _COMPONENT ACPI_COMPILER
48 ACPI_MODULE_NAME ("aslrestype2d")
51 * This module contains the Dword (32-bit) address space descriptors:
58 /*******************************************************************************
60 * FUNCTION: RsDoDwordIoDescriptor
62 * PARAMETERS: Info - Parse Op and resource template offset
64 * RETURN: Completed resource node
66 * DESCRIPTION: Construct a long "DwordIO" descriptor
68 ******************************************************************************/
71 RsDoDwordIoDescriptor (
72 ASL_RESOURCE_INFO *Info)
74 AML_RESOURCE *Descriptor;
75 ACPI_PARSE_OBJECT *InitializerOp;
76 ACPI_PARSE_OBJECT *MinOp = NULL;
77 ACPI_PARSE_OBJECT *MaxOp = NULL;
78 ACPI_PARSE_OBJECT *LengthOp = NULL;
79 ACPI_PARSE_OBJECT *GranOp = NULL;
80 ASL_RESOURCE_NODE *Rnode;
81 UINT16 StringLength = 0;
82 UINT32 OptionIndex = 0;
83 UINT8 *OptionalFields;
84 UINT32 CurrentByteOffset;
86 BOOLEAN ResSourceIndex = FALSE;
89 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
90 StringLength = RsGetStringDataLength (InitializerOp);
91 CurrentByteOffset = Info->CurrentByteOffset;
93 Rnode = RsAllocateResourceNode (
94 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
96 Descriptor = Rnode->Buffer;
97 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
98 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
101 * Initial descriptor length -- may be enlarged if there are
102 * optional fields present
104 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
105 Descriptor->Address32.ResourceLength = (UINT16)
106 (sizeof (AML_RESOURCE_ADDRESS32) -
107 sizeof (AML_RESOURCE_LARGE_HEADER));
109 /* Process all child initialization nodes */
111 for (i = 0; InitializerOp; i++)
115 case 0: /* Resource Usage */
117 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
120 case 1: /* MinType */
122 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
124 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
127 case 2: /* MaxType */
129 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
130 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
131 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
134 case 3: /* DecodeType */
136 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
137 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
138 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
141 case 4: /* Range Type */
143 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
144 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
145 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0, 2);
148 case 5: /* Address Granularity */
150 Descriptor->Address32.Granularity =
151 (UINT32) InitializerOp->Asl.Value.Integer;
152 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
153 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
154 GranOp = InitializerOp;
157 case 6: /* Address Min */
159 Descriptor->Address32.Minimum =
160 (UINT32) InitializerOp->Asl.Value.Integer;
161 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
162 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
163 MinOp = InitializerOp;
166 case 7: /* Address Max */
168 Descriptor->Address32.Maximum =
169 (UINT32) InitializerOp->Asl.Value.Integer;
170 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
171 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
172 MaxOp = InitializerOp;
175 case 8: /* Translation Offset */
177 Descriptor->Address32.TranslationOffset =
178 (UINT32) InitializerOp->Asl.Value.Integer;
179 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
180 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
183 case 9: /* Address Length */
185 Descriptor->Address32.AddressLength =
186 (UINT32) InitializerOp->Asl.Value.Integer;
187 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
188 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
189 LengthOp = InitializerOp;
192 case 10: /* ResSourceIndex [Optional Field - BYTE] */
194 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
196 /* Found a valid ResourceSourceIndex */
198 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
200 Descriptor->Address32.ResourceLength++;
201 ResSourceIndex = TRUE;
205 case 11: /* ResSource [Optional Field - STRING] */
207 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
208 (InitializerOp->Asl.Value.String))
212 /* Found a valid ResourceSource */
214 Descriptor->Address32.ResourceLength = (UINT16)
215 (Descriptor->Address32.ResourceLength + StringLength);
218 &OptionalFields[OptionIndex],
219 InitializerOp->Asl.Value.String);
221 /* ResourceSourceIndex must also be valid */
225 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
226 InitializerOp, NULL);
233 * Not a valid ResourceSource, ResourceSourceIndex must also
236 else if (ResSourceIndex)
238 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
239 InitializerOp, NULL);
244 case 12: /* ResourceTag */
246 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
251 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
252 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
253 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
256 case 14: /* Translation Type */
258 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
259 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
260 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
265 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
269 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
272 /* Validate the Min/Max/Len/Gran values */
274 RsLargeAddressCheck (
275 (UINT64) Descriptor->Address32.Minimum,
276 (UINT64) Descriptor->Address32.Maximum,
277 (UINT64) Descriptor->Address32.AddressLength,
278 (UINT64) Descriptor->Address32.Granularity,
279 Descriptor->Address32.Flags,
280 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
282 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
283 OptionIndex + StringLength;
288 /*******************************************************************************
290 * FUNCTION: RsDoDwordMemoryDescriptor
292 * PARAMETERS: Info - Parse Op and resource template offset
294 * RETURN: Completed resource node
296 * DESCRIPTION: Construct a long "DwordMemory" descriptor
298 ******************************************************************************/
301 RsDoDwordMemoryDescriptor (
302 ASL_RESOURCE_INFO *Info)
304 AML_RESOURCE *Descriptor;
305 ACPI_PARSE_OBJECT *InitializerOp;
306 ACPI_PARSE_OBJECT *MinOp = NULL;
307 ACPI_PARSE_OBJECT *MaxOp = NULL;
308 ACPI_PARSE_OBJECT *LengthOp = NULL;
309 ACPI_PARSE_OBJECT *GranOp = NULL;
310 ASL_RESOURCE_NODE *Rnode;
311 UINT8 *OptionalFields;
312 UINT16 StringLength = 0;
313 UINT32 OptionIndex = 0;
314 UINT32 CurrentByteOffset;
316 BOOLEAN ResSourceIndex = FALSE;
319 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
320 StringLength = RsGetStringDataLength (InitializerOp);
321 CurrentByteOffset = Info->CurrentByteOffset;
323 Rnode = RsAllocateResourceNode (
324 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
326 Descriptor = Rnode->Buffer;
327 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
328 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
331 * Initial descriptor length -- may be enlarged if there are
332 * optional fields present
334 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
335 Descriptor->Address32.ResourceLength = (UINT16)
336 (sizeof (AML_RESOURCE_ADDRESS32) -
337 sizeof (AML_RESOURCE_LARGE_HEADER));
340 /* Process all child initialization nodes */
342 for (i = 0; InitializerOp; i++)
346 case 0: /* Resource Usage */
348 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
351 case 1: /* DecodeType */
353 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
354 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
355 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
358 case 2: /* MinType */
360 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
361 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
362 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
365 case 3: /* MaxType */
367 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
368 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
369 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
372 case 4: /* Memory Type */
374 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
375 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
376 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1, 2);
379 case 5: /* Read/Write Type */
381 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
382 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
383 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
386 case 6: /* Address Granularity */
388 Descriptor->Address32.Granularity =
389 (UINT32) InitializerOp->Asl.Value.Integer;
390 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
391 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
392 GranOp = InitializerOp;
395 case 7: /* Min Address */
397 Descriptor->Address32.Minimum =
398 (UINT32) InitializerOp->Asl.Value.Integer;
399 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
400 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
401 MinOp = InitializerOp;
404 case 8: /* Max Address */
406 Descriptor->Address32.Maximum =
407 (UINT32) InitializerOp->Asl.Value.Integer;
408 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
409 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
410 MaxOp = InitializerOp;
413 case 9: /* Translation Offset */
415 Descriptor->Address32.TranslationOffset =
416 (UINT32) InitializerOp->Asl.Value.Integer;
417 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
418 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
421 case 10: /* Address Length */
423 Descriptor->Address32.AddressLength =
424 (UINT32) InitializerOp->Asl.Value.Integer;
425 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
426 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
427 LengthOp = InitializerOp;
430 case 11: /* ResSourceIndex [Optional Field - BYTE] */
432 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
434 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
436 Descriptor->Address32.ResourceLength++;
437 ResSourceIndex = TRUE;
441 case 12: /* ResSource [Optional Field - STRING] */
443 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
444 (InitializerOp->Asl.Value.String))
448 Descriptor->Address32.ResourceLength = (UINT16)
449 (Descriptor->Address32.ResourceLength + StringLength);
452 &OptionalFields[OptionIndex],
453 InitializerOp->Asl.Value.String);
455 /* ResourceSourceIndex must also be valid */
459 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
460 InitializerOp, NULL);
467 * Not a valid ResourceSource, ResourceSourceIndex must also
470 else if (ResSourceIndex)
472 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
473 InitializerOp, NULL);
478 case 13: /* ResourceTag */
480 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
484 case 14: /* Address Range */
486 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
487 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
488 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3, 2);
493 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
494 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
495 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
500 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
504 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
507 /* Validate the Min/Max/Len/Gran values */
509 RsLargeAddressCheck (
510 (UINT64) Descriptor->Address32.Minimum,
511 (UINT64) Descriptor->Address32.Maximum,
512 (UINT64) Descriptor->Address32.AddressLength,
513 (UINT64) Descriptor->Address32.Granularity,
514 Descriptor->Address32.Flags,
515 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
517 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
518 OptionIndex + StringLength;
523 /*******************************************************************************
525 * FUNCTION: RsDoDwordSpaceDescriptor
527 * PARAMETERS: Info - Parse Op and resource template offset
529 * RETURN: Completed resource node
531 * DESCRIPTION: Construct a long "DwordSpace" descriptor
533 ******************************************************************************/
536 RsDoDwordSpaceDescriptor (
537 ASL_RESOURCE_INFO *Info)
539 AML_RESOURCE *Descriptor;
540 ACPI_PARSE_OBJECT *InitializerOp;
541 ACPI_PARSE_OBJECT *MinOp = NULL;
542 ACPI_PARSE_OBJECT *MaxOp = NULL;
543 ACPI_PARSE_OBJECT *LengthOp = NULL;
544 ACPI_PARSE_OBJECT *GranOp = NULL;
545 ASL_RESOURCE_NODE *Rnode;
546 UINT8 *OptionalFields;
547 UINT16 StringLength = 0;
548 UINT32 OptionIndex = 0;
549 UINT32 CurrentByteOffset;
551 BOOLEAN ResSourceIndex = FALSE;
554 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
555 StringLength = RsGetStringDataLength (InitializerOp);
556 CurrentByteOffset = Info->CurrentByteOffset;
558 Rnode = RsAllocateResourceNode (
559 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
561 Descriptor = Rnode->Buffer;
562 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
565 * Initial descriptor length -- may be enlarged if there are
566 * optional fields present
568 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
569 Descriptor->Address32.ResourceLength = (UINT16)
570 (sizeof (AML_RESOURCE_ADDRESS32) -
571 sizeof (AML_RESOURCE_LARGE_HEADER));
573 /* Process all child initialization nodes */
575 for (i = 0; InitializerOp; i++)
579 case 0: /* Resource Type */
581 Descriptor->Address32.ResourceType =
582 (UINT8) InitializerOp->Asl.Value.Integer;
585 case 1: /* Resource Usage */
587 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
590 case 2: /* DecodeType */
592 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
593 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
594 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
597 case 3: /* MinType */
599 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
600 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
601 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
604 case 4: /* MaxType */
606 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
607 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
608 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
611 case 5: /* Type-Specific flags */
613 Descriptor->Address32.SpecificFlags =
614 (UINT8) InitializerOp->Asl.Value.Integer;
617 case 6: /* Address Granularity */
619 Descriptor->Address32.Granularity =
620 (UINT32) InitializerOp->Asl.Value.Integer;
621 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
622 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
623 GranOp = InitializerOp;
626 case 7: /* Min Address */
628 Descriptor->Address32.Minimum =
629 (UINT32) InitializerOp->Asl.Value.Integer;
630 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
631 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
632 MinOp = InitializerOp;
635 case 8: /* Max Address */
637 Descriptor->Address32.Maximum =
638 (UINT32) InitializerOp->Asl.Value.Integer;
639 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
640 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
641 MaxOp = InitializerOp;
644 case 9: /* Translation Offset */
646 Descriptor->Address32.TranslationOffset =
647 (UINT32) InitializerOp->Asl.Value.Integer;
648 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
649 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
652 case 10: /* Address Length */
654 Descriptor->Address32.AddressLength =
655 (UINT32) InitializerOp->Asl.Value.Integer;
656 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
657 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
658 LengthOp = InitializerOp;
661 case 11: /* ResSourceIndex [Optional Field - BYTE] */
663 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
665 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
667 Descriptor->Address32.ResourceLength++;
668 ResSourceIndex = TRUE;
672 case 12: /* ResSource [Optional Field - STRING] */
674 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
675 (InitializerOp->Asl.Value.String))
679 Descriptor->Address32.ResourceLength = (UINT16)
680 (Descriptor->Address32.ResourceLength + StringLength);
683 &OptionalFields[OptionIndex],
684 InitializerOp->Asl.Value.String);
686 /* ResourceSourceIndex must also be valid */
690 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
691 InitializerOp, NULL);
698 * Not a valid ResourceSource, ResourceSourceIndex must also
701 else if (ResSourceIndex)
703 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
704 InitializerOp, NULL);
709 case 13: /* ResourceTag */
711 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
716 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST,
717 InitializerOp, NULL);
721 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
724 /* Validate the Min/Max/Len/Gran values */
726 RsLargeAddressCheck (
727 (UINT64) Descriptor->Address32.Minimum,
728 (UINT64) Descriptor->Address32.Maximum,
729 (UINT64) Descriptor->Address32.AddressLength,
730 (UINT64) Descriptor->Address32.Granularity,
731 Descriptor->Address32.Flags,
732 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
734 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
735 OptionIndex + StringLength;