1 /******************************************************************************
2 *
3 * Module Name: aslrestype2e - Large Extended address resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, 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 *
RsDoExtendedIoDescriptor(ASL_RESOURCE_INFO * Info)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 *
RsDoExtendedMemoryDescriptor(ASL_RESOURCE_INFO * Info)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 *
RsDoExtendedSpaceDescriptor(ASL_RESOURCE_INFO * Info)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