2 /******************************************************************************
4 * Module Name: aslrestype2d - Large DWord address resource descriptors
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include "aslcompiler.y.h"
49 #define _COMPONENT ACPI_COMPILER
50 ACPI_MODULE_NAME ("aslrestype2d")
53 * This module contains the Dword (32-bit) address space descriptors:
60 /*******************************************************************************
62 * FUNCTION: RsDoDwordIoDescriptor
64 * PARAMETERS: Op - Parent resource descriptor parse node
65 * CurrentByteOffset - Offset into the resource template AML
66 * buffer (to track references to the desc)
68 * RETURN: Completed resource node
70 * DESCRIPTION: Construct a long "DwordIO" descriptor
72 ******************************************************************************/
75 RsDoDwordIoDescriptor (
76 ACPI_PARSE_OBJECT *Op,
77 UINT32 CurrentByteOffset)
79 AML_RESOURCE *Descriptor;
80 ACPI_PARSE_OBJECT *InitializerOp;
81 ACPI_PARSE_OBJECT *MinOp = NULL;
82 ACPI_PARSE_OBJECT *MaxOp = NULL;
83 ACPI_PARSE_OBJECT *LengthOp = NULL;
84 ACPI_PARSE_OBJECT *GranOp = NULL;
85 ASL_RESOURCE_NODE *Rnode;
86 UINT16 StringLength = 0;
87 UINT32 OptionIndex = 0;
88 UINT8 *OptionalFields;
90 BOOLEAN ResSourceIndex = FALSE;
93 InitializerOp = Op->Asl.Child;
94 StringLength = RsGetStringDataLength (InitializerOp);
96 Rnode = RsAllocateResourceNode (
97 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
99 Descriptor = Rnode->Buffer;
100 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
101 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
104 * Initial descriptor length -- may be enlarged if there are
105 * optional fields present
107 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
108 Descriptor->Address32.ResourceLength = (UINT16)
109 (sizeof (AML_RESOURCE_ADDRESS32) -
110 sizeof (AML_RESOURCE_LARGE_HEADER));
112 /* Process all child initialization nodes */
114 for (i = 0; InitializerOp; i++)
118 case 0: /* Resource Usage */
120 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
123 case 1: /* MinType */
125 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
126 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
127 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
130 case 2: /* MaxType */
132 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
133 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
134 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
137 case 3: /* DecodeType */
139 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
140 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
141 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
144 case 4: /* Range Type */
146 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
147 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
148 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
151 case 5: /* Address Granularity */
153 Descriptor->Address32.Granularity =
154 (UINT32) InitializerOp->Asl.Value.Integer;
155 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
156 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
157 GranOp = InitializerOp;
160 case 6: /* Address Min */
162 Descriptor->Address32.Minimum =
163 (UINT32) InitializerOp->Asl.Value.Integer;
164 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
165 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
166 MinOp = InitializerOp;
169 case 7: /* Address Max */
171 Descriptor->Address32.Maximum =
172 (UINT32) InitializerOp->Asl.Value.Integer;
173 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
174 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
175 MaxOp = InitializerOp;
178 case 8: /* Translation Offset */
180 Descriptor->Address32.TranslationOffset =
181 (UINT32) InitializerOp->Asl.Value.Integer;
182 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
183 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
186 case 9: /* Address Length */
188 Descriptor->Address32.AddressLength =
189 (UINT32) InitializerOp->Asl.Value.Integer;
190 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
191 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
192 LengthOp = InitializerOp;
195 case 10: /* ResSourceIndex [Optional Field - BYTE] */
197 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
199 /* Found a valid ResourceSourceIndex */
201 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
203 Descriptor->Address32.ResourceLength++;
204 ResSourceIndex = TRUE;
208 case 11: /* ResSource [Optional Field - STRING] */
210 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
211 (InitializerOp->Asl.Value.String))
215 /* Found a valid ResourceSource */
217 Descriptor->Address32.ResourceLength = (UINT16)
218 (Descriptor->Address32.ResourceLength + StringLength);
221 &OptionalFields[OptionIndex],
222 InitializerOp->Asl.Value.String);
224 /* ResourceSourceIndex must also be valid */
228 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
229 InitializerOp, NULL);
236 * Not a valid ResourceSource, ResourceSourceIndex must also
239 else if (ResSourceIndex)
241 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
242 InitializerOp, NULL);
247 case 12: /* ResourceTag */
249 UtAttachNamepathToOwner (Op, InitializerOp);
254 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
255 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
256 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
259 case 14: /* Translation Type */
261 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
262 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
263 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
268 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
272 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
275 /* Validate the Min/Max/Len/Gran values */
277 RsLargeAddressCheck (
278 (UINT64) Descriptor->Address32.Minimum,
279 (UINT64) Descriptor->Address32.Maximum,
280 (UINT64) Descriptor->Address32.AddressLength,
281 (UINT64) Descriptor->Address32.Granularity,
282 Descriptor->Address32.Flags,
283 MinOp, MaxOp, LengthOp, GranOp, Op);
285 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
286 OptionIndex + StringLength;
291 /*******************************************************************************
293 * FUNCTION: RsDoDwordMemoryDescriptor
295 * PARAMETERS: Op - Parent resource descriptor parse node
296 * CurrentByteOffset - Offset into the resource template AML
297 * buffer (to track references to the desc)
299 * RETURN: Completed resource node
301 * DESCRIPTION: Construct a long "DwordMemory" descriptor
303 ******************************************************************************/
306 RsDoDwordMemoryDescriptor (
307 ACPI_PARSE_OBJECT *Op,
308 UINT32 CurrentByteOffset)
310 AML_RESOURCE *Descriptor;
311 ACPI_PARSE_OBJECT *InitializerOp;
312 ACPI_PARSE_OBJECT *MinOp = NULL;
313 ACPI_PARSE_OBJECT *MaxOp = NULL;
314 ACPI_PARSE_OBJECT *LengthOp = NULL;
315 ACPI_PARSE_OBJECT *GranOp = NULL;
316 ASL_RESOURCE_NODE *Rnode;
317 UINT8 *OptionalFields;
318 UINT16 StringLength = 0;
319 UINT32 OptionIndex = 0;
321 BOOLEAN ResSourceIndex = FALSE;
324 InitializerOp = Op->Asl.Child;
325 StringLength = RsGetStringDataLength (InitializerOp);
327 Rnode = RsAllocateResourceNode (
328 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
330 Descriptor = Rnode->Buffer;
331 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
332 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
335 * Initial descriptor length -- may be enlarged if there are
336 * optional fields present
338 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
339 Descriptor->Address32.ResourceLength = (UINT16)
340 (sizeof (AML_RESOURCE_ADDRESS32) -
341 sizeof (AML_RESOURCE_LARGE_HEADER));
344 /* Process all child initialization nodes */
346 for (i = 0; InitializerOp; i++)
350 case 0: /* Resource Usage */
352 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
355 case 1: /* DecodeType */
357 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
358 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
359 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
362 case 2: /* MinType */
364 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
365 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
366 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
369 case 3: /* MaxType */
371 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
372 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
373 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
376 case 4: /* Memory Type */
378 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
379 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
380 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1);
383 case 5: /* Read/Write Type */
385 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
386 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
387 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
390 case 6: /* Address Granularity */
392 Descriptor->Address32.Granularity =
393 (UINT32) InitializerOp->Asl.Value.Integer;
394 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
395 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
396 GranOp = InitializerOp;
399 case 7: /* Min Address */
401 Descriptor->Address32.Minimum =
402 (UINT32) InitializerOp->Asl.Value.Integer;
403 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
404 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
405 MinOp = InitializerOp;
408 case 8: /* Max Address */
410 Descriptor->Address32.Maximum =
411 (UINT32) InitializerOp->Asl.Value.Integer;
412 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
413 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
414 MaxOp = InitializerOp;
417 case 9: /* Translation Offset */
419 Descriptor->Address32.TranslationOffset =
420 (UINT32) InitializerOp->Asl.Value.Integer;
421 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
422 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
425 case 10: /* Address Length */
427 Descriptor->Address32.AddressLength =
428 (UINT32) InitializerOp->Asl.Value.Integer;
429 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
430 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
431 LengthOp = InitializerOp;
434 case 11: /* ResSourceIndex [Optional Field - BYTE] */
436 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
438 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
440 Descriptor->Address32.ResourceLength++;
441 ResSourceIndex = TRUE;
445 case 12: /* ResSource [Optional Field - STRING] */
447 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
448 (InitializerOp->Asl.Value.String))
452 Descriptor->Address32.ResourceLength = (UINT16)
453 (Descriptor->Address32.ResourceLength + StringLength);
456 &OptionalFields[OptionIndex],
457 InitializerOp->Asl.Value.String);
459 /* ResourceSourceIndex must also be valid */
463 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
464 InitializerOp, NULL);
471 * Not a valid ResourceSource, ResourceSourceIndex must also
474 else if (ResSourceIndex)
476 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
477 InitializerOp, NULL);
482 case 13: /* ResourceTag */
484 UtAttachNamepathToOwner (Op, InitializerOp);
488 case 14: /* Address Range */
490 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
491 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
492 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3);
497 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
498 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
499 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
504 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
508 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
511 /* Validate the Min/Max/Len/Gran values */
513 RsLargeAddressCheck (
514 (UINT64) Descriptor->Address32.Minimum,
515 (UINT64) Descriptor->Address32.Maximum,
516 (UINT64) Descriptor->Address32.AddressLength,
517 (UINT64) Descriptor->Address32.Granularity,
518 Descriptor->Address32.Flags,
519 MinOp, MaxOp, LengthOp, GranOp, Op);
521 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
522 OptionIndex + StringLength;
527 /*******************************************************************************
529 * FUNCTION: RsDoDwordSpaceDescriptor
531 * PARAMETERS: Op - Parent resource descriptor parse node
532 * CurrentByteOffset - Offset into the resource template AML
533 * buffer (to track references to the desc)
535 * RETURN: Completed resource node
537 * DESCRIPTION: Construct a long "DwordSpace" descriptor
539 ******************************************************************************/
542 RsDoDwordSpaceDescriptor (
543 ACPI_PARSE_OBJECT *Op,
544 UINT32 CurrentByteOffset)
546 AML_RESOURCE *Descriptor;
547 ACPI_PARSE_OBJECT *InitializerOp;
548 ACPI_PARSE_OBJECT *MinOp = NULL;
549 ACPI_PARSE_OBJECT *MaxOp = NULL;
550 ACPI_PARSE_OBJECT *LengthOp = NULL;
551 ACPI_PARSE_OBJECT *GranOp = NULL;
552 ASL_RESOURCE_NODE *Rnode;
553 UINT8 *OptionalFields;
554 UINT16 StringLength = 0;
555 UINT32 OptionIndex = 0;
557 BOOLEAN ResSourceIndex = FALSE;
560 InitializerOp = Op->Asl.Child;
561 StringLength = RsGetStringDataLength (InitializerOp);
563 Rnode = RsAllocateResourceNode (
564 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
566 Descriptor = Rnode->Buffer;
567 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
570 * Initial descriptor length -- may be enlarged if there are
571 * optional fields present
573 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
574 Descriptor->Address32.ResourceLength = (UINT16)
575 (sizeof (AML_RESOURCE_ADDRESS32) -
576 sizeof (AML_RESOURCE_LARGE_HEADER));
578 /* Process all child initialization nodes */
580 for (i = 0; InitializerOp; i++)
584 case 0: /* Resource Type */
586 Descriptor->Address32.ResourceType =
587 (UINT8) InitializerOp->Asl.Value.Integer;
590 case 1: /* Resource Usage */
592 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
595 case 2: /* DecodeType */
597 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
598 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
599 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
602 case 3: /* MinType */
604 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
605 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
606 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
609 case 4: /* MaxType */
611 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
612 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
613 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
616 case 5: /* Type-Specific flags */
618 Descriptor->Address32.SpecificFlags =
619 (UINT8) InitializerOp->Asl.Value.Integer;
622 case 6: /* Address Granularity */
624 Descriptor->Address32.Granularity =
625 (UINT32) InitializerOp->Asl.Value.Integer;
626 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
627 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
628 GranOp = InitializerOp;
631 case 7: /* Min Address */
633 Descriptor->Address32.Minimum =
634 (UINT32) InitializerOp->Asl.Value.Integer;
635 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
636 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
637 MinOp = InitializerOp;
640 case 8: /* Max Address */
642 Descriptor->Address32.Maximum =
643 (UINT32) InitializerOp->Asl.Value.Integer;
644 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
645 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
646 MaxOp = InitializerOp;
649 case 9: /* Translation Offset */
651 Descriptor->Address32.TranslationOffset =
652 (UINT32) InitializerOp->Asl.Value.Integer;
653 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
654 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
657 case 10: /* Address Length */
659 Descriptor->Address32.AddressLength =
660 (UINT32) InitializerOp->Asl.Value.Integer;
661 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
662 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
663 LengthOp = InitializerOp;
666 case 11: /* ResSourceIndex [Optional Field - BYTE] */
668 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
670 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
672 Descriptor->Address32.ResourceLength++;
673 ResSourceIndex = TRUE;
677 case 12: /* ResSource [Optional Field - STRING] */
679 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
680 (InitializerOp->Asl.Value.String))
684 Descriptor->Address32.ResourceLength = (UINT16)
685 (Descriptor->Address32.ResourceLength + StringLength);
688 &OptionalFields[OptionIndex],
689 InitializerOp->Asl.Value.String);
691 /* ResourceSourceIndex must also be valid */
695 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
696 InitializerOp, NULL);
703 * Not a valid ResourceSource, ResourceSourceIndex must also
706 else if (ResSourceIndex)
708 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
709 InitializerOp, NULL);
714 case 13: /* ResourceTag */
716 UtAttachNamepathToOwner (Op, InitializerOp);
721 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST,
722 InitializerOp, NULL);
726 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
729 /* Validate the Min/Max/Len/Gran values */
731 RsLargeAddressCheck (
732 (UINT64) Descriptor->Address32.Minimum,
733 (UINT64) Descriptor->Address32.Maximum,
734 (UINT64) Descriptor->Address32.AddressLength,
735 (UINT64) Descriptor->Address32.Granularity,
736 Descriptor->Address32.Flags,
737 MinOp, MaxOp, LengthOp, GranOp, Op);
739 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
740 OptionIndex + StringLength;