1 /******************************************************************************
2 *
3 * Module Name: aslrestype2q - Large QWord address resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2022, 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 MERCHANTABILITY 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 #include "aslcompiler.y.h"
46
47 #define _COMPONENT ACPI_COMPILER
48 ACPI_MODULE_NAME ("aslrestype2q")
49
50 /*
51 * This module contains the QWord (64-bit) address space descriptors:
52 *
53 * QWordIO
54 * QWordMemory
55 * QWordSpace
56 */
57
58 /*******************************************************************************
59 *
60 * FUNCTION: RsDoQwordIoDescriptor
61 *
62 * PARAMETERS: Info - Parse Op and resource template offset
63 *
64 * RETURN: Completed resource node
65 *
66 * DESCRIPTION: Construct a long "QwordIO" descriptor
67 *
68 ******************************************************************************/
69
70 ASL_RESOURCE_NODE *
RsDoQwordIoDescriptor(ASL_RESOURCE_INFO * Info)71 RsDoQwordIoDescriptor (
72 ASL_RESOURCE_INFO *Info)
73 {
74 AML_RESOURCE *Descriptor;
75 ACPI_PARSE_OBJECT *InitializerOp;
76 ACPI_PARSE_OBJECT *MinOp = NULL;
77 ACPI_PARSE_OBJECT *MaxOp = NULL;
78 ACPI_PARSE_OBJECT *LengthOp = NULL;
79 ACPI_PARSE_OBJECT *GranOp = NULL;
80 ASL_RESOURCE_NODE *Rnode;
81 UINT8 *OptionalFields;
82 UINT16 StringLength = 0;
83 UINT32 OptionIndex = 0;
84 UINT32 CurrentByteOffset;
85 UINT32 i;
86 BOOLEAN ResSourceIndex = FALSE;
87
88
89 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
90 StringLength = RsGetStringDataLength (InitializerOp);
91 CurrentByteOffset = Info->CurrentByteOffset;
92
93 Rnode = RsAllocateResourceNode (
94 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
95
96 Descriptor = Rnode->Buffer;
97 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
98 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
99
100 /*
101 * Initial descriptor length -- may be enlarged if there are
102 * optional fields present
103 */
104 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
105 Descriptor->Address64.ResourceLength = (UINT16)
106 (sizeof (AML_RESOURCE_ADDRESS64) -
107 sizeof (AML_RESOURCE_LARGE_HEADER));
108
109 /* Process all child initialization nodes */
110
111 for (i = 0; InitializerOp; i++)
112 {
113 switch (i)
114 {
115 case 0: /* Resource Usage */
116
117 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
118 break;
119
120 case 1: /* MinType */
121
122 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
124 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
125 break;
126
127 case 2: /* MaxType */
128
129 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
130 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
131 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
132 break;
133
134 case 3: /* DecodeType */
135
136 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
137 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
138 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
139 break;
140
141 case 4: /* Range Type */
142
143 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
144 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
145 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0, 2);
146 break;
147
148 case 5: /* Address Granularity */
149
150 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
151 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
152 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
153 GranOp = InitializerOp;
154 break;
155
156 case 6: /* Address Min */
157
158 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
159 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
160 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
161 MinOp = InitializerOp;
162 break;
163
164 case 7: /* Address Max */
165
166 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
167 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
168 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
169 MaxOp = InitializerOp;
170 break;
171
172 case 8: /* Translation Offset */
173
174 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
175 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
176 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
177 break;
178
179 case 9: /* Address Length */
180
181 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
182 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
183 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
184 LengthOp = InitializerOp;
185 break;
186
187 case 10: /* ResSourceIndex [Optional Field - BYTE] */
188
189 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
190 {
191 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
192 OptionIndex++;
193 Descriptor->Address64.ResourceLength++;
194 ResSourceIndex = TRUE;
195 }
196 break;
197
198 case 11: /* ResSource [Optional Field - STRING] */
199
200 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
201 (InitializerOp->Asl.Value.String))
202 {
203 if (StringLength)
204 {
205 Descriptor->Address64.ResourceLength = (UINT16)
206 (Descriptor->Address64.ResourceLength + StringLength);
207
208 strcpy ((char *)
209 &OptionalFields[OptionIndex],
210 InitializerOp->Asl.Value.String);
211
212 /* ResourceSourceIndex must also be valid */
213
214 if (!ResSourceIndex)
215 {
216 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
217 InitializerOp, NULL);
218 }
219 }
220 }
221
222 #if 0
223 /*
224 * Not a valid ResourceSource, ResourceSourceIndex must also
225 * be invalid
226 */
227 else if (ResSourceIndex)
228 {
229 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
230 InitializerOp, NULL);
231 }
232 #endif
233 break;
234
235 case 12: /* ResourceTag */
236
237 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
238 break;
239
240 case 13: /* Type */
241
242 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
243 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
244 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
245 break;
246
247 case 14: /* Translation Type */
248
249 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
250 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
251 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
252 break;
253
254 default:
255
256 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
257 break;
258 }
259
260 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
261 }
262
263 /* Validate the Min/Max/Len/Gran values */
264
265 RsLargeAddressCheck (
266 Descriptor->Address64.Minimum,
267 Descriptor->Address64.Maximum,
268 Descriptor->Address64.AddressLength,
269 Descriptor->Address64.Granularity,
270 Descriptor->Address64.Flags,
271 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
272
273 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
274 OptionIndex + StringLength;
275 return (Rnode);
276 }
277
278
279 /*******************************************************************************
280 *
281 * FUNCTION: RsDoQwordMemoryDescriptor
282 *
283 * PARAMETERS: Info - Parse Op and resource template offset
284 *
285 * RETURN: Completed resource node
286 *
287 * DESCRIPTION: Construct a long "QwordMemory" descriptor
288 *
289 ******************************************************************************/
290
291 ASL_RESOURCE_NODE *
RsDoQwordMemoryDescriptor(ASL_RESOURCE_INFO * Info)292 RsDoQwordMemoryDescriptor (
293 ASL_RESOURCE_INFO *Info)
294 {
295 AML_RESOURCE *Descriptor;
296 ACPI_PARSE_OBJECT *InitializerOp;
297 ACPI_PARSE_OBJECT *MinOp = NULL;
298 ACPI_PARSE_OBJECT *MaxOp = NULL;
299 ACPI_PARSE_OBJECT *LengthOp = NULL;
300 ACPI_PARSE_OBJECT *GranOp = NULL;
301 ASL_RESOURCE_NODE *Rnode;
302 UINT8 *OptionalFields;
303 UINT16 StringLength = 0;
304 UINT32 OptionIndex = 0;
305 UINT32 CurrentByteOffset;
306 UINT32 i;
307 BOOLEAN ResSourceIndex = FALSE;
308
309
310 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
311 StringLength = RsGetStringDataLength (InitializerOp);
312 CurrentByteOffset = Info->CurrentByteOffset;
313
314 Rnode = RsAllocateResourceNode (
315 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
316
317 Descriptor = Rnode->Buffer;
318 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
319 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
320
321 /*
322 * Initial descriptor length -- may be enlarged if there are
323 * optional fields present
324 */
325 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
326 Descriptor->Address64.ResourceLength = (UINT16)
327 (sizeof (AML_RESOURCE_ADDRESS64) -
328 sizeof (AML_RESOURCE_LARGE_HEADER));
329
330 /* Process all child initialization nodes */
331
332 for (i = 0; InitializerOp; i++)
333 {
334 switch (i)
335 {
336 case 0: /* Resource Usage */
337
338 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
339 break;
340
341 case 1: /* DecodeType */
342
343 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
344 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
345 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
346 break;
347
348 case 2: /* MinType */
349
350 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
351 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
352 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
353 break;
354
355 case 3: /* MaxType */
356
357 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
358 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
359 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
360 break;
361
362 case 4: /* Memory Type */
363
364 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
365 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
366 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
367 break;
368
369 case 5: /* Read/Write Type */
370
371 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
372 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
373 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
374 break;
375
376 case 6: /* Address Granularity */
377
378 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
379 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
380 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
381 GranOp = InitializerOp;
382 break;
383
384 case 7: /* Min Address */
385
386 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
387 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
388 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
389 MinOp = InitializerOp;
390 break;
391
392 case 8: /* Max Address */
393
394 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
395 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
396 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
397 MaxOp = InitializerOp;
398 break;
399
400 case 9: /* Translation Offset */
401
402 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
403 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
404 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
405 break;
406
407 case 10: /* Address Length */
408
409 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
410 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
411 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
412 LengthOp = InitializerOp;
413 break;
414
415 case 11: /* ResSourceIndex [Optional Field - BYTE] */
416
417 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
418 {
419 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
420 OptionIndex++;
421 Descriptor->Address64.ResourceLength++;
422 ResSourceIndex = TRUE;
423 }
424 break;
425
426 case 12: /* ResSource [Optional Field - STRING] */
427
428 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
429 (InitializerOp->Asl.Value.String))
430 {
431 if (StringLength)
432 {
433 Descriptor->Address64.ResourceLength = (UINT16)
434 (Descriptor->Address64.ResourceLength + StringLength);
435
436 strcpy ((char *)
437 &OptionalFields[OptionIndex],
438 InitializerOp->Asl.Value.String);
439
440 /* ResourceSourceIndex must also be valid */
441
442 if (!ResSourceIndex)
443 {
444 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
445 InitializerOp, NULL);
446 }
447 }
448 }
449
450 #if 0
451 /*
452 * Not a valid ResourceSource, ResourceSourceIndex must also
453 * be invalid
454 */
455 else if (ResSourceIndex)
456 {
457 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
458 InitializerOp, NULL);
459 }
460 #endif
461 break;
462
463 case 13: /* ResourceTag */
464
465 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
466 break;
467
468
469 case 14: /* Address Range */
470
471 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
472 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
473 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
474 break;
475
476 case 15: /* Type */
477
478 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
479 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
480 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
481 break;
482
483 default:
484
485 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
486 break;
487 }
488
489 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
490 }
491
492 /* Validate the Min/Max/Len/Gran values */
493
494 RsLargeAddressCheck (
495 Descriptor->Address64.Minimum,
496 Descriptor->Address64.Maximum,
497 Descriptor->Address64.AddressLength,
498 Descriptor->Address64.Granularity,
499 Descriptor->Address64.Flags,
500 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
501
502 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
503 OptionIndex + StringLength;
504 return (Rnode);
505 }
506
507
508 /*******************************************************************************
509 *
510 * FUNCTION: RsDoQwordSpaceDescriptor
511 *
512 * PARAMETERS: Info - Parse Op and resource template offset
513 *
514 * RETURN: Completed resource node
515 *
516 * DESCRIPTION: Construct a long "QwordSpace" descriptor
517 *
518 ******************************************************************************/
519
520 ASL_RESOURCE_NODE *
RsDoQwordSpaceDescriptor(ASL_RESOURCE_INFO * Info)521 RsDoQwordSpaceDescriptor (
522 ASL_RESOURCE_INFO *Info)
523 {
524 AML_RESOURCE *Descriptor;
525 ACPI_PARSE_OBJECT *InitializerOp;
526 ACPI_PARSE_OBJECT *MinOp = NULL;
527 ACPI_PARSE_OBJECT *MaxOp = NULL;
528 ACPI_PARSE_OBJECT *LengthOp = NULL;
529 ACPI_PARSE_OBJECT *GranOp = NULL;
530 ASL_RESOURCE_NODE *Rnode;
531 UINT8 *OptionalFields;
532 UINT16 StringLength = 0;
533 UINT32 OptionIndex = 0;
534 UINT32 CurrentByteOffset;
535 UINT32 i;
536 BOOLEAN ResSourceIndex = FALSE;
537
538
539 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
540 StringLength = RsGetStringDataLength (InitializerOp);
541 CurrentByteOffset = Info->CurrentByteOffset;
542
543 Rnode = RsAllocateResourceNode (
544 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
545
546 Descriptor = Rnode->Buffer;
547 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
548
549 /*
550 * Initial descriptor length -- may be enlarged if there are
551 * optional fields present
552 */
553 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
554 Descriptor->Address64.ResourceLength = (UINT16)
555 (sizeof (AML_RESOURCE_ADDRESS64) -
556 sizeof (AML_RESOURCE_LARGE_HEADER));
557
558 /* Process all child initialization nodes */
559
560 for (i = 0; InitializerOp; i++)
561 {
562 switch (i)
563 {
564 case 0: /* Resource Type */
565
566 Descriptor->Address64.ResourceType =
567 (UINT8) InitializerOp->Asl.Value.Integer;
568 break;
569
570 case 1: /* Resource Usage */
571
572 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
573 break;
574
575 case 2: /* DecodeType */
576
577 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
578 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
579 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
580 break;
581
582 case 3: /* MinType */
583
584 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
585 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
586 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
587 break;
588
589 case 4: /* MaxType */
590
591 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
592 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
593 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
594 break;
595
596 case 5: /* Type-Specific flags */
597
598 Descriptor->Address64.SpecificFlags =
599 (UINT8) InitializerOp->Asl.Value.Integer;
600 break;
601
602 case 6: /* Address Granularity */
603
604 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
605 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
606 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
607 GranOp = InitializerOp;
608 break;
609
610 case 7: /* Min Address */
611
612 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
613 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
614 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
615 MinOp = InitializerOp;
616 break;
617
618 case 8: /* Max Address */
619
620 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
621 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
622 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
623 MaxOp = InitializerOp;
624 break;
625
626 case 9: /* Translation Offset */
627
628 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
629 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
630 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
631 break;
632
633 case 10: /* Address Length */
634
635 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
636 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
637 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
638 LengthOp = InitializerOp;
639 break;
640
641 case 11: /* ResSourceIndex [Optional Field - BYTE] */
642
643 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
644 {
645 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
646 OptionIndex++;
647 Descriptor->Address64.ResourceLength++;
648 ResSourceIndex = TRUE;
649 }
650 break;
651
652 case 12: /* ResSource [Optional Field - STRING] */
653
654 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
655 (InitializerOp->Asl.Value.String))
656 {
657 if (StringLength)
658 {
659 Descriptor->Address64.ResourceLength = (UINT16)
660 (Descriptor->Address64.ResourceLength + StringLength);
661
662 strcpy ((char *)
663 &OptionalFields[OptionIndex],
664 InitializerOp->Asl.Value.String);
665
666 /* ResourceSourceIndex must also be valid */
667
668 if (!ResSourceIndex)
669 {
670 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
671 InitializerOp, NULL);
672 }
673 }
674 }
675
676 #if 0
677 /*
678 * Not a valid ResourceSource, ResourceSourceIndex must also
679 * be invalid
680 */
681 else if (ResSourceIndex)
682 {
683 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
684 InitializerOp, NULL);
685 }
686 #endif
687 break;
688
689 case 13: /* ResourceTag */
690
691 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
692 break;
693
694 default:
695
696 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
697 break;
698 }
699
700 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
701 }
702
703 /* Validate the Min/Max/Len/Gran values */
704
705 RsLargeAddressCheck (
706 Descriptor->Address64.Minimum,
707 Descriptor->Address64.Maximum,
708 Descriptor->Address64.AddressLength,
709 Descriptor->Address64.Granularity,
710 Descriptor->Address64.Flags,
711 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
712
713 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
714 OptionIndex + StringLength;
715 return (Rnode);
716 }
717