1/******************************************************************************
2 *
3 * Module Name: aslrestype2q - Large QWord address resource descriptors
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2013, 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
45#include <contrib/dev/acpica/compiler/aslcompiler.h>
46#include "aslcompiler.y.h"
47
48#define _COMPONENT          ACPI_COMPILER
49        ACPI_MODULE_NAME    ("aslrestype2q")
50
51/*
52 * This module contains the QWord (64-bit) address space descriptors:
53 *
54 * QWordIO
55 * QWordMemory
56 * QWordSpace
57 */
58
59/*******************************************************************************
60 *
61 * FUNCTION:    RsDoQwordIoDescriptor
62 *
63 * PARAMETERS:  Op                  - Parent resource descriptor parse node
64 *              CurrentByteOffset   - Offset into the resource template AML
65 *                                    buffer (to track references to the desc)
66 *
67 * RETURN:      Completed resource node
68 *
69 * DESCRIPTION: Construct a long "QwordIO" descriptor
70 *
71 ******************************************************************************/
72
73ASL_RESOURCE_NODE *
74RsDoQwordIoDescriptor (
75    ACPI_PARSE_OBJECT       *Op,
76    UINT32                  CurrentByteOffset)
77{
78    AML_RESOURCE            *Descriptor;
79    ACPI_PARSE_OBJECT       *InitializerOp;
80    ACPI_PARSE_OBJECT       *MinOp = NULL;
81    ACPI_PARSE_OBJECT       *MaxOp = NULL;
82    ACPI_PARSE_OBJECT       *LengthOp = NULL;
83    ACPI_PARSE_OBJECT       *GranOp = NULL;
84    ASL_RESOURCE_NODE       *Rnode;
85    UINT8                   *OptionalFields;
86    UINT16                  StringLength = 0;
87    UINT32                  OptionIndex = 0;
88    UINT32                  i;
89    BOOLEAN                 ResSourceIndex = FALSE;
90
91
92    InitializerOp = Op->Asl.Child;
93    StringLength = RsGetStringDataLength (InitializerOp);
94
95    Rnode = RsAllocateResourceNode (
96                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
97
98    Descriptor = Rnode->Buffer;
99    Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
100    Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
101
102    /*
103     * Initial descriptor length -- may be enlarged if there are
104     * optional fields present
105     */
106    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
107    Descriptor->Address64.ResourceLength = (UINT16)
108        (sizeof (AML_RESOURCE_ADDRESS64) -
109         sizeof (AML_RESOURCE_LARGE_HEADER));
110
111    /* Process all child initialization nodes */
112
113    for (i = 0; InitializerOp; i++)
114    {
115        switch (i)
116        {
117        case 0: /* Resource Usage */
118
119            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
120            break;
121
122        case 1: /* MinType */
123
124            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
125            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
126                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
127            break;
128
129        case 2: /* MaxType */
130
131            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
132            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
133                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
134            break;
135
136        case 3: /* DecodeType */
137
138            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
139            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
140                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
141            break;
142
143        case 4: /* Range Type */
144
145            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
146            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
147                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0, 2);
148            break;
149
150        case 5: /* Address Granularity */
151
152            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
153            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
154                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
155            GranOp = InitializerOp;
156            break;
157
158        case 6: /* Address Min */
159
160            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
161            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
162                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
163            MinOp = InitializerOp;
164            break;
165
166        case 7: /* Address Max */
167
168            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
169            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
170                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
171            MaxOp = InitializerOp;
172            break;
173
174        case 8: /* Translation Offset */
175
176            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
177            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
178                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
179            break;
180
181        case 9: /* Address Length */
182
183            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
184            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
185                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
186            LengthOp = InitializerOp;
187            break;
188
189        case 10: /* ResSourceIndex [Optional Field - BYTE] */
190
191            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
192            {
193                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
194                OptionIndex++;
195                Descriptor->Address64.ResourceLength++;
196                ResSourceIndex = TRUE;
197            }
198            break;
199
200        case 11: /* ResSource [Optional Field - STRING] */
201
202            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
203                (InitializerOp->Asl.Value.String))
204            {
205                if (StringLength)
206                {
207                    Descriptor->Address64.ResourceLength = (UINT16)
208                        (Descriptor->Address64.ResourceLength + StringLength);
209
210                    strcpy ((char *)
211                        &OptionalFields[OptionIndex],
212                        InitializerOp->Asl.Value.String);
213
214                    /* ResourceSourceIndex must also be valid */
215
216                    if (!ResSourceIndex)
217                    {
218                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
219                            InitializerOp, NULL);
220                    }
221                }
222            }
223
224#if 0
225            /*
226             * Not a valid ResourceSource, ResourceSourceIndex must also
227             * be invalid
228             */
229            else if (ResSourceIndex)
230            {
231                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
232                    InitializerOp, NULL);
233            }
234#endif
235            break;
236
237        case 12: /* ResourceTag */
238
239            UtAttachNamepathToOwner (Op, InitializerOp);
240            break;
241
242        case 13: /* Type */
243
244            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
245            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
246                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
247            break;
248
249        case 14: /* Translation Type */
250
251            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
252            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
253                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
254            break;
255
256        default:
257
258            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
259            break;
260        }
261
262        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
263    }
264
265    /* Validate the Min/Max/Len/Gran values */
266
267    RsLargeAddressCheck (
268        Descriptor->Address64.Minimum,
269        Descriptor->Address64.Maximum,
270        Descriptor->Address64.AddressLength,
271        Descriptor->Address64.Granularity,
272        Descriptor->Address64.Flags,
273        MinOp, MaxOp, LengthOp, GranOp, Op);
274
275    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
276                            OptionIndex + StringLength;
277    return (Rnode);
278}
279
280
281/*******************************************************************************
282 *
283 * FUNCTION:    RsDoQwordMemoryDescriptor
284 *
285 * PARAMETERS:  Op                  - Parent resource descriptor parse node
286 *              CurrentByteOffset   - Offset into the resource template AML
287 *                                    buffer (to track references to the desc)
288 *
289 * RETURN:      Completed resource node
290 *
291 * DESCRIPTION: Construct a long "QwordMemory" descriptor
292 *
293 ******************************************************************************/
294
295ASL_RESOURCE_NODE *
296RsDoQwordMemoryDescriptor (
297    ACPI_PARSE_OBJECT       *Op,
298    UINT32                  CurrentByteOffset)
299{
300    AML_RESOURCE            *Descriptor;
301    ACPI_PARSE_OBJECT       *InitializerOp;
302    ACPI_PARSE_OBJECT       *MinOp = NULL;
303    ACPI_PARSE_OBJECT       *MaxOp = NULL;
304    ACPI_PARSE_OBJECT       *LengthOp = NULL;
305    ACPI_PARSE_OBJECT       *GranOp = NULL;
306    ASL_RESOURCE_NODE       *Rnode;
307    UINT8                   *OptionalFields;
308    UINT16                  StringLength = 0;
309    UINT32                  OptionIndex = 0;
310    UINT32                  i;
311    BOOLEAN                 ResSourceIndex = FALSE;
312
313
314    InitializerOp = Op->Asl.Child;
315    StringLength = RsGetStringDataLength (InitializerOp);
316
317    Rnode = RsAllocateResourceNode (
318                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
319
320    Descriptor = Rnode->Buffer;
321    Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
322    Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
323
324    /*
325     * Initial descriptor length -- may be enlarged if there are
326     * optional fields present
327     */
328    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
329    Descriptor->Address64.ResourceLength = (UINT16)
330        (sizeof (AML_RESOURCE_ADDRESS64) -
331         sizeof (AML_RESOURCE_LARGE_HEADER));
332
333    /* Process all child initialization nodes */
334
335    for (i = 0; InitializerOp; i++)
336    {
337        switch (i)
338        {
339        case 0: /* Resource Usage */
340
341            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
342            break;
343
344        case 1: /* DecodeType */
345
346            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
347            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
348                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
349            break;
350
351        case 2: /* MinType */
352
353            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
354            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
355                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
356            break;
357
358        case 3: /* MaxType */
359
360            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
361            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
362                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
363            break;
364
365        case 4: /* Memory Type */
366
367            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
368            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
369                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
370            break;
371
372        case 5: /* Read/Write Type */
373
374            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
375            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
376                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
377            break;
378
379        case 6: /* Address Granularity */
380
381            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
382            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
383                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
384            GranOp = InitializerOp;
385            break;
386
387        case 7: /* Min Address */
388
389            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
390            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
391                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
392            MinOp = InitializerOp;
393            break;
394
395        case 8: /* Max Address */
396
397            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
398            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
399                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
400            MaxOp = InitializerOp;
401            break;
402
403        case 9: /* Translation Offset */
404
405            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
406            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
407                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
408            break;
409
410        case 10: /* Address Length */
411
412            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
413            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
414                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
415            LengthOp = InitializerOp;
416            break;
417
418        case 11: /* ResSourceIndex [Optional Field - BYTE] */
419
420            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
421            {
422                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
423                OptionIndex++;
424                Descriptor->Address64.ResourceLength++;
425                ResSourceIndex = TRUE;
426            }
427            break;
428
429        case 12: /* ResSource [Optional Field - STRING] */
430
431            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
432                (InitializerOp->Asl.Value.String))
433            {
434                if (StringLength)
435                {
436                    Descriptor->Address64.ResourceLength = (UINT16)
437                        (Descriptor->Address64.ResourceLength + StringLength);
438
439                    strcpy ((char *)
440                        &OptionalFields[OptionIndex],
441                        InitializerOp->Asl.Value.String);
442
443                    /* ResourceSourceIndex must also be valid */
444
445                    if (!ResSourceIndex)
446                    {
447                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
448                            InitializerOp, NULL);
449                    }
450                }
451            }
452
453#if 0
454            /*
455             * Not a valid ResourceSource, ResourceSourceIndex must also
456             * be invalid
457             */
458            else if (ResSourceIndex)
459            {
460                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
461                    InitializerOp, NULL);
462            }
463#endif
464            break;
465
466        case 13: /* ResourceTag */
467
468            UtAttachNamepathToOwner (Op, InitializerOp);
469            break;
470
471
472        case 14: /* Address Range */
473
474            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
475            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
476                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
477            break;
478
479        case 15: /* Type */
480
481            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
482            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
483                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
484            break;
485
486        default:
487
488            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
489            break;
490        }
491
492        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
493    }
494
495    /* Validate the Min/Max/Len/Gran values */
496
497    RsLargeAddressCheck (
498        Descriptor->Address64.Minimum,
499        Descriptor->Address64.Maximum,
500        Descriptor->Address64.AddressLength,
501        Descriptor->Address64.Granularity,
502        Descriptor->Address64.Flags,
503        MinOp, MaxOp, LengthOp, GranOp, Op);
504
505    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
506                            OptionIndex + StringLength;
507    return (Rnode);
508}
509
510
511/*******************************************************************************
512 *
513 * FUNCTION:    RsDoQwordSpaceDescriptor
514 *
515 * PARAMETERS:  Op                  - Parent resource descriptor parse node
516 *              CurrentByteOffset   - Offset into the resource template AML
517 *                                    buffer (to track references to the desc)
518 *
519 * RETURN:      Completed resource node
520 *
521 * DESCRIPTION: Construct a long "QwordSpace" descriptor
522 *
523 ******************************************************************************/
524
525ASL_RESOURCE_NODE *
526RsDoQwordSpaceDescriptor (
527    ACPI_PARSE_OBJECT       *Op,
528    UINT32                  CurrentByteOffset)
529{
530    AML_RESOURCE            *Descriptor;
531    ACPI_PARSE_OBJECT       *InitializerOp;
532    ACPI_PARSE_OBJECT       *MinOp = NULL;
533    ACPI_PARSE_OBJECT       *MaxOp = NULL;
534    ACPI_PARSE_OBJECT       *LengthOp = NULL;
535    ACPI_PARSE_OBJECT       *GranOp = NULL;
536    ASL_RESOURCE_NODE       *Rnode;
537    UINT8                   *OptionalFields;
538    UINT16                  StringLength = 0;
539    UINT32                  OptionIndex = 0;
540    UINT32                  i;
541    BOOLEAN                 ResSourceIndex = FALSE;
542
543
544    InitializerOp = Op->Asl.Child;
545    StringLength = RsGetStringDataLength (InitializerOp);
546
547    Rnode = RsAllocateResourceNode (
548                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
549
550    Descriptor = Rnode->Buffer;
551    Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
552
553    /*
554     * Initial descriptor length -- may be enlarged if there are
555     * optional fields present
556     */
557    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
558    Descriptor->Address64.ResourceLength = (UINT16)
559        (sizeof (AML_RESOURCE_ADDRESS64) -
560         sizeof (AML_RESOURCE_LARGE_HEADER));
561
562    /* Process all child initialization nodes */
563
564    for (i = 0; InitializerOp; i++)
565    {
566        switch (i)
567        {
568        case 0: /* Resource Type */
569
570            Descriptor->Address64.ResourceType =
571                (UINT8) InitializerOp->Asl.Value.Integer;
572            break;
573
574        case 1: /* Resource Usage */
575
576            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
577            break;
578
579        case 2: /* DecodeType */
580
581            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
582            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
583                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
584            break;
585
586        case 3: /* MinType */
587
588            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
589            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
590                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
591            break;
592
593        case 4: /* MaxType */
594
595            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
596            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
597                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
598            break;
599
600        case 5: /* Type-Specific flags */
601
602            Descriptor->Address64.SpecificFlags =
603                (UINT8) InitializerOp->Asl.Value.Integer;
604            break;
605
606        case 6: /* Address Granularity */
607
608            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
609            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
610                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
611            GranOp = InitializerOp;
612            break;
613
614        case 7: /* Min Address */
615
616            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
617            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
618                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
619            MinOp = InitializerOp;
620            break;
621
622        case 8: /* Max Address */
623
624            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
625            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
626                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
627            MaxOp = InitializerOp;
628            break;
629
630        case 9: /* Translation Offset */
631
632            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
633            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
634                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
635            break;
636
637        case 10: /* Address Length */
638
639            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
640            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
641                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
642            LengthOp = InitializerOp;
643            break;
644
645        case 11: /* ResSourceIndex [Optional Field - BYTE] */
646
647            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
648            {
649                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
650                OptionIndex++;
651                Descriptor->Address64.ResourceLength++;
652                ResSourceIndex = TRUE;
653            }
654            break;
655
656        case 12: /* ResSource [Optional Field - STRING] */
657
658            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
659                (InitializerOp->Asl.Value.String))
660            {
661                if (StringLength)
662                {
663                    Descriptor->Address64.ResourceLength = (UINT16)
664                        (Descriptor->Address64.ResourceLength + StringLength);
665
666                    strcpy ((char *)
667                        &OptionalFields[OptionIndex],
668                        InitializerOp->Asl.Value.String);
669
670                    /* ResourceSourceIndex must also be valid */
671
672                    if (!ResSourceIndex)
673                    {
674                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
675                            InitializerOp, NULL);
676                    }
677                }
678            }
679
680#if 0
681            /*
682             * Not a valid ResourceSource, ResourceSourceIndex must also
683             * be invalid
684             */
685            else if (ResSourceIndex)
686            {
687                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
688                    InitializerOp, NULL);
689            }
690#endif
691            break;
692
693        case 13: /* ResourceTag */
694
695            UtAttachNamepathToOwner (Op, InitializerOp);
696            break;
697
698        default:
699
700            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
701            break;
702        }
703
704        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
705    }
706
707    /* Validate the Min/Max/Len/Gran values */
708
709    RsLargeAddressCheck (
710        Descriptor->Address64.Minimum,
711        Descriptor->Address64.Maximum,
712        Descriptor->Address64.AddressLength,
713        Descriptor->Address64.Granularity,
714        Descriptor->Address64.Flags,
715        MinOp, MaxOp, LengthOp, GranOp, Op);
716
717    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
718                            OptionIndex + StringLength;
719    return (Rnode);
720}
721