aslrestype2q.c revision 228110 
11573Srgrimes
21573Srgrimes/******************************************************************************
31573Srgrimes *
41573Srgrimes * Module Name: aslrestype2q - Large QWord address resource descriptors
51573Srgrimes *
61573Srgrimes *****************************************************************************/
71573Srgrimes
81573Srgrimes/*
91573Srgrimes * Copyright (C) 2000 - 2011, Intel Corp.
101573Srgrimes * All rights reserved.
111573Srgrimes *
121573Srgrimes * Redistribution and use in source and binary forms, with or without
131573Srgrimes * modification, are permitted provided that the following conditions
141573Srgrimes * are met:
151573Srgrimes * 1. Redistributions of source code must retain the above copyright
16148834Sstefanf *    notice, this list of conditions, and the following disclaimer,
171573Srgrimes *    without modification.
181573Srgrimes * 2. Redistributions in binary form must reproduce at minimum a disclaimer
191573Srgrimes *    substantially similar to the "NO WARRANTY" disclaimer below
201573Srgrimes *    ("Disclaimer") and any redistribution must be conditioned upon
211573Srgrimes *    including a substantially similar Disclaimer requirement for further
221573Srgrimes *    binary redistribution.
231573Srgrimes * 3. Neither the names of the above-listed copyright holders nor the names
241573Srgrimes *    of any contributors may be used to endorse or promote products derived
251573Srgrimes *    from this software without specific prior written permission.
261573Srgrimes *
271573Srgrimes * Alternatively, this software may be distributed under the terms of the
281573Srgrimes * GNU General Public License ("GPL") version 2 as published by the Free
291573Srgrimes * Software Foundation.
301573Srgrimes *
311573Srgrimes * NO WARRANTY
321573Srgrimes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33268782Spfg * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3484260Sobrien * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
351573Srgrimes * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
361573Srgrimes * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
371573Srgrimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
381573Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
391573Srgrimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
401573Srgrimes * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
4184260Sobrien * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
421573Srgrimes * POSSIBILITY OF SUCH DAMAGES.
43148924Sstefanf */
44148924Sstefanf
451573Srgrimes
461573Srgrimes#include <contrib/dev/acpica/compiler/aslcompiler.h>
471573Srgrimes#include "aslcompiler.y.h"
481573Srgrimes
491573Srgrimes#define _COMPONENT          ACPI_COMPILER
501573Srgrimes        ACPI_MODULE_NAME    ("aslrestype2q")
511573Srgrimes
521573Srgrimes/*
531573Srgrimes * This module contains the QWord (64-bit) address space descriptors:
541573Srgrimes *
551573Srgrimes * QWordIO
561573Srgrimes * QWordMemory
571573Srgrimes * QWordSpace
581573Srgrimes */
591573Srgrimes
6084260Sobrien/*******************************************************************************
611573Srgrimes *
621573Srgrimes * FUNCTION:    RsDoQwordIoDescriptor
631573Srgrimes *
641573Srgrimes * PARAMETERS:  Op                  - Parent resource descriptor parse node
6584260Sobrien *              CurrentByteOffset   - Offset into the resource template AML
661573Srgrimes *                                    buffer (to track references to the desc)
671573Srgrimes *
681573Srgrimes * RETURN:      Completed resource node
691573Srgrimes *
7084260Sobrien * DESCRIPTION: Construct a long "QwordIO" descriptor
7184260Sobrien *
7284260Sobrien ******************************************************************************/
73268782Spfg
74268782SpfgASL_RESOURCE_NODE *
75268782SpfgRsDoQwordIoDescriptor (
76268782Spfg    ACPI_PARSE_OBJECT       *Op,
77268782Spfg    UINT32                  CurrentByteOffset)
78268782Spfg{
79268782Spfg    AML_RESOURCE            *Descriptor;
80268782Spfg    ACPI_PARSE_OBJECT       *InitializerOp;
81268782Spfg    ACPI_PARSE_OBJECT       *MinOp = NULL;
82148834Sstefanf    ACPI_PARSE_OBJECT       *MaxOp = NULL;
8326926Smsmith    ACPI_PARSE_OBJECT       *LengthOp = NULL;
8426926Smsmith    ACPI_PARSE_OBJECT       *GranOp = NULL;
851573Srgrimes    ASL_RESOURCE_NODE       *Rnode;
861573Srgrimes    UINT8                   *OptionalFields;
871573Srgrimes    UINT16                  StringLength = 0;
881573Srgrimes    UINT32                  OptionIndex = 0;
891573Srgrimes    UINT32                  i;
90148834Sstefanf    BOOLEAN                 ResSourceIndex = FALSE;
91148834Sstefanf
92148834Sstefanf
93148834Sstefanf    InitializerOp = Op->Asl.Child;
94148834Sstefanf    StringLength = RsGetStringDataLength (InitializerOp);
95148834Sstefanf
9684260Sobrien    Rnode = RsAllocateResourceNode (
9784260Sobrien                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
9884260Sobrien
9984260Sobrien    Descriptor = Rnode->Buffer;
10084260Sobrien    Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
10184260Sobrien    Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
10284260Sobrien
10384260Sobrien    /*
10484260Sobrien     * Initial descriptor length -- may be enlarged if there are
1051573Srgrimes     * optional fields present
1061573Srgrimes     */
10784260Sobrien    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1081573Srgrimes    Descriptor->Address64.ResourceLength = (UINT16)
1091573Srgrimes        (sizeof (AML_RESOURCE_ADDRESS64) -
1101573Srgrimes         sizeof (AML_RESOURCE_LARGE_HEADER));
1111573Srgrimes
11284260Sobrien    /* Process all child initialization nodes */
11384260Sobrien
1141573Srgrimes    for (i = 0; InitializerOp; i++)
11584260Sobrien    {
1161573Srgrimes        switch (i)
1171573Srgrimes        {
1181573Srgrimes        case 0: /* Resource Usage */
119
120            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
121            break;
122
123        case 1: /* MinType */
124
125            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
126            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
127                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
128            break;
129
130        case 2: /* MaxType */
131
132            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
133            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
134                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
135            break;
136
137        case 3: /* DecodeType */
138
139            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
140            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
141                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
142            break;
143
144        case 4: /* Range Type */
145
146            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
147            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
148                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0, 2);
149            break;
150
151        case 5: /* Address Granularity */
152
153            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
154            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
155                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
156            GranOp = InitializerOp;
157            break;
158
159        case 6: /* Address Min */
160
161            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
162            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
163                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
164            MinOp = InitializerOp;
165            break;
166
167        case 7: /* Address Max */
168
169            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
170            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
171                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
172            MaxOp = InitializerOp;
173            break;
174
175        case 8: /* Translation Offset */
176
177            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
178            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
179                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
180            break;
181
182        case 9: /* Address Length */
183
184            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
185            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
186                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
187            LengthOp = InitializerOp;
188            break;
189
190        case 10: /* ResSourceIndex [Optional Field - BYTE] */
191
192            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
193            {
194                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
195                OptionIndex++;
196                Descriptor->Address64.ResourceLength++;
197                ResSourceIndex = TRUE;
198            }
199            break;
200
201        case 11: /* ResSource [Optional Field - STRING] */
202
203            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
204                (InitializerOp->Asl.Value.String))
205            {
206                if (StringLength)
207                {
208                    Descriptor->Address64.ResourceLength = (UINT16)
209                        (Descriptor->Address64.ResourceLength + StringLength);
210
211                    strcpy ((char *)
212                        &OptionalFields[OptionIndex],
213                        InitializerOp->Asl.Value.String);
214
215                    /* ResourceSourceIndex must also be valid */
216
217                    if (!ResSourceIndex)
218                    {
219                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
220                            InitializerOp, NULL);
221                    }
222                }
223            }
224
225#if 0
226            /*
227             * Not a valid ResourceSource, ResourceSourceIndex must also
228             * be invalid
229             */
230            else if (ResSourceIndex)
231            {
232                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
233                    InitializerOp, NULL);
234            }
235#endif
236            break;
237
238        case 12: /* ResourceTag */
239
240            UtAttachNamepathToOwner (Op, InitializerOp);
241            break;
242
243        case 13: /* Type */
244
245            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
246            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
247                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
248            break;
249
250        case 14: /* Translation Type */
251
252            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
253            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
254                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
255            break;
256
257        default:
258
259            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
260            break;
261        }
262
263        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
264    }
265
266    /* Validate the Min/Max/Len/Gran values */
267
268    RsLargeAddressCheck (
269        Descriptor->Address64.Minimum,
270        Descriptor->Address64.Maximum,
271        Descriptor->Address64.AddressLength,
272        Descriptor->Address64.Granularity,
273        Descriptor->Address64.Flags,
274        MinOp, MaxOp, LengthOp, GranOp, Op);
275
276    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
277                            OptionIndex + StringLength;
278    return (Rnode);
279}
280
281
282/*******************************************************************************
283 *
284 * FUNCTION:    RsDoQwordMemoryDescriptor
285 *
286 * PARAMETERS:  Op                  - Parent resource descriptor parse node
287 *              CurrentByteOffset   - Offset into the resource template AML
288 *                                    buffer (to track references to the desc)
289 *
290 * RETURN:      Completed resource node
291 *
292 * DESCRIPTION: Construct a long "QwordMemory" descriptor
293 *
294 ******************************************************************************/
295
296ASL_RESOURCE_NODE *
297RsDoQwordMemoryDescriptor (
298    ACPI_PARSE_OBJECT       *Op,
299    UINT32                  CurrentByteOffset)
300{
301    AML_RESOURCE            *Descriptor;
302    ACPI_PARSE_OBJECT       *InitializerOp;
303    ACPI_PARSE_OBJECT       *MinOp = NULL;
304    ACPI_PARSE_OBJECT       *MaxOp = NULL;
305    ACPI_PARSE_OBJECT       *LengthOp = NULL;
306    ACPI_PARSE_OBJECT       *GranOp = NULL;
307    ASL_RESOURCE_NODE       *Rnode;
308    UINT8                   *OptionalFields;
309    UINT16                  StringLength = 0;
310    UINT32                  OptionIndex = 0;
311    UINT32                  i;
312    BOOLEAN                 ResSourceIndex = FALSE;
313
314
315    InitializerOp = Op->Asl.Child;
316    StringLength = RsGetStringDataLength (InitializerOp);
317
318    Rnode = RsAllocateResourceNode (
319                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
320
321    Descriptor = Rnode->Buffer;
322    Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
323    Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
324
325    /*
326     * Initial descriptor length -- may be enlarged if there are
327     * optional fields present
328     */
329    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
330    Descriptor->Address64.ResourceLength = (UINT16)
331        (sizeof (AML_RESOURCE_ADDRESS64) -
332         sizeof (AML_RESOURCE_LARGE_HEADER));
333
334    /* Process all child initialization nodes */
335
336    for (i = 0; InitializerOp; i++)
337    {
338        switch (i)
339        {
340        case 0: /* Resource Usage */
341
342            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
343            break;
344
345        case 1: /* DecodeType */
346
347            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
348            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
349                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
350            break;
351
352        case 2: /* MinType */
353
354            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
355            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
356                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
357            break;
358
359        case 3: /* MaxType */
360
361            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
362            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
363                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
364            break;
365
366        case 4: /* Memory Type */
367
368            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
369            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
370                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
371            break;
372
373        case 5: /* Read/Write Type */
374
375            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
376            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
377                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
378            break;
379
380        case 6: /* Address Granularity */
381
382            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
383            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
384                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
385            GranOp = InitializerOp;
386            break;
387
388        case 7: /* Min Address */
389
390            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
391            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
392                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
393            MinOp = InitializerOp;
394            break;
395
396        case 8: /* Max Address */
397
398            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
399            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
400                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
401            MaxOp = InitializerOp;
402            break;
403
404        case 9: /* Translation Offset */
405
406            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
407            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
408                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
409            break;
410
411        case 10: /* Address Length */
412
413            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
414            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
415                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
416            LengthOp = InitializerOp;
417            break;
418
419        case 11: /* ResSourceIndex [Optional Field - BYTE] */
420
421            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
422            {
423                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
424                OptionIndex++;
425                Descriptor->Address64.ResourceLength++;
426                ResSourceIndex = TRUE;
427            }
428            break;
429
430        case 12: /* ResSource [Optional Field - STRING] */
431
432            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
433                (InitializerOp->Asl.Value.String))
434            {
435                if (StringLength)
436                {
437                    Descriptor->Address64.ResourceLength = (UINT16)
438                        (Descriptor->Address64.ResourceLength + StringLength);
439
440                    strcpy ((char *)
441                        &OptionalFields[OptionIndex],
442                        InitializerOp->Asl.Value.String);
443
444                    /* ResourceSourceIndex must also be valid */
445
446                    if (!ResSourceIndex)
447                    {
448                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
449                            InitializerOp, NULL);
450                    }
451                }
452            }
453
454#if 0
455            /*
456             * Not a valid ResourceSource, ResourceSourceIndex must also
457             * be invalid
458             */
459            else if (ResSourceIndex)
460            {
461                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
462                    InitializerOp, NULL);
463            }
464#endif
465            break;
466
467        case 13: /* ResourceTag */
468
469            UtAttachNamepathToOwner (Op, InitializerOp);
470            break;
471
472
473        case 14: /* Address Range */
474
475            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
476            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
477                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
478            break;
479
480        case 15: /* Type */
481
482            RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
483            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
484                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
485            break;
486
487        default:
488
489            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
490            break;
491        }
492
493        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
494    }
495
496    /* Validate the Min/Max/Len/Gran values */
497
498    RsLargeAddressCheck (
499        Descriptor->Address64.Minimum,
500        Descriptor->Address64.Maximum,
501        Descriptor->Address64.AddressLength,
502        Descriptor->Address64.Granularity,
503        Descriptor->Address64.Flags,
504        MinOp, MaxOp, LengthOp, GranOp, Op);
505
506    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
507                            OptionIndex + StringLength;
508    return (Rnode);
509}
510
511
512/*******************************************************************************
513 *
514 * FUNCTION:    RsDoQwordSpaceDescriptor
515 *
516 * PARAMETERS:  Op                  - Parent resource descriptor parse node
517 *              CurrentByteOffset   - Offset into the resource template AML
518 *                                    buffer (to track references to the desc)
519 *
520 * RETURN:      Completed resource node
521 *
522 * DESCRIPTION: Construct a long "QwordSpace" descriptor
523 *
524 ******************************************************************************/
525
526ASL_RESOURCE_NODE *
527RsDoQwordSpaceDescriptor (
528    ACPI_PARSE_OBJECT       *Op,
529    UINT32                  CurrentByteOffset)
530{
531    AML_RESOURCE            *Descriptor;
532    ACPI_PARSE_OBJECT       *InitializerOp;
533    ACPI_PARSE_OBJECT       *MinOp = NULL;
534    ACPI_PARSE_OBJECT       *MaxOp = NULL;
535    ACPI_PARSE_OBJECT       *LengthOp = NULL;
536    ACPI_PARSE_OBJECT       *GranOp = NULL;
537    ASL_RESOURCE_NODE       *Rnode;
538    UINT8                   *OptionalFields;
539    UINT16                  StringLength = 0;
540    UINT32                  OptionIndex = 0;
541    UINT32                  i;
542    BOOLEAN                 ResSourceIndex = FALSE;
543
544
545    InitializerOp = Op->Asl.Child;
546    StringLength = RsGetStringDataLength (InitializerOp);
547
548    Rnode = RsAllocateResourceNode (
549                sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
550
551    Descriptor = Rnode->Buffer;
552    Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
553
554    /*
555     * Initial descriptor length -- may be enlarged if there are
556     * optional fields present
557     */
558    OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
559    Descriptor->Address64.ResourceLength = (UINT16)
560        (sizeof (AML_RESOURCE_ADDRESS64) -
561         sizeof (AML_RESOURCE_LARGE_HEADER));
562
563    /* Process all child initialization nodes */
564
565    for (i = 0; InitializerOp; i++)
566    {
567        switch (i)
568        {
569        case 0: /* Resource Type */
570
571            Descriptor->Address64.ResourceType =
572                (UINT8) InitializerOp->Asl.Value.Integer;
573            break;
574
575        case 1: /* Resource Usage */
576
577            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
578            break;
579
580        case 2: /* DecodeType */
581
582            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
583            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
584                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
585            break;
586
587        case 3: /* MinType */
588
589            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
590            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
591                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
592            break;
593
594        case 4: /* MaxType */
595
596            RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
597            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
598                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
599            break;
600
601        case 5: /* Type-Specific flags */
602
603            Descriptor->Address64.SpecificFlags =
604                (UINT8) InitializerOp->Asl.Value.Integer;
605            break;
606
607        case 6: /* Address Granularity */
608
609            Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
610            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
611                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
612            GranOp = InitializerOp;
613            break;
614
615        case 7: /* Min Address */
616
617            Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
618            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
619                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
620            MinOp = InitializerOp;
621            break;
622
623        case 8: /* Max Address */
624
625            Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
626            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
627                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
628            MaxOp = InitializerOp;
629            break;
630
631        case 9: /* Translation Offset */
632
633            Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
634            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
635                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
636            break;
637
638        case 10: /* Address Length */
639
640            Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
641            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
642                CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
643            LengthOp = InitializerOp;
644            break;
645
646        case 11: /* ResSourceIndex [Optional Field - BYTE] */
647
648            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
649            {
650                OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
651                OptionIndex++;
652                Descriptor->Address64.ResourceLength++;
653                ResSourceIndex = TRUE;
654            }
655            break;
656
657        case 12: /* ResSource [Optional Field - STRING] */
658
659            if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
660                (InitializerOp->Asl.Value.String))
661            {
662                if (StringLength)
663                {
664                    Descriptor->Address64.ResourceLength = (UINT16)
665                        (Descriptor->Address64.ResourceLength + StringLength);
666
667                    strcpy ((char *)
668                        &OptionalFields[OptionIndex],
669                        InitializerOp->Asl.Value.String);
670
671                    /* ResourceSourceIndex must also be valid */
672
673                    if (!ResSourceIndex)
674                    {
675                        AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
676                            InitializerOp, NULL);
677                    }
678                }
679            }
680
681#if 0
682            /*
683             * Not a valid ResourceSource, ResourceSourceIndex must also
684             * be invalid
685             */
686            else if (ResSourceIndex)
687            {
688                AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
689                    InitializerOp, NULL);
690            }
691#endif
692            break;
693
694        case 13: /* ResourceTag */
695
696            UtAttachNamepathToOwner (Op, InitializerOp);
697            break;
698
699        default:
700
701            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
702            break;
703        }
704
705        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
706    }
707
708    /* Validate the Min/Max/Len/Gran values */
709
710    RsLargeAddressCheck (
711        Descriptor->Address64.Minimum,
712        Descriptor->Address64.Maximum,
713        Descriptor->Address64.AddressLength,
714        Descriptor->Address64.Granularity,
715        Descriptor->Address64.Flags,
716        MinOp, MaxOp, LengthOp, GranOp, Op);
717
718    Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
719                            OptionIndex + StringLength;
720    return (Rnode);
721}
722