1
2/******************************************************************************
3 *
4 * Module Name: aslrestype2e - Large Extended address resource descriptors
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions, and the following disclaimer,
17 *    without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 *    substantially similar to the "NO WARRANTY" disclaimer below
20 *    ("Disclaimer") and any redistribution must be conditioned upon
21 *    including a substantially similar Disclaimer requirement for further
22 *    binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 *    of any contributors may be used to endorse or promote products derived
25 *    from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45
46#include <contrib/dev/acpica/compiler/aslcompiler.h>
47
48#define _COMPONENT          ACPI_COMPILER
49        ACPI_MODULE_NAME    ("aslrestype2e")
50
51/*
52 * This module contains the Extended (64-bit) address space descriptors:
53 *
54 * ExtendedIO
55 * ExtendedMemory
56 * ExtendedSpace
57 */
58
59/*******************************************************************************
60 *
61 * FUNCTION:    RsDoExtendedIoDescriptor
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 "ExtendedIO" descriptor
70 *
71 ******************************************************************************/
72
73ASL_RESOURCE_NODE *
74RsDoExtendedIoDescriptor (
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    UINT16                  StringLength = 0;
86    UINT32                  i;
87
88
89    InitializerOp = Op->Asl.Child;
90    StringLength = RsGetStringDataLength (InitializerOp);
91
92    Rnode = RsAllocateResourceNode (
93                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
94
95    Descriptor = Rnode->Buffer;
96    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
97    Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
98    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
99
100    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
101        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
102         sizeof (AML_RESOURCE_LARGE_HEADER));
103
104    /* Process all child initialization nodes */
105
106    for (i = 0; InitializerOp; i++)
107    {
108        switch (i)
109        {
110        case 0: /* Resource Usage */
111
112            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
113            break;
114
115        case 1: /* MinType */
116
117            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
118            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
119                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
120            break;
121
122        case 2: /* MaxType */
123
124            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
125            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
126                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
127            break;
128
129        case 3: /* DecodeType */
130
131            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
132            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
133                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
134            break;
135
136        case 4: /* Range Type */
137
138            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
139            RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
140                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
141            break;
142
143        case 5: /* Address Granularity */
144
145            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
146            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
147                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
148            GranOp = InitializerOp;
149           break;
150
151        case 6: /* Address Min */
152
153            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
154            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
155                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
156            MinOp = InitializerOp;
157            break;
158
159        case 7: /* Address Max */
160
161            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
162            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
163                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
164            MaxOp = InitializerOp;
165            break;
166
167        case 8: /* Translation Offset */
168
169            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
170            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
171                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
172            break;
173
174        case 9: /* Address Length */
175
176            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
177            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
178                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
179            LengthOp = InitializerOp;
180            break;
181
182        case 10: /* Type-Specific Attributes */
183
184            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
185            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
186                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
187            break;
188
189        case 11: /* ResourceTag */
190
191            UtAttachNamepathToOwner (Op, InitializerOp);
192            break;
193
194        case 12: /* Type */
195
196            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
197            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
198                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
199            break;
200
201        case 13: /* Translation Type */
202
203            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
204            RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
205                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
206            break;
207
208        default:
209
210            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
211            break;
212        }
213
214        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
215    }
216
217    /* Validate the Min/Max/Len/Gran values */
218
219    RsLargeAddressCheck (
220        Descriptor->ExtAddress64.Minimum,
221        Descriptor->ExtAddress64.Maximum,
222        Descriptor->ExtAddress64.AddressLength,
223        Descriptor->ExtAddress64.Granularity,
224        Descriptor->ExtAddress64.Flags,
225        MinOp, MaxOp, LengthOp, GranOp, Op);
226
227    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
228    return (Rnode);
229}
230
231
232/*******************************************************************************
233 *
234 * FUNCTION:    RsDoExtendedMemoryDescriptor
235 *
236 * PARAMETERS:  Op                  - Parent resource descriptor parse node
237 *              CurrentByteOffset   - Offset into the resource template AML
238 *                                    buffer (to track references to the desc)
239 *
240 * RETURN:      Completed resource node
241 *
242 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
243 *
244 ******************************************************************************/
245
246ASL_RESOURCE_NODE *
247RsDoExtendedMemoryDescriptor (
248    ACPI_PARSE_OBJECT       *Op,
249    UINT32                  CurrentByteOffset)
250{
251    AML_RESOURCE            *Descriptor;
252    ACPI_PARSE_OBJECT       *InitializerOp;
253    ACPI_PARSE_OBJECT       *MinOp = NULL;
254    ACPI_PARSE_OBJECT       *MaxOp = NULL;
255    ACPI_PARSE_OBJECT       *LengthOp = NULL;
256    ACPI_PARSE_OBJECT       *GranOp = NULL;
257    ASL_RESOURCE_NODE       *Rnode;
258    UINT16                  StringLength = 0;
259    UINT32                  i;
260
261
262    InitializerOp = Op->Asl.Child;
263    StringLength = RsGetStringDataLength (InitializerOp);
264
265    Rnode = RsAllocateResourceNode (
266                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
267
268    Descriptor = Rnode->Buffer;
269    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
270    Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
271    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
272
273    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
274        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
275         sizeof (AML_RESOURCE_LARGE_HEADER));
276
277    /* Process all child initialization nodes */
278
279    for (i = 0; InitializerOp; i++)
280    {
281        switch (i)
282        {
283        case 0: /* Resource Usage */
284
285            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
286            break;
287
288        case 1: /* DecodeType */
289
290            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
291            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
292                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
293            break;
294
295        case 2: /* MinType */
296
297            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
298            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
299                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
300            break;
301
302        case 3: /* MaxType */
303
304            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
305            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
306                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
307            break;
308
309        case 4: /* Memory Type */
310
311            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
312            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
313                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
314            break;
315
316        case 5: /* Read/Write Type */
317
318            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
319            RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
320                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
321            break;
322
323        case 6: /* Address Granularity */
324
325            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
326            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
327                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
328            GranOp = InitializerOp;
329            break;
330
331        case 7: /* Min Address */
332
333            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
334            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
335                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
336            MinOp = InitializerOp;
337            break;
338
339        case 8: /* Max Address */
340
341            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
342            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
343                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
344            MaxOp = InitializerOp;
345            break;
346
347        case 9: /* Translation Offset */
348
349            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
350            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
351                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
352            break;
353
354        case 10: /* Address Length */
355
356            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
357            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
358                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
359            LengthOp = InitializerOp;
360            break;
361
362        case 11: /* Type-Specific Attributes */
363
364            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
365            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
366                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
367            break;
368
369        case 12: /* ResourceTag */
370
371            UtAttachNamepathToOwner (Op, InitializerOp);
372            break;
373
374
375        case 13: /* Address Range */
376
377            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
378            RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
379                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
380            break;
381
382        case 14: /* Type */
383
384            RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
385            RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
386                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
387            break;
388
389        default:
390
391            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
392            break;
393        }
394
395        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
396    }
397
398    /* Validate the Min/Max/Len/Gran values */
399
400    RsLargeAddressCheck (
401        Descriptor->ExtAddress64.Minimum,
402        Descriptor->ExtAddress64.Maximum,
403        Descriptor->ExtAddress64.AddressLength,
404        Descriptor->ExtAddress64.Granularity,
405        Descriptor->ExtAddress64.Flags,
406        MinOp, MaxOp, LengthOp, GranOp, Op);
407
408    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
409    return (Rnode);
410}
411
412
413/*******************************************************************************
414 *
415 * FUNCTION:    RsDoExtendedSpaceDescriptor
416 *
417 * PARAMETERS:  Op                  - Parent resource descriptor parse node
418 *              CurrentByteOffset   - Offset into the resource template AML
419 *                                    buffer (to track references to the desc)
420 *
421 * RETURN:      Completed resource node
422 *
423 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
424 *
425 ******************************************************************************/
426
427ASL_RESOURCE_NODE *
428RsDoExtendedSpaceDescriptor (
429    ACPI_PARSE_OBJECT       *Op,
430    UINT32                  CurrentByteOffset)
431{
432    AML_RESOURCE            *Descriptor;
433    ACPI_PARSE_OBJECT       *InitializerOp;
434    ACPI_PARSE_OBJECT       *MinOp = NULL;
435    ACPI_PARSE_OBJECT       *MaxOp = NULL;
436    ACPI_PARSE_OBJECT       *LengthOp = NULL;
437    ACPI_PARSE_OBJECT       *GranOp = NULL;
438    ASL_RESOURCE_NODE       *Rnode;
439    UINT16                  StringLength = 0;
440    UINT32                  i;
441
442
443    InitializerOp = Op->Asl.Child;
444    StringLength = RsGetStringDataLength (InitializerOp);
445
446    Rnode = RsAllocateResourceNode (
447                sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
448
449    Descriptor = Rnode->Buffer;
450    Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
451    Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
452
453    Descriptor->ExtAddress64.ResourceLength  = (UINT16)
454        (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
455         sizeof (AML_RESOURCE_LARGE_HEADER));
456
457    /* Process all child initialization nodes */
458
459    for (i = 0; InitializerOp; i++)
460    {
461        switch (i)
462        {
463        case 0: /* Resource Type */
464
465            Descriptor->ExtAddress64.ResourceType =
466                (UINT8) InitializerOp->Asl.Value.Integer;
467            break;
468
469        case 1: /* Resource Usage */
470
471            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
472            break;
473
474        case 2: /* DecodeType */
475
476            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
477            RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
478                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
479            break;
480
481        case 3: /* MinType */
482
483            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
484            RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
485                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
486            break;
487
488        case 4: /* MaxType */
489
490            RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
491            RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
492                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
493            break;
494
495        case 5: /* Type-Specific flags */
496
497            Descriptor->ExtAddress64.SpecificFlags =
498                (UINT8) InitializerOp->Asl.Value.Integer;
499            break;
500
501        case 6: /* Address Granularity */
502
503            Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
504            RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
505                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
506            GranOp = InitializerOp;
507            break;
508
509        case 7: /* Min Address */
510
511            Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
512            RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
513                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
514            MinOp = InitializerOp;
515            break;
516
517        case 8: /* Max Address */
518
519            Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
520            RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
521                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
522            MaxOp = InitializerOp;
523            break;
524
525        case 9: /* Translation Offset */
526
527            Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
528            RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
529                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
530            break;
531
532        case 10: /* Address Length */
533
534            Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
535            RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
536                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
537            LengthOp = InitializerOp;
538            break;
539
540        case 11: /* Type-Specific Attributes */
541
542            Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
543            RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
544                CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
545            break;
546
547        case 12: /* ResourceTag */
548
549            UtAttachNamepathToOwner (Op, InitializerOp);
550            break;
551
552        default:
553
554            AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
555            break;
556        }
557
558        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
559    }
560
561    /* Validate the Min/Max/Len/Gran values */
562
563    RsLargeAddressCheck (
564        Descriptor->ExtAddress64.Minimum,
565        Descriptor->ExtAddress64.Maximum,
566        Descriptor->ExtAddress64.AddressLength,
567        Descriptor->ExtAddress64.Granularity,
568        Descriptor->ExtAddress64.Flags,
569        MinOp, MaxOp, LengthOp, GranOp, Op);
570
571    Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
572    return (Rnode);
573}
574