1
2/******************************************************************************
3 *
4 * Module Name: aslrestype2d - Large DWord address resource descriptors
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
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.
26 *
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.
30 *
31 * NO WARRANTY
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.
43 */
44
45
46#include "aslcompiler.h"
47#include "aslcompiler.y.h"
48
49#define _COMPONENT          ACPI_COMPILER
50        ACPI_MODULE_NAME    ("aslrestype2d")
51
52/*
53 * This module contains the Dword (32-bit) address space descriptors:
54 *
55 * DwordIO
56 * DwordMemory
57 * DwordSpace
58 */
59
60/*******************************************************************************
61 *
62 * FUNCTION:    RsDoDwordIoDescriptor
63 *
64 * PARAMETERS:  Op                  - Parent resource descriptor parse node
65 *              CurrentByteOffset   - Offset into the resource template AML
66 *                                    buffer (to track references to the desc)
67 *
68 * RETURN:      Completed resource node
69 *
70 * DESCRIPTION: Construct a long "DwordIO" descriptor
71 *
72 ******************************************************************************/
73
74ASL_RESOURCE_NODE *
75RsDoDwordIoDescriptor (
76    ACPI_PARSE_OBJECT       *Op,
77    UINT32                  CurrentByteOffset)
78{
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;
89    UINT32                  i;
90    BOOLEAN                 ResSourceIndex = FALSE;
91
92
93    InitializerOp = Op->Asl.Child;
94    StringLength = RsGetStringDataLength (InitializerOp);
95
96    Rnode = RsAllocateResourceNode (
97                sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
98
99    Descriptor = Rnode->Buffer;
100    Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
101    Descriptor->Address32.ResourceType   = ACPI_ADDRESS_TYPE_IO_RANGE;
102
103    /*
104     * Initial descriptor length -- may be enlarged if there are
105     * optional fields present
106     */
107    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
108    Descriptor->Address32.ResourceLength = (UINT16)
109        (sizeof (AML_RESOURCE_ADDRESS32) -
110         sizeof (AML_RESOURCE_LARGE_HEADER));
111
112    /* Process all child initialization nodes */
113
114    for (i = 0; InitializerOp; i++)
115    {
116        switch (i)
117        {
118        case 0: /* Resource Usage */
119
120            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
121            break;
122
123        case 1: /* MinType */
124
125            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
126            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
127                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
128            break;
129
130        case 2: /* MaxType */
131
132            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
133            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
134                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
135            break;
136
137        case 3: /* DecodeType */
138
139            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
140            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
141                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
142            break;
143
144        case 4: /* Range Type */
145
146            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
147            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
148                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
149            break;
150
151        case 5: /* Address Granularity */
152
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;
158            break;
159
160        case 6: /* Address Min */
161
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;
167            break;
168
169        case 7: /* Address Max */
170
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;
176            break;
177
178        case 8: /* Translation Offset */
179
180            Descriptor->Address32.TranslationOffset =
181                (UINT32) InitializerOp->Asl.Value.Integer;
182            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
183                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
184            break;
185
186        case 9: /* Address Length */
187
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;
193            break;
194
195        case 10: /* ResSourceIndex [Optional Field - BYTE] */
196
197            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
198            {
199                /* Found a valid ResourceSourceIndex */
200
201                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
202                OptionIndex++;
203                Descriptor->Address32.ResourceLength++;
204                ResSourceIndex = TRUE;
205            }
206            break;
207
208        case 11: /* ResSource [Optional Field - STRING] */
209
210            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
211                (InitializerOp->Asl.Value.String))
212            {
213                if (StringLength)
214                {
215                    /* Found a valid ResourceSource */
216
217                    Descriptor->Address32.ResourceLength = (UINT16)
218                        (Descriptor->Address32.ResourceLength + StringLength);
219
220                    strcpy ((char *)
221                        &OptionalFields[OptionIndex],
222                        InitializerOp->Asl.Value.String);
223
224                    /* ResourceSourceIndex must also be valid */
225
226                    if (!ResSourceIndex)
227                    {
228                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
229                            InitializerOp, NULL);
230                    }
231                }
232            }
233
234#if 0
235            /*
236             * Not a valid ResourceSource, ResourceSourceIndex must also
237             * be invalid
238             */
239            else if (ResSourceIndex)
240            {
241                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
242                    InitializerOp, NULL);
243            }
244#endif
245            break;
246
247        case 12: /* ResourceTag */
248
249            UtAttachNamepathToOwner (Op, InitializerOp);
250            break;
251
252        case 13: /* Type */
253
254            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
255            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
256                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
257            break;
258
259        case 14: /* Translation Type */
260
261            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
262            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
263                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
264            break;
265
266        default:
267
268            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
269            break;
270        }
271
272        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
273    }
274
275    /* Validate the Min/Max/Len/Gran values */
276
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);
284
285    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
286                            OptionIndex + StringLength;
287    return (Rnode);
288}
289
290
291/*******************************************************************************
292 *
293 * FUNCTION:    RsDoDwordMemoryDescriptor
294 *
295 * PARAMETERS:  Op                  - Parent resource descriptor parse node
296 *              CurrentByteOffset   - Offset into the resource template AML
297 *                                    buffer (to track references to the desc)
298 *
299 * RETURN:      Completed resource node
300 *
301 * DESCRIPTION: Construct a long "DwordMemory" descriptor
302 *
303 ******************************************************************************/
304
305ASL_RESOURCE_NODE *
306RsDoDwordMemoryDescriptor (
307    ACPI_PARSE_OBJECT       *Op,
308    UINT32                  CurrentByteOffset)
309{
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;
320    UINT32                  i;
321    BOOLEAN                 ResSourceIndex = FALSE;
322
323
324    InitializerOp = Op->Asl.Child;
325    StringLength = RsGetStringDataLength (InitializerOp);
326
327    Rnode = RsAllocateResourceNode (
328                sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
329
330    Descriptor = Rnode->Buffer;
331    Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
332    Descriptor->Address32.ResourceType   = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
333
334    /*
335     * Initial descriptor length -- may be enlarged if there are
336     * optional fields present
337     */
338    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
339    Descriptor->Address32.ResourceLength = (UINT16)
340        (sizeof (AML_RESOURCE_ADDRESS32) -
341         sizeof (AML_RESOURCE_LARGE_HEADER));
342
343
344    /* Process all child initialization nodes */
345
346    for (i = 0; InitializerOp; i++)
347    {
348        switch (i)
349        {
350        case 0: /* Resource Usage */
351
352            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
353            break;
354
355        case 1: /* DecodeType */
356
357            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
358            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
359                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
360            break;
361
362        case 2: /* MinType */
363
364            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
365            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
366                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
367            break;
368
369        case 3: /* MaxType */
370
371            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
372            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
373                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
374            break;
375
376        case 4: /* Memory Type */
377
378            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
379            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
380                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1);
381            break;
382
383        case 5: /* Read/Write Type */
384
385            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
386            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
387                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
388            break;
389
390        case 6: /* Address Granularity */
391
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;
397            break;
398
399        case 7: /* Min Address */
400
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;
406            break;
407
408        case 8: /* Max Address */
409
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;
415            break;
416
417        case 9: /* Translation Offset */
418
419            Descriptor->Address32.TranslationOffset =
420                (UINT32) InitializerOp->Asl.Value.Integer;
421            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
422                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
423            break;
424
425        case 10: /* Address Length */
426
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;
432            break;
433
434        case 11: /* ResSourceIndex [Optional Field - BYTE] */
435
436            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
437            {
438                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
439                OptionIndex++;
440                Descriptor->Address32.ResourceLength++;
441                ResSourceIndex = TRUE;
442            }
443            break;
444
445        case 12: /* ResSource [Optional Field - STRING] */
446
447            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
448                (InitializerOp->Asl.Value.String))
449            {
450                if (StringLength)
451                {
452                    Descriptor->Address32.ResourceLength = (UINT16)
453                        (Descriptor->Address32.ResourceLength + StringLength);
454
455                    strcpy ((char *)
456                        &OptionalFields[OptionIndex],
457                        InitializerOp->Asl.Value.String);
458
459                    /* ResourceSourceIndex must also be valid */
460
461                    if (!ResSourceIndex)
462                    {
463                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
464                            InitializerOp, NULL);
465                    }
466                }
467            }
468
469#if 0
470            /*
471             * Not a valid ResourceSource, ResourceSourceIndex must also
472             * be invalid
473             */
474            else if (ResSourceIndex)
475            {
476                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
477                    InitializerOp, NULL);
478            }
479#endif
480            break;
481
482        case 13: /* ResourceTag */
483
484            UtAttachNamepathToOwner (Op, InitializerOp);
485            break;
486
487
488        case 14: /* Address Range */
489
490            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
491            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
492                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3);
493            break;
494
495        case 15: /* Type */
496
497            RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
498            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
499                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
500            break;
501
502        default:
503
504            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
505            break;
506        }
507
508        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
509    }
510
511    /* Validate the Min/Max/Len/Gran values */
512
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);
520
521    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
522                            OptionIndex + StringLength;
523    return (Rnode);
524}
525
526
527/*******************************************************************************
528 *
529 * FUNCTION:    RsDoDwordSpaceDescriptor
530 *
531 * PARAMETERS:  Op                  - Parent resource descriptor parse node
532 *              CurrentByteOffset   - Offset into the resource template AML
533 *                                    buffer (to track references to the desc)
534 *
535 * RETURN:      Completed resource node
536 *
537 * DESCRIPTION: Construct a long "DwordSpace" descriptor
538 *
539 ******************************************************************************/
540
541ASL_RESOURCE_NODE *
542RsDoDwordSpaceDescriptor (
543    ACPI_PARSE_OBJECT       *Op,
544    UINT32                  CurrentByteOffset)
545{
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;
556    UINT32                  i;
557    BOOLEAN                 ResSourceIndex = FALSE;
558
559
560    InitializerOp = Op->Asl.Child;
561    StringLength = RsGetStringDataLength (InitializerOp);
562
563    Rnode = RsAllocateResourceNode (
564                sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
565
566    Descriptor = Rnode->Buffer;
567    Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
568
569    /*
570     * Initial descriptor length -- may be enlarged if there are
571     * optional fields present
572     */
573    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
574    Descriptor->Address32.ResourceLength = (UINT16)
575        (sizeof (AML_RESOURCE_ADDRESS32) -
576         sizeof (AML_RESOURCE_LARGE_HEADER));
577
578    /* Process all child initialization nodes */
579
580    for (i = 0; InitializerOp; i++)
581    {
582        switch (i)
583        {
584        case 0: /* Resource Type */
585
586            Descriptor->Address32.ResourceType =
587                (UINT8) InitializerOp->Asl.Value.Integer;
588            break;
589
590        case 1: /* Resource Usage */
591
592            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
593            break;
594
595        case 2: /* DecodeType */
596
597            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
598            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
599                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
600            break;
601
602        case 3: /* MinType */
603
604            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
605            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
606                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
607            break;
608
609        case 4: /* MaxType */
610
611            RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
612            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
613                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
614            break;
615
616        case 5: /* Type-Specific flags */
617
618            Descriptor->Address32.SpecificFlags =
619                (UINT8) InitializerOp->Asl.Value.Integer;
620            break;
621
622        case 6: /* Address Granularity */
623
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;
629            break;
630
631        case 7: /* Min Address */
632
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;
638            break;
639
640        case 8: /* Max Address */
641
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;
647            break;
648
649        case 9: /* Translation Offset */
650
651            Descriptor->Address32.TranslationOffset =
652                (UINT32) InitializerOp->Asl.Value.Integer;
653            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
654                CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
655            break;
656
657        case 10: /* Address Length */
658
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;
664            break;
665
666        case 11: /* ResSourceIndex [Optional Field - BYTE] */
667
668            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
669            {
670                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
671                OptionIndex++;
672                Descriptor->Address32.ResourceLength++;
673                ResSourceIndex = TRUE;
674            }
675            break;
676
677        case 12: /* ResSource [Optional Field - STRING] */
678
679            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
680                (InitializerOp->Asl.Value.String))
681            {
682                if (StringLength)
683                {
684                    Descriptor->Address32.ResourceLength = (UINT16)
685                        (Descriptor->Address32.ResourceLength + StringLength);
686
687                    strcpy ((char *)
688                        &OptionalFields[OptionIndex],
689                        InitializerOp->Asl.Value.String);
690
691                    /* ResourceSourceIndex must also be valid */
692
693                    if (!ResSourceIndex)
694                    {
695                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
696                            InitializerOp, NULL);
697                    }
698                }
699            }
700
701#if 0
702            /*
703             * Not a valid ResourceSource, ResourceSourceIndex must also
704             * be invalid
705             */
706            else if (ResSourceIndex)
707            {
708                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
709                    InitializerOp, NULL);
710            }
711#endif
712            break;
713
714        case 13: /* ResourceTag */
715
716            UtAttachNamepathToOwner (Op, InitializerOp);
717            break;
718
719        default:
720
721            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST,
722                InitializerOp, NULL);
723            break;
724        }
725
726        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
727    }
728
729    /* Validate the Min/Max/Len/Gran values */
730
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);
738
739    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
740                            OptionIndex + StringLength;
741    return (Rnode);
742}
743