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 "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 
72 ASL_RESOURCE_NODE *
73 RsDoExtendedIoDescriptor (
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 
245 ASL_RESOURCE_NODE *
246 RsDoExtendedMemoryDescriptor (
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 
426 ASL_RESOURCE_NODE *
427 RsDoExtendedSpaceDescriptor (
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