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 "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 
69 ASL_RESOURCE_NODE *
70 RsDoExtendedIoDescriptor (
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 
242 ASL_RESOURCE_NODE *
243 RsDoExtendedMemoryDescriptor (
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 
423 ASL_RESOURCE_NODE *
424 RsDoExtendedSpaceDescriptor (
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