1 /******************************************************************************
3 * Module Name: aslrestype2w - Large Word address resource descriptors
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2015, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
45 #include "aslcompiler.y.h"
47 #define _COMPONENT ACPI_COMPILER
48 ACPI_MODULE_NAME ("aslrestype2w")
51 * This module contains the Word (16-bit) address space descriptors:
58 /*******************************************************************************
60 * FUNCTION: RsDoWordIoDescriptor
62 * PARAMETERS: Info - Parse Op and resource template offset
64 * RETURN: Completed resource node
66 * DESCRIPTION: Construct a long "WordIO" descriptor
68 ******************************************************************************/
71 RsDoWordIoDescriptor (
72 ASL_RESOURCE_INFO *Info)
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;
86 BOOLEAN ResSourceIndex = FALSE;
89 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
90 StringLength = RsGetStringDataLength (InitializerOp);
91 CurrentByteOffset = Info->CurrentByteOffset;
93 Rnode = RsAllocateResourceNode (
94 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
96 Descriptor = Rnode->Buffer;
97 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
98 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
101 * Initial descriptor length -- may be enlarged if there are
102 * optional fields present
104 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
105 Descriptor->Address16.ResourceLength = (UINT16)
106 (sizeof (AML_RESOURCE_ADDRESS16) -
107 sizeof (AML_RESOURCE_LARGE_HEADER));
109 /* Process all child initialization nodes */
111 for (i = 0; InitializerOp; i++)
115 case 0: /* Resource Usage */
117 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
120 case 1: /* MinType */
122 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
124 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
127 case 2: /* MaxType */
129 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
130 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
131 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
134 case 3: /* DecodeType */
136 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
137 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
138 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
141 case 4: /* Range Type */
143 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
144 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
145 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0, 2);
148 case 5: /* Address Granularity */
150 Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
151 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
152 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
153 GranOp = InitializerOp;
156 case 6: /* Address Min */
158 Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
159 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
160 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
161 MinOp = InitializerOp;
164 case 7: /* Address Max */
166 Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
167 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
168 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
169 MaxOp = InitializerOp;
172 case 8: /* Translation Offset */
174 Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
175 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
176 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
179 case 9: /* Address Length */
181 Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
182 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
183 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
184 LengthOp = InitializerOp;
187 case 10: /* ResSourceIndex [Optional Field - BYTE] */
189 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
191 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
193 Descriptor->Address16.ResourceLength++;
194 ResSourceIndex = TRUE;
198 case 11: /* ResSource [Optional Field - STRING] */
200 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
201 (InitializerOp->Asl.Value.String))
205 Descriptor->Address16.ResourceLength = (UINT16)
206 (Descriptor->Address16.ResourceLength + StringLength);
209 &OptionalFields[OptionIndex],
210 InitializerOp->Asl.Value.String);
212 /* ResourceSourceIndex must also be valid */
216 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
217 InitializerOp, NULL);
224 * Not a valid ResourceSource, ResourceSourceIndex must also
227 else if (ResSourceIndex)
229 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
230 InitializerOp, NULL);
235 case 12: /* ResourceTag */
237 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
242 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0);
243 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
244 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4);
247 case 14: /* Translation Type */
249 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0);
250 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
251 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5);
256 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
260 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
263 /* Validate the Min/Max/Len/Gran values */
265 RsLargeAddressCheck (
266 (UINT64) Descriptor->Address16.Minimum,
267 (UINT64) Descriptor->Address16.Maximum,
268 (UINT64) Descriptor->Address16.AddressLength,
269 (UINT64) Descriptor->Address16.Granularity,
270 Descriptor->Address16.Flags,
271 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
273 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
274 OptionIndex + StringLength;
279 /*******************************************************************************
281 * FUNCTION: RsDoWordBusNumberDescriptor
283 * PARAMETERS: Info - Parse Op and resource template offset
285 * RETURN: Completed resource node
287 * DESCRIPTION: Construct a long "WordBusNumber" descriptor
289 ******************************************************************************/
292 RsDoWordBusNumberDescriptor (
293 ASL_RESOURCE_INFO *Info)
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;
307 BOOLEAN ResSourceIndex = FALSE;
310 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
311 StringLength = RsGetStringDataLength (InitializerOp);
312 CurrentByteOffset = Info->CurrentByteOffset;
314 Rnode = RsAllocateResourceNode (
315 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
317 Descriptor = Rnode->Buffer;
318 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
319 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE;
322 * Initial descriptor length -- may be enlarged if there are
323 * optional fields present
325 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
326 Descriptor->Address16.ResourceLength = (UINT16)
327 (sizeof (AML_RESOURCE_ADDRESS16) -
328 sizeof (AML_RESOURCE_LARGE_HEADER));
330 /* Process all child initialization nodes */
332 for (i = 0; InitializerOp; i++)
336 case 0: /* Resource Usage */
338 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
341 case 1: /* MinType */
343 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
344 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
345 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
348 case 2: /* MaxType */
350 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
351 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
352 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
355 case 3: /* DecodeType */
357 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
358 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
359 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
362 case 4: /* Address Granularity */
364 Descriptor->Address16.Granularity =
365 (UINT16) InitializerOp->Asl.Value.Integer;
366 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
367 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
368 GranOp = InitializerOp;
371 case 5: /* Min Address */
373 Descriptor->Address16.Minimum =
374 (UINT16) InitializerOp->Asl.Value.Integer;
375 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
376 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
377 MinOp = InitializerOp;
380 case 6: /* Max Address */
382 Descriptor->Address16.Maximum =
383 (UINT16) InitializerOp->Asl.Value.Integer;
384 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
385 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
386 MaxOp = InitializerOp;
389 case 7: /* Translation Offset */
391 Descriptor->Address16.TranslationOffset =
392 (UINT16) InitializerOp->Asl.Value.Integer;
393 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
394 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
397 case 8: /* Address Length */
399 Descriptor->Address16.AddressLength =
400 (UINT16) InitializerOp->Asl.Value.Integer;
401 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
402 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
403 LengthOp = InitializerOp;
406 case 9: /* ResSourceIndex [Optional Field - BYTE] */
408 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
410 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
412 Descriptor->Address16.ResourceLength++;
413 ResSourceIndex = TRUE;
417 case 10: /* ResSource [Optional Field - STRING] */
419 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
420 (InitializerOp->Asl.Value.String))
424 Descriptor->Address16.ResourceLength = (UINT16)
425 (Descriptor->Address16.ResourceLength + StringLength);
428 &OptionalFields[OptionIndex],
429 InitializerOp->Asl.Value.String);
431 /* ResourceSourceIndex must also be valid */
435 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
436 InitializerOp, NULL);
443 * Not a valid ResourceSource, ResourceSourceIndex must also
446 else if (ResSourceIndex)
448 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
449 InitializerOp, NULL);
454 case 11: /* ResourceTag */
456 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
461 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
465 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
468 /* Validate the Min/Max/Len/Gran values */
470 RsLargeAddressCheck (
471 (UINT64) Descriptor->Address16.Minimum,
472 (UINT64) Descriptor->Address16.Maximum,
473 (UINT64) Descriptor->Address16.AddressLength,
474 (UINT64) Descriptor->Address16.Granularity,
475 Descriptor->Address16.Flags,
476 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
478 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
479 OptionIndex + StringLength;
484 /*******************************************************************************
486 * FUNCTION: RsDoWordSpaceDescriptor
488 * PARAMETERS: Info - Parse Op and resource template offset
490 * RETURN: Completed resource node
492 * DESCRIPTION: Construct a long "WordSpace" descriptor
494 ******************************************************************************/
497 RsDoWordSpaceDescriptor (
498 ASL_RESOURCE_INFO *Info)
500 AML_RESOURCE *Descriptor;
501 ACPI_PARSE_OBJECT *InitializerOp;
502 ACPI_PARSE_OBJECT *MinOp = NULL;
503 ACPI_PARSE_OBJECT *MaxOp = NULL;
504 ACPI_PARSE_OBJECT *LengthOp = NULL;
505 ACPI_PARSE_OBJECT *GranOp = NULL;
506 ASL_RESOURCE_NODE *Rnode;
507 UINT8 *OptionalFields;
508 UINT16 StringLength = 0;
509 UINT32 OptionIndex = 0;
510 UINT32 CurrentByteOffset;
512 BOOLEAN ResSourceIndex = FALSE;
515 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
516 StringLength = RsGetStringDataLength (InitializerOp);
517 CurrentByteOffset = Info->CurrentByteOffset;
519 Rnode = RsAllocateResourceNode (
520 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
522 Descriptor = Rnode->Buffer;
523 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
526 * Initial descriptor length -- may be enlarged if there are
527 * optional fields present
529 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
530 Descriptor->Address16.ResourceLength = (UINT16)
531 (sizeof (AML_RESOURCE_ADDRESS16) -
532 sizeof (AML_RESOURCE_LARGE_HEADER));
534 /* Process all child initialization nodes */
536 for (i = 0; InitializerOp; i++)
540 case 0: /* Resource Type */
542 Descriptor->Address16.ResourceType =
543 (UINT8) InitializerOp->Asl.Value.Integer;
546 case 1: /* Resource Usage */
548 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
551 case 2: /* DecodeType */
553 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
554 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
555 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
558 case 3: /* MinType */
560 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
561 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
562 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
565 case 4: /* MaxType */
567 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
568 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
569 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
572 case 5: /* Type-Specific flags */
574 Descriptor->Address16.SpecificFlags =
575 (UINT8) InitializerOp->Asl.Value.Integer;
578 case 6: /* Address Granularity */
580 Descriptor->Address16.Granularity =
581 (UINT16) InitializerOp->Asl.Value.Integer;
582 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
583 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
584 GranOp = InitializerOp;
587 case 7: /* Min Address */
589 Descriptor->Address16.Minimum =
590 (UINT16) InitializerOp->Asl.Value.Integer;
591 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
592 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
593 MinOp = InitializerOp;
596 case 8: /* Max Address */
598 Descriptor->Address16.Maximum =
599 (UINT16) InitializerOp->Asl.Value.Integer;
600 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
601 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
602 MaxOp = InitializerOp;
605 case 9: /* Translation Offset */
607 Descriptor->Address16.TranslationOffset =
608 (UINT16) InitializerOp->Asl.Value.Integer;
609 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
610 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
613 case 10: /* Address Length */
615 Descriptor->Address16.AddressLength =
616 (UINT16) InitializerOp->Asl.Value.Integer;
617 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
618 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
619 LengthOp = InitializerOp;
622 case 11: /* ResSourceIndex [Optional Field - BYTE] */
624 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
626 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
628 Descriptor->Address16.ResourceLength++;
629 ResSourceIndex = TRUE;
633 case 12: /* ResSource [Optional Field - STRING] */
635 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
636 (InitializerOp->Asl.Value.String))
640 Descriptor->Address16.ResourceLength = (UINT16)
641 (Descriptor->Address16.ResourceLength + StringLength);
644 &OptionalFields[OptionIndex],
645 InitializerOp->Asl.Value.String);
647 /* ResourceSourceIndex must also be valid */
651 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
652 InitializerOp, NULL);
659 * Not a valid ResourceSource, ResourceSourceIndex must also
662 else if (ResSourceIndex)
664 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
665 InitializerOp, NULL);
670 case 13: /* ResourceTag */
672 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
677 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
681 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
684 /* Validate the Min/Max/Len/Gran values */
686 RsLargeAddressCheck (
687 (UINT64) Descriptor->Address16.Minimum,
688 (UINT64) Descriptor->Address16.Maximum,
689 (UINT64) Descriptor->Address16.AddressLength,
690 (UINT64) Descriptor->Address16.Granularity,
691 Descriptor->Address16.Flags,
692 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
694 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
695 OptionIndex + StringLength;