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