aslrestype2e.c revision 281075 
1/******************************************************************************
2 *
3 * Module Name: aslrestype2e - Large Extended address resource descriptors
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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#include <contrib/dev/acpica/compiler/aslcompiler.h>
45
46#define _COMPONENT          ACPI_COMPILER
47        ACPI_MODULE_NAME    ("aslrestype2e")
48
49/*
50 * This module contains the Extended (64-bit) address space descriptors:
51 *
52 * ExtendedIO
53 * ExtendedMemory
54 * ExtendedSpace
55 */
56
57/*******************************************************************************
58 *
59 * FUNCTION:    RsDoExtendedIoDescriptor
60 *
61 * PARAMETERS:  Info                - Parse Op and resource template offset
62 *
63 * RETURN:      Completed resource node
64 *
65 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
66 *
67 ******************************************************************************/
68
69ASL_RESOURCE_NODE *
70RsDoExtendedIoDescriptor (
71    ASL_RESOURCE_INFO       *Info)
72{
73    AML_RESOURCE            *Descriptor;
74    ACPI_PARSE_OBJECT       *InitializerOp;
75    ACPI_PARSE_OBJECT       *MinOp = NULL;
76    ACPI_PARSE_OBJECT       *MaxOp = NULL;
77    ACPI_PARSE_OBJECT       *LengthOp = NULL;
78    ACPI_PARSE_OBJECT       *GranOp = NULL;
79    ASL_RESOURCE_NODE       *Rnode;
80    UINT16                  StringLength = 0;
81    UINT32                  CurrentByteOffset;
82    UINT32                  i;
83
84
85    InitializerOp = Info->DescriptorTypeOp->Asl.Child;
86    StringLength = RsGetStringDataLength (InitializerOp);
87    CurrentByteOffset = Info->CurrentByteOffset;
88
89    Rnode = RsAllocateResourceNode (
90                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
91
92    Descriptor = Rnode->Buffer;
93    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
94    Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
95    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
96
97    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
98        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
99         sizeof (AML_RESOURCE_LARGE_HEADER));
100
101    /* Process all child initialization nodes */
102
103    for (i = 0; InitializerOp; i++)
104    {
105        switch (i)
106        {
107        case 0: /* Resource Usage */
108
109            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
110            break;
111
112        case 1: /* MinType */
113
114            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
115            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
116                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
117            break;
118
119        case 2: /* MaxType */
120
121            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
122            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
123                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
124            break;
125
126        case 3: /* DecodeType */
127
128            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
129            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
130                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
131            break;
132
133        case 4: /* Range Type */
134
135            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
136            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
137                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
138            break;
139
140        case 5: /* Address Granularity */
141
142            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
143            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
144                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
145            GranOp = InitializerOp;
146           break;
147
148        case 6: /* Address Min */
149
150            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
151            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
152                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
153            MinOp = InitializerOp;
154            break;
155
156        case 7: /* Address Max */
157
158            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
159            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
160                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
161            MaxOp = InitializerOp;
162            break;
163
164        case 8: /* Translation Offset */
165
166            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
167            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
168                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
169            break;
170
171        case 9: /* Address Length */
172
173            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
174            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
175                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
176            LengthOp = InitializerOp;
177            break;
178
179        case 10: /* Type-Specific Attributes */
180
181            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
182            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
183                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
184            break;
185
186        case 11: /* ResourceTag */
187
188            UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
189            break;
190
191        case 12: /* Type */
192
193            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
194            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
195                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
196            break;
197
198        case 13: /* Translation Type */
199
200            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
201            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
202                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
203            break;
204
205        default:
206
207            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
208            break;
209        }
210
211        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
212    }
213
214    /* Validate the Min/Max/Len/Gran values */
215
216    RsLargeAddressCheck (
217        Descriptor->ExtAddress64.Minimum,
218        Descriptor->ExtAddress64.Maximum,
219        Descriptor->ExtAddress64.AddressLength,
220        Descriptor->ExtAddress64.Granularity,
221        Descriptor->ExtAddress64.Flags,
222        MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
223
224    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
225        StringLength;
226    return (Rnode);
227}
228
229
230/*******************************************************************************
231 *
232 * FUNCTION:    RsDoExtendedMemoryDescriptor
233 *
234 * PARAMETERS:  Info                - Parse Op and resource template offset
235 *
236 * RETURN:      Completed resource node
237 *
238 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
239 *
240 ******************************************************************************/
241
242ASL_RESOURCE_NODE *
243RsDoExtendedMemoryDescriptor (
244    ASL_RESOURCE_INFO       *Info)
245{
246    AML_RESOURCE            *Descriptor;
247    ACPI_PARSE_OBJECT       *InitializerOp;
248    ACPI_PARSE_OBJECT       *MinOp = NULL;
249    ACPI_PARSE_OBJECT       *MaxOp = NULL;
250    ACPI_PARSE_OBJECT       *LengthOp = NULL;
251    ACPI_PARSE_OBJECT       *GranOp = NULL;
252    ASL_RESOURCE_NODE       *Rnode;
253    UINT16                  StringLength = 0;
254    UINT32                  CurrentByteOffset;
255    UINT32                  i;
256
257
258    InitializerOp = Info->DescriptorTypeOp->Asl.Child;
259    StringLength = RsGetStringDataLength (InitializerOp);
260    CurrentByteOffset = Info->CurrentByteOffset;
261
262    Rnode = RsAllocateResourceNode (
263                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
264
265    Descriptor = Rnode->Buffer;
266    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
267    Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
268    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
269
270    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
271        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
272         sizeof (AML_RESOURCE_LARGE_HEADER));
273
274    /* Process all child initialization nodes */
275
276    for (i = 0; InitializerOp; i++)
277    {
278        switch (i)
279        {
280        case 0: /* Resource Usage */
281
282            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
283            break;
284
285        case 1: /* DecodeType */
286
287            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
288            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
289                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
290            break;
291
292        case 2: /* MinType */
293
294            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
295            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
296                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
297            break;
298
299        case 3: /* MaxType */
300
301            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
302            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
303                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
304            break;
305
306        case 4: /* Memory Type */
307
308            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
309            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
310                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
311            break;
312
313        case 5: /* Read/Write Type */
314
315            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
316            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
317                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
318            break;
319
320        case 6: /* Address Granularity */
321
322            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
323            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
324                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
325            GranOp = InitializerOp;
326            break;
327
328        case 7: /* Min Address */
329
330            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
331            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
332                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
333            MinOp = InitializerOp;
334            break;
335
336        case 8: /* Max Address */
337
338            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
339            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
340                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
341            MaxOp = InitializerOp;
342            break;
343
344        case 9: /* Translation Offset */
345
346            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
347            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
348                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
349            break;
350
351        case 10: /* Address Length */
352
353            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
354            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
355                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
356            LengthOp = InitializerOp;
357            break;
358
359        case 11: /* Type-Specific Attributes */
360
361            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
362            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
363                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
364            break;
365
366        case 12: /* ResourceTag */
367
368            UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
369            break;
370
371
372        case 13: /* Address Range */
373
374            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
375            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
376                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
377            break;
378
379        case 14: /* Type */
380
381            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
382            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
383                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
384            break;
385
386        default:
387
388            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
389            break;
390        }
391
392        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
393    }
394
395    /* Validate the Min/Max/Len/Gran values */
396
397    RsLargeAddressCheck (
398        Descriptor->ExtAddress64.Minimum,
399        Descriptor->ExtAddress64.Maximum,
400        Descriptor->ExtAddress64.AddressLength,
401        Descriptor->ExtAddress64.Granularity,
402        Descriptor->ExtAddress64.Flags,
403        MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
404
405    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
406        StringLength;
407    return (Rnode);
408}
409
410
411/*******************************************************************************
412 *
413 * FUNCTION:    RsDoExtendedSpaceDescriptor
414 *
415 * PARAMETERS:  Info                - Parse Op and resource template offset
416 *
417 * RETURN:      Completed resource node
418 *
419 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
420 *
421 ******************************************************************************/
422
423ASL_RESOURCE_NODE *
424RsDoExtendedSpaceDescriptor (
425    ASL_RESOURCE_INFO       *Info)
426{
427    AML_RESOURCE            *Descriptor;
428    ACPI_PARSE_OBJECT       *InitializerOp;
429    ACPI_PARSE_OBJECT       *MinOp = NULL;
430    ACPI_PARSE_OBJECT       *MaxOp = NULL;
431    ACPI_PARSE_OBJECT       *LengthOp = NULL;
432    ACPI_PARSE_OBJECT       *GranOp = NULL;
433    ASL_RESOURCE_NODE       *Rnode;
434    UINT16                  StringLength = 0;
435    UINT32                  CurrentByteOffset;
436    UINT32                  i;
437
438
439    InitializerOp = Info->DescriptorTypeOp->Asl.Child;
440    StringLength = RsGetStringDataLength (InitializerOp);
441    CurrentByteOffset = Info->CurrentByteOffset;
442
443    Rnode = RsAllocateResourceNode (
444                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
445
446    Descriptor = Rnode->Buffer;
447    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
448    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
449
450    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
451        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
452         sizeof (AML_RESOURCE_LARGE_HEADER));
453
454    /* Process all child initialization nodes */
455
456    for (i = 0; InitializerOp; i++)
457    {
458        switch (i)
459        {
460        case 0: /* Resource Type */
461
462            Descriptor->ExtAddress64.ResourceType =
463                (UINT8) InitializerOp->Asl.Value.Integer;
464            break;
465
466        case 1: /* Resource Usage */
467
468            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
469            break;
470
471        case 2: /* DecodeType */
472
473            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
474            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
475                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
476            break;
477
478        case 3: /* MinType */
479
480            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
481            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
482                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
483            break;
484
485        case 4: /* MaxType */
486
487            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
488            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
489                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
490            break;
491
492        case 5: /* Type-Specific flags */
493
494            Descriptor->ExtAddress64.SpecificFlags =
495                (UINT8) InitializerOp->Asl.Value.Integer;
496            break;
497
498        case 6: /* Address Granularity */
499
500            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
501            RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
502                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
503            GranOp = InitializerOp;
504            break;
505
506        case 7: /* Min Address */
507
508            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
509            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
510                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
511            MinOp = InitializerOp;
512            break;
513
514        case 8: /* Max Address */
515
516            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
517            RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
518                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
519            MaxOp = InitializerOp;
520            break;
521
522        case 9: /* Translation Offset */
523
524            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
525            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
526                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
527            break;
528
529        case 10: /* Address Length */
530
531            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
532            RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
533                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
534            LengthOp = InitializerOp;
535            break;
536
537        case 11: /* Type-Specific Attributes */
538
539            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
540            RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
541                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
542            break;
543
544        case 12: /* ResourceTag */
545
546            UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
547            break;
548
549        default:
550
551            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
552            break;
553        }
554
555        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
556    }
557
558    /* Validate the Min/Max/Len/Gran values */
559
560    RsLargeAddressCheck (
561        Descriptor->ExtAddress64.Minimum,
562        Descriptor->ExtAddress64.Maximum,
563        Descriptor->ExtAddress64.AddressLength,
564        Descriptor->ExtAddress64.Granularity,
565        Descriptor->ExtAddress64.Flags,
566        MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
567
568    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
569        StringLength;
570    return (Rnode);
571}
572