2 /******************************************************************************
4 * Module Name: aslrestype2 - Long (type2) resource templates and descriptors
6 *****************************************************************************/
8 /******************************************************************************
12 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
13 * All rights reserved.
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
38 * The above copyright and patent license is granted only if the following
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
73 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
81 * 4. Disclaimer and Export Compliance
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
115 *****************************************************************************/
118 #include <contrib/dev/acpica/compiler/aslcompiler.h>
119 #include "aslcompiler.y.h"
121 #define _COMPONENT ACPI_COMPILER
122 ACPI_MODULE_NAME ("aslrestype2")
124 /* Local prototypes */
127 RsGetStringDataLength (
128 ACPI_PARSE_OBJECT *InitializerOp);
131 /*******************************************************************************
133 * FUNCTION: RsGetStringDataLength
135 * PARAMETERS: InitializerOp - Start of a subtree of init nodes
137 * RETURN: Valid string length if a string node is found (otherwise 0)
139 * DESCRIPTION: In a list of peer nodes, find the first one that contains a
140 * string and return the length of the string.
142 ******************************************************************************/
145 RsGetStringDataLength (
146 ACPI_PARSE_OBJECT *InitializerOp)
149 while (InitializerOp)
151 if (InitializerOp->Asl.ParseOpcode == PARSEOP_STRING_LITERAL)
153 return ((UINT16) (strlen (InitializerOp->Asl.Value.String) + 1));
155 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
162 /*******************************************************************************
164 * FUNCTION: RsDoDwordIoDescriptor
166 * PARAMETERS: Op - Parent resource descriptor parse node
167 * CurrentByteOffset - Offset into the resource template AML
168 * buffer (to track references to the desc)
170 * RETURN: Completed resource node
172 * DESCRIPTION: Construct a long "DwordIO" descriptor
174 ******************************************************************************/
177 RsDoDwordIoDescriptor (
178 ACPI_PARSE_OBJECT *Op,
179 UINT32 CurrentByteOffset)
181 AML_RESOURCE *Descriptor;
182 ACPI_PARSE_OBJECT *InitializerOp;
183 ASL_RESOURCE_NODE *Rnode;
184 UINT16 StringLength = 0;
185 UINT32 OptionIndex = 0;
186 UINT8 *OptionalFields;
188 BOOLEAN ResSourceIndex = FALSE;
191 InitializerOp = Op->Asl.Child;
192 StringLength = RsGetStringDataLength (InitializerOp);
194 Rnode = RsAllocateResourceNode (
195 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
197 Descriptor = Rnode->Buffer;
198 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
199 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
202 * Initial descriptor length -- may be enlarged if there are
203 * optional fields present
205 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
206 Descriptor->Address32.ResourceLength = (UINT16)
207 (sizeof (AML_RESOURCE_ADDRESS32) -
208 sizeof (AML_RESOURCE_LARGE_HEADER));
210 /* Process all child initialization nodes */
212 for (i = 0; InitializerOp; i++)
216 case 0: /* Resource Usage */
218 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
221 case 1: /* MinType */
223 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
224 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
225 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
228 case 2: /* MaxType */
230 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
231 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
232 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
235 case 3: /* DecodeType */
237 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
238 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
239 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
242 case 4: /* Range Type */
244 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
245 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
246 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
249 case 5: /* Address Granularity */
251 Descriptor->Address32.Granularity =
252 (UINT32) InitializerOp->Asl.Value.Integer;
253 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
254 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
257 case 6: /* Address Min */
259 Descriptor->Address32.Minimum =
260 (UINT32) InitializerOp->Asl.Value.Integer;
261 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
262 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
265 case 7: /* Address Max */
267 Descriptor->Address32.Maximum =
268 (UINT32) InitializerOp->Asl.Value.Integer;
269 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
270 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
273 case 8: /* Translation Offset */
275 Descriptor->Address32.TranslationOffset =
276 (UINT32) InitializerOp->Asl.Value.Integer;
277 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
278 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
281 case 9: /* Address Length */
283 Descriptor->Address32.AddressLength =
284 (UINT32) InitializerOp->Asl.Value.Integer;
285 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
286 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
289 case 10: /* ResSourceIndex [Optional Field - BYTE] */
291 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
293 /* Found a valid ResourceSourceIndex */
295 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
297 Descriptor->Address32.ResourceLength++;
298 ResSourceIndex = TRUE;
302 case 11: /* ResSource [Optional Field - STRING] */
304 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
305 (InitializerOp->Asl.Value.String))
309 /* Found a valid ResourceSource */
311 Descriptor->Address32.ResourceLength = (UINT16)
312 (Descriptor->Address32.ResourceLength + StringLength);
315 &OptionalFields[OptionIndex],
316 InitializerOp->Asl.Value.String);
318 /* ResourceSourceIndex must also be valid */
322 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
323 InitializerOp, NULL);
330 * Not a valid ResourceSource, ResourceSourceIndex must also
333 else if (ResSourceIndex)
335 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
336 InitializerOp, NULL);
341 case 12: /* ResourceTag */
343 UtAttachNamepathToOwner (Op, InitializerOp);
348 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
349 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
350 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
353 case 14: /* Translation Type */
355 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
356 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
357 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
362 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
366 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
369 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
370 OptionIndex + StringLength;
375 /*******************************************************************************
377 * FUNCTION: RsDoDwordMemoryDescriptor
379 * PARAMETERS: Op - Parent resource descriptor parse node
380 * CurrentByteOffset - Offset into the resource template AML
381 * buffer (to track references to the desc)
383 * RETURN: Completed resource node
385 * DESCRIPTION: Construct a long "DwordMemory" descriptor
387 ******************************************************************************/
390 RsDoDwordMemoryDescriptor (
391 ACPI_PARSE_OBJECT *Op,
392 UINT32 CurrentByteOffset)
394 AML_RESOURCE *Descriptor;
395 ACPI_PARSE_OBJECT *InitializerOp;
396 ASL_RESOURCE_NODE *Rnode;
397 UINT8 *OptionalFields;
398 UINT16 StringLength = 0;
399 UINT32 OptionIndex = 0;
401 BOOLEAN ResSourceIndex = FALSE;
404 InitializerOp = Op->Asl.Child;
405 StringLength = RsGetStringDataLength (InitializerOp);
407 Rnode = RsAllocateResourceNode (
408 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
410 Descriptor = Rnode->Buffer;
411 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
412 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
415 * Initial descriptor length -- may be enlarged if there are
416 * optional fields present
418 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
419 Descriptor->Address32.ResourceLength = (UINT16)
420 (sizeof (AML_RESOURCE_ADDRESS32) -
421 sizeof (AML_RESOURCE_LARGE_HEADER));
424 /* Process all child initialization nodes */
426 for (i = 0; InitializerOp; i++)
430 case 0: /* Resource Usage */
432 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
435 case 1: /* DecodeType */
437 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
438 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
439 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
442 case 2: /* MinType */
444 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
445 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
446 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
449 case 3: /* MaxType */
451 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
452 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
453 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
456 case 4: /* Memory Type */
458 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
459 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
460 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1);
463 case 5: /* Read/Write Type */
465 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
466 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
467 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
470 case 6: /* Address Granularity */
472 Descriptor->Address32.Granularity =
473 (UINT32) InitializerOp->Asl.Value.Integer;
474 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
475 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
478 case 7: /* Min Address */
480 Descriptor->Address32.Minimum =
481 (UINT32) InitializerOp->Asl.Value.Integer;
482 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
483 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
486 case 8: /* Max Address */
488 Descriptor->Address32.Maximum =
489 (UINT32) InitializerOp->Asl.Value.Integer;
490 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
491 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
494 case 9: /* Translation Offset */
496 Descriptor->Address32.TranslationOffset =
497 (UINT32) InitializerOp->Asl.Value.Integer;
498 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
499 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
502 case 10: /* Address Length */
504 Descriptor->Address32.AddressLength =
505 (UINT32) InitializerOp->Asl.Value.Integer;
506 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
507 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
510 case 11: /* ResSourceIndex [Optional Field - BYTE] */
512 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
514 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
516 Descriptor->Address32.ResourceLength++;
517 ResSourceIndex = TRUE;
521 case 12: /* ResSource [Optional Field - STRING] */
523 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
524 (InitializerOp->Asl.Value.String))
528 Descriptor->Address32.ResourceLength = (UINT16)
529 (Descriptor->Address32.ResourceLength + StringLength);
532 &OptionalFields[OptionIndex],
533 InitializerOp->Asl.Value.String);
535 /* ResourceSourceIndex must also be valid */
539 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
540 InitializerOp, NULL);
547 * Not a valid ResourceSource, ResourceSourceIndex must also
550 else if (ResSourceIndex)
552 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
553 InitializerOp, NULL);
558 case 13: /* ResourceTag */
560 UtAttachNamepathToOwner (Op, InitializerOp);
564 case 14: /* Address Range */
566 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
567 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
568 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3);
573 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
574 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
575 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
580 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
584 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
587 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
588 OptionIndex + StringLength;
593 /*******************************************************************************
595 * FUNCTION: RsDoDwordSpaceDescriptor
597 * PARAMETERS: Op - Parent resource descriptor parse node
598 * CurrentByteOffset - Offset into the resource template AML
599 * buffer (to track references to the desc)
601 * RETURN: Completed resource node
603 * DESCRIPTION: Construct a long "DwordSpace" descriptor
605 ******************************************************************************/
608 RsDoDwordSpaceDescriptor (
609 ACPI_PARSE_OBJECT *Op,
610 UINT32 CurrentByteOffset)
612 AML_RESOURCE *Descriptor;
613 ACPI_PARSE_OBJECT *InitializerOp;
614 ASL_RESOURCE_NODE *Rnode;
615 UINT8 *OptionalFields;
616 UINT16 StringLength = 0;
617 UINT32 OptionIndex = 0;
619 BOOLEAN ResSourceIndex = FALSE;
622 InitializerOp = Op->Asl.Child;
623 StringLength = RsGetStringDataLength (InitializerOp);
625 Rnode = RsAllocateResourceNode (
626 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
628 Descriptor = Rnode->Buffer;
629 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
632 * Initial descriptor length -- may be enlarged if there are
633 * optional fields present
635 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
636 Descriptor->Address32.ResourceLength = (UINT16)
637 (sizeof (AML_RESOURCE_ADDRESS32) -
638 sizeof (AML_RESOURCE_LARGE_HEADER));
640 /* Process all child initialization nodes */
642 for (i = 0; InitializerOp; i++)
646 case 0: /* Resource Type */
648 Descriptor->Address32.ResourceType =
649 (UINT8) InitializerOp->Asl.Value.Integer;
652 case 1: /* Resource Usage */
654 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
657 case 2: /* DecodeType */
659 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
660 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
661 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
664 case 3: /* MinType */
666 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
667 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
668 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
671 case 4: /* MaxType */
673 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
674 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
675 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
678 case 5: /* Type-Specific flags */
680 Descriptor->Address32.SpecificFlags =
681 (UINT8) InitializerOp->Asl.Value.Integer;
684 case 6: /* Address Granularity */
686 Descriptor->Address32.Granularity =
687 (UINT32) InitializerOp->Asl.Value.Integer;
688 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
689 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
692 case 7: /* Min Address */
694 Descriptor->Address32.Minimum =
695 (UINT32) InitializerOp->Asl.Value.Integer;
696 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
697 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
700 case 8: /* Max Address */
702 Descriptor->Address32.Maximum =
703 (UINT32) InitializerOp->Asl.Value.Integer;
704 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
705 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
708 case 9: /* Translation Offset */
710 Descriptor->Address32.TranslationOffset =
711 (UINT32) InitializerOp->Asl.Value.Integer;
712 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
713 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
716 case 10: /* Address Length */
718 Descriptor->Address32.AddressLength =
719 (UINT32) InitializerOp->Asl.Value.Integer;
720 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
721 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
724 case 11: /* ResSourceIndex [Optional Field - BYTE] */
726 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
728 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
730 Descriptor->Address32.ResourceLength++;
731 ResSourceIndex = TRUE;
735 case 12: /* ResSource [Optional Field - STRING] */
737 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
738 (InitializerOp->Asl.Value.String))
742 Descriptor->Address32.ResourceLength = (UINT16)
743 (Descriptor->Address32.ResourceLength + StringLength);
746 &OptionalFields[OptionIndex],
747 InitializerOp->Asl.Value.String);
749 /* ResourceSourceIndex must also be valid */
753 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
754 InitializerOp, NULL);
761 * Not a valid ResourceSource, ResourceSourceIndex must also
764 else if (ResSourceIndex)
766 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
767 InitializerOp, NULL);
772 case 13: /* ResourceTag */
774 UtAttachNamepathToOwner (Op, InitializerOp);
779 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST,
780 InitializerOp, NULL);
784 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
787 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
788 OptionIndex + StringLength;
793 /*******************************************************************************
795 * FUNCTION: RsDoExtendedIoDescriptor
797 * PARAMETERS: Op - Parent resource descriptor parse node
798 * CurrentByteOffset - Offset into the resource template AML
799 * buffer (to track references to the desc)
801 * RETURN: Completed resource node
803 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
805 ******************************************************************************/
808 RsDoExtendedIoDescriptor (
809 ACPI_PARSE_OBJECT *Op,
810 UINT32 CurrentByteOffset)
812 AML_RESOURCE *Descriptor;
813 ACPI_PARSE_OBJECT *InitializerOp;
814 ASL_RESOURCE_NODE *Rnode;
815 UINT16 StringLength = 0;
819 InitializerOp = Op->Asl.Child;
820 StringLength = RsGetStringDataLength (InitializerOp);
822 Rnode = RsAllocateResourceNode (
823 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
825 Descriptor = Rnode->Buffer;
826 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
827 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
828 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
830 Descriptor->ExtAddress64.ResourceLength = (UINT16)
831 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
832 sizeof (AML_RESOURCE_LARGE_HEADER));
834 /* Process all child initialization nodes */
836 for (i = 0; InitializerOp; i++)
840 case 0: /* Resource Usage */
842 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
845 case 1: /* MinType */
847 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
848 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
849 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
852 case 2: /* MaxType */
854 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
855 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
856 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
859 case 3: /* DecodeType */
861 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
862 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
863 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
866 case 4: /* Range Type */
868 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
869 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
870 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
873 case 5: /* Address Granularity */
875 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
876 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
877 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
880 case 6: /* Address Min */
882 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
883 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
884 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
887 case 7: /* Address Max */
889 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
890 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
891 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
894 case 8: /* Translation Offset */
896 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
897 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
898 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
901 case 9: /* Address Length */
903 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
904 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
905 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
908 case 10: /* Type-Specific Attributes */
910 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
911 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
912 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
915 case 11: /* ResourceTag */
917 UtAttachNamepathToOwner (Op, InitializerOp);
922 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
923 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
924 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
927 case 13: /* Translation Type */
929 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
930 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
931 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
936 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
940 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
943 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
948 /*******************************************************************************
950 * FUNCTION: RsDoExtendedMemoryDescriptor
952 * PARAMETERS: Op - Parent resource descriptor parse node
953 * CurrentByteOffset - Offset into the resource template AML
954 * buffer (to track references to the desc)
956 * RETURN: Completed resource node
958 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
960 ******************************************************************************/
963 RsDoExtendedMemoryDescriptor (
964 ACPI_PARSE_OBJECT *Op,
965 UINT32 CurrentByteOffset)
967 AML_RESOURCE *Descriptor;
968 ACPI_PARSE_OBJECT *InitializerOp;
969 ASL_RESOURCE_NODE *Rnode;
970 UINT16 StringLength = 0;
974 InitializerOp = Op->Asl.Child;
975 StringLength = RsGetStringDataLength (InitializerOp);
977 Rnode = RsAllocateResourceNode (
978 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
980 Descriptor = Rnode->Buffer;
981 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
982 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
983 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
985 Descriptor->ExtAddress64.ResourceLength = (UINT16)
986 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
987 sizeof (AML_RESOURCE_LARGE_HEADER));
989 /* Process all child initialization nodes */
991 for (i = 0; InitializerOp; i++)
995 case 0: /* Resource Usage */
997 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
1000 case 1: /* DecodeType */
1002 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
1003 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1004 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
1007 case 2: /* MinType */
1009 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
1010 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1011 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
1014 case 3: /* MaxType */
1016 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
1017 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1018 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
1021 case 4: /* Memory Type */
1023 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
1024 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
1025 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
1028 case 5: /* Read/Write Type */
1030 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
1031 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
1032 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
1035 case 6: /* Address Granularity */
1037 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
1038 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1039 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
1042 case 7: /* Min Address */
1044 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
1045 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1046 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
1049 case 8: /* Max Address */
1051 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
1052 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1053 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
1056 case 9: /* Translation Offset */
1058 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1059 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1060 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
1063 case 10: /* Address Length */
1065 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
1066 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1067 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
1070 case 11: /* Type-Specific Attributes */
1072 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
1073 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
1074 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
1077 case 12: /* ResourceTag */
1079 UtAttachNamepathToOwner (Op, InitializerOp);
1083 case 13: /* Address Range */
1085 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
1086 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
1087 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
1092 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
1093 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
1094 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
1099 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1103 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1106 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
1111 /*******************************************************************************
1113 * FUNCTION: RsDoExtendedSpaceDescriptor
1115 * PARAMETERS: Op - Parent resource descriptor parse node
1116 * CurrentByteOffset - Offset into the resource template AML
1117 * buffer (to track references to the desc)
1119 * RETURN: Completed resource node
1121 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
1123 ******************************************************************************/
1126 RsDoExtendedSpaceDescriptor (
1127 ACPI_PARSE_OBJECT *Op,
1128 UINT32 CurrentByteOffset)
1130 AML_RESOURCE *Descriptor;
1131 ACPI_PARSE_OBJECT *InitializerOp;
1132 ASL_RESOURCE_NODE *Rnode;
1133 UINT16 StringLength = 0;
1137 InitializerOp = Op->Asl.Child;
1138 StringLength = RsGetStringDataLength (InitializerOp);
1140 Rnode = RsAllocateResourceNode (
1141 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
1143 Descriptor = Rnode->Buffer;
1144 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
1145 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
1147 Descriptor->ExtAddress64.ResourceLength = (UINT16)
1148 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
1149 sizeof (AML_RESOURCE_LARGE_HEADER));
1151 /* Process all child initialization nodes */
1153 for (i = 0; InitializerOp; i++)
1157 case 0: /* Resource Type */
1159 Descriptor->ExtAddress64.ResourceType =
1160 (UINT8) InitializerOp->Asl.Value.Integer;
1163 case 1: /* Resource Usage */
1165 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
1168 case 2: /* DecodeType */
1170 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
1171 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1172 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
1175 case 3: /* MinType */
1177 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
1178 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1179 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
1182 case 4: /* MaxType */
1184 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
1185 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1186 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
1189 case 5: /* Type-Specific flags */
1191 Descriptor->ExtAddress64.SpecificFlags =
1192 (UINT8) InitializerOp->Asl.Value.Integer;
1195 case 6: /* Address Granularity */
1197 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
1198 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1199 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
1202 case 7: /* Min Address */
1204 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
1205 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1206 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
1209 case 8: /* Max Address */
1211 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
1212 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1213 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
1216 case 9: /* Translation Offset */
1218 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1219 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1220 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
1223 case 10: /* Address Length */
1225 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
1226 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1227 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
1230 case 11: /* Type-Specific Attributes */
1232 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
1233 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
1234 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
1237 case 12: /* ResourceTag */
1239 UtAttachNamepathToOwner (Op, InitializerOp);
1244 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1248 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1251 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
1256 /*******************************************************************************
1258 * FUNCTION: RsDoQwordIoDescriptor
1260 * PARAMETERS: Op - Parent resource descriptor parse node
1261 * CurrentByteOffset - Offset into the resource template AML
1262 * buffer (to track references to the desc)
1264 * RETURN: Completed resource node
1266 * DESCRIPTION: Construct a long "QwordIO" descriptor
1268 ******************************************************************************/
1271 RsDoQwordIoDescriptor (
1272 ACPI_PARSE_OBJECT *Op,
1273 UINT32 CurrentByteOffset)
1275 AML_RESOURCE *Descriptor;
1276 ACPI_PARSE_OBJECT *InitializerOp;
1277 ASL_RESOURCE_NODE *Rnode;
1278 UINT8 *OptionalFields;
1279 UINT16 StringLength = 0;
1280 UINT32 OptionIndex = 0;
1282 BOOLEAN ResSourceIndex = FALSE;
1285 InitializerOp = Op->Asl.Child;
1286 StringLength = RsGetStringDataLength (InitializerOp);
1288 Rnode = RsAllocateResourceNode (
1289 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1291 Descriptor = Rnode->Buffer;
1292 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
1293 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
1296 * Initial descriptor length -- may be enlarged if there are
1297 * optional fields present
1299 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1300 Descriptor->Address64.ResourceLength = (UINT16)
1301 (sizeof (AML_RESOURCE_ADDRESS64) -
1302 sizeof (AML_RESOURCE_LARGE_HEADER));
1304 /* Process all child initialization nodes */
1306 for (i = 0; InitializerOp; i++)
1310 case 0: /* Resource Usage */
1312 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1315 case 1: /* MinType */
1317 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1318 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1319 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1322 case 2: /* MaxType */
1324 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1325 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1326 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1329 case 3: /* DecodeType */
1331 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1332 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1333 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1336 case 4: /* Range Type */
1338 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
1339 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
1340 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
1343 case 5: /* Address Granularity */
1345 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1346 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1347 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1350 case 6: /* Address Min */
1352 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1353 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1354 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1357 case 7: /* Address Max */
1359 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1360 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1361 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1364 case 8: /* Translation Offset */
1366 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1367 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1368 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1371 case 9: /* Address Length */
1373 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1374 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1375 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1378 case 10: /* ResSourceIndex [Optional Field - BYTE] */
1380 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1382 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1384 Descriptor->Address64.ResourceLength++;
1385 ResSourceIndex = TRUE;
1389 case 11: /* ResSource [Optional Field - STRING] */
1391 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1392 (InitializerOp->Asl.Value.String))
1396 Descriptor->Address64.ResourceLength = (UINT16)
1397 (Descriptor->Address64.ResourceLength + StringLength);
1400 &OptionalFields[OptionIndex],
1401 InitializerOp->Asl.Value.String);
1403 /* ResourceSourceIndex must also be valid */
1405 if (!ResSourceIndex)
1407 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1408 InitializerOp, NULL);
1415 * Not a valid ResourceSource, ResourceSourceIndex must also
1418 else if (ResSourceIndex)
1420 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1421 InitializerOp, NULL);
1426 case 12: /* ResourceTag */
1428 UtAttachNamepathToOwner (Op, InitializerOp);
1433 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
1434 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
1435 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
1438 case 14: /* Translation Type */
1440 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
1441 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
1442 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
1447 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1451 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1454 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1455 OptionIndex + StringLength;
1460 /*******************************************************************************
1462 * FUNCTION: RsDoQwordMemoryDescriptor
1464 * PARAMETERS: Op - Parent resource descriptor parse node
1465 * CurrentByteOffset - Offset into the resource template AML
1466 * buffer (to track references to the desc)
1468 * RETURN: Completed resource node
1470 * DESCRIPTION: Construct a long "QwordMemory" descriptor
1472 ******************************************************************************/
1475 RsDoQwordMemoryDescriptor (
1476 ACPI_PARSE_OBJECT *Op,
1477 UINT32 CurrentByteOffset)
1479 AML_RESOURCE *Descriptor;
1480 ACPI_PARSE_OBJECT *InitializerOp;
1481 ASL_RESOURCE_NODE *Rnode;
1482 UINT8 *OptionalFields;
1483 UINT16 StringLength = 0;
1484 UINT32 OptionIndex = 0;
1486 BOOLEAN ResSourceIndex = FALSE;
1489 InitializerOp = Op->Asl.Child;
1490 StringLength = RsGetStringDataLength (InitializerOp);
1492 Rnode = RsAllocateResourceNode (
1493 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1495 Descriptor = Rnode->Buffer;
1496 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
1497 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
1500 * Initial descriptor length -- may be enlarged if there are
1501 * optional fields present
1503 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1504 Descriptor->Address64.ResourceLength = (UINT16)
1505 (sizeof (AML_RESOURCE_ADDRESS64) -
1506 sizeof (AML_RESOURCE_LARGE_HEADER));
1508 /* Process all child initialization nodes */
1510 for (i = 0; InitializerOp; i++)
1514 case 0: /* Resource Usage */
1516 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1519 case 1: /* DecodeType */
1521 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1522 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1523 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1526 case 2: /* MinType */
1528 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1529 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1530 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1533 case 3: /* MaxType */
1535 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1536 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1537 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1540 case 4: /* Memory Type */
1542 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
1543 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
1544 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1);
1547 case 5: /* Read/Write Type */
1549 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
1550 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
1551 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
1554 case 6: /* Address Granularity */
1556 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1557 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1558 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1561 case 7: /* Min Address */
1563 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1564 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1565 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1568 case 8: /* Max Address */
1570 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1571 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1572 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1575 case 9: /* Translation Offset */
1577 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1578 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1579 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1582 case 10: /* Address Length */
1584 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1585 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1586 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1589 case 11: /* ResSourceIndex [Optional Field - BYTE] */
1591 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1593 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1595 Descriptor->Address64.ResourceLength++;
1596 ResSourceIndex = TRUE;
1600 case 12: /* ResSource [Optional Field - STRING] */
1602 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1603 (InitializerOp->Asl.Value.String))
1607 Descriptor->Address64.ResourceLength = (UINT16)
1608 (Descriptor->Address64.ResourceLength + StringLength);
1611 &OptionalFields[OptionIndex],
1612 InitializerOp->Asl.Value.String);
1614 /* ResourceSourceIndex must also be valid */
1616 if (!ResSourceIndex)
1618 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1619 InitializerOp, NULL);
1626 * Not a valid ResourceSource, ResourceSourceIndex must also
1629 else if (ResSourceIndex)
1631 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1632 InitializerOp, NULL);
1637 case 13: /* ResourceTag */
1639 UtAttachNamepathToOwner (Op, InitializerOp);
1643 case 14: /* Address Range */
1645 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
1646 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
1647 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3);
1652 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
1653 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
1654 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
1659 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1663 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1666 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1667 OptionIndex + StringLength;
1672 /*******************************************************************************
1674 * FUNCTION: RsDoQwordSpaceDescriptor
1676 * PARAMETERS: Op - Parent resource descriptor parse node
1677 * CurrentByteOffset - Offset into the resource template AML
1678 * buffer (to track references to the desc)
1680 * RETURN: Completed resource node
1682 * DESCRIPTION: Construct a long "QwordSpace" descriptor
1684 ******************************************************************************/
1687 RsDoQwordSpaceDescriptor (
1688 ACPI_PARSE_OBJECT *Op,
1689 UINT32 CurrentByteOffset)
1691 AML_RESOURCE *Descriptor;
1692 ACPI_PARSE_OBJECT *InitializerOp;
1693 ASL_RESOURCE_NODE *Rnode;
1694 UINT8 *OptionalFields;
1695 UINT16 StringLength = 0;
1696 UINT32 OptionIndex = 0;
1698 BOOLEAN ResSourceIndex = FALSE;
1701 InitializerOp = Op->Asl.Child;
1702 StringLength = RsGetStringDataLength (InitializerOp);
1704 Rnode = RsAllocateResourceNode (
1705 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1707 Descriptor = Rnode->Buffer;
1708 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
1711 * Initial descriptor length -- may be enlarged if there are
1712 * optional fields present
1714 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1715 Descriptor->Address64.ResourceLength = (UINT16)
1716 (sizeof (AML_RESOURCE_ADDRESS64) -
1717 sizeof (AML_RESOURCE_LARGE_HEADER));
1719 /* Process all child initialization nodes */
1721 for (i = 0; InitializerOp; i++)
1725 case 0: /* Resource Type */
1727 Descriptor->Address64.ResourceType =
1728 (UINT8) InitializerOp->Asl.Value.Integer;
1731 case 1: /* Resource Usage */
1733 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1736 case 2: /* DecodeType */
1738 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1739 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1740 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1743 case 3: /* MinType */
1745 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1746 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1747 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1750 case 4: /* MaxType */
1752 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1753 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1754 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1757 case 5: /* Type-Specific flags */
1759 Descriptor->Address64.SpecificFlags =
1760 (UINT8) InitializerOp->Asl.Value.Integer;
1763 case 6: /* Address Granularity */
1765 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1766 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1767 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1770 case 7: /* Min Address */
1772 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1773 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1774 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1777 case 8: /* Max Address */
1779 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1780 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1781 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1784 case 9: /* Translation Offset */
1786 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1787 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1788 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1791 case 10: /* Address Length */
1793 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1794 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1795 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1798 case 11: /* ResSourceIndex [Optional Field - BYTE] */
1800 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1802 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1804 Descriptor->Address64.ResourceLength++;
1805 ResSourceIndex = TRUE;
1809 case 12: /* ResSource [Optional Field - STRING] */
1811 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1812 (InitializerOp->Asl.Value.String))
1816 Descriptor->Address64.ResourceLength = (UINT16)
1817 (Descriptor->Address64.ResourceLength + StringLength);
1820 &OptionalFields[OptionIndex],
1821 InitializerOp->Asl.Value.String);
1823 /* ResourceSourceIndex must also be valid */
1825 if (!ResSourceIndex)
1827 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1828 InitializerOp, NULL);
1835 * Not a valid ResourceSource, ResourceSourceIndex must also
1838 else if (ResSourceIndex)
1840 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1841 InitializerOp, NULL);
1846 case 13: /* ResourceTag */
1848 UtAttachNamepathToOwner (Op, InitializerOp);
1853 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1857 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1860 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1861 OptionIndex + StringLength;
1866 /*******************************************************************************
1868 * FUNCTION: RsDoWordIoDescriptor
1870 * PARAMETERS: Op - Parent resource descriptor parse node
1871 * CurrentByteOffset - Offset into the resource template AML
1872 * buffer (to track references to the desc)
1874 * RETURN: Completed resource node
1876 * DESCRIPTION: Construct a long "WordIO" descriptor
1878 ******************************************************************************/
1881 RsDoWordIoDescriptor (
1882 ACPI_PARSE_OBJECT *Op,
1883 UINT32 CurrentByteOffset)
1885 AML_RESOURCE *Descriptor;
1886 ACPI_PARSE_OBJECT *InitializerOp;
1887 ASL_RESOURCE_NODE *Rnode;
1888 UINT8 *OptionalFields;
1889 UINT16 StringLength = 0;
1890 UINT32 OptionIndex = 0;
1892 BOOLEAN ResSourceIndex = FALSE;
1895 InitializerOp = Op->Asl.Child;
1896 StringLength = RsGetStringDataLength (InitializerOp);
1898 Rnode = RsAllocateResourceNode (
1899 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
1901 Descriptor = Rnode->Buffer;
1902 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
1903 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
1906 * Initial descriptor length -- may be enlarged if there are
1907 * optional fields present
1909 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
1910 Descriptor->Address16.ResourceLength = (UINT16)
1911 (sizeof (AML_RESOURCE_ADDRESS16) -
1912 sizeof (AML_RESOURCE_LARGE_HEADER));
1914 /* Process all child initialization nodes */
1916 for (i = 0; InitializerOp; i++)
1920 case 0: /* Resource Usage */
1922 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
1925 case 1: /* MinType */
1927 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
1928 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
1929 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
1932 case 2: /* MaxType */
1934 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
1935 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
1936 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
1939 case 3: /* DecodeType */
1941 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
1942 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
1943 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
1946 case 4: /* Range Type */
1948 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
1949 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
1950 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0);
1953 case 5: /* Address Granularity */
1955 Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
1956 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
1957 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
1960 case 6: /* Address Min */
1962 Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
1963 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
1964 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
1967 case 7: /* Address Max */
1969 Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
1970 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
1971 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
1974 case 8: /* Translation Offset */
1976 Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
1977 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
1978 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
1981 case 9: /* Address Length */
1983 Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1984 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
1985 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
1988 case 10: /* ResSourceIndex [Optional Field - BYTE] */
1990 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1992 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1994 Descriptor->Address16.ResourceLength++;
1995 ResSourceIndex = TRUE;
1999 case 11: /* ResSource [Optional Field - STRING] */
2001 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2002 (InitializerOp->Asl.Value.String))
2006 Descriptor->Address16.ResourceLength = (UINT16)
2007 (Descriptor->Address16.ResourceLength + StringLength);
2010 &OptionalFields[OptionIndex],
2011 InitializerOp->Asl.Value.String);
2013 /* ResourceSourceIndex must also be valid */
2015 if (!ResSourceIndex)
2017 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2018 InitializerOp, NULL);
2025 * Not a valid ResourceSource, ResourceSourceIndex must also
2028 else if (ResSourceIndex)
2030 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2031 InitializerOp, NULL);
2036 case 12: /* ResourceTag */
2038 UtAttachNamepathToOwner (Op, InitializerOp);
2043 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0);
2044 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
2045 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4);
2048 case 14: /* Translation Type */
2050 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0);
2051 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
2052 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5);
2057 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2061 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2064 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2065 OptionIndex + StringLength;
2070 /*******************************************************************************
2072 * FUNCTION: RsDoWordBusNumberDescriptor
2074 * PARAMETERS: Op - Parent resource descriptor parse node
2075 * CurrentByteOffset - Offset into the resource template AML
2076 * buffer (to track references to the desc)
2078 * RETURN: Completed resource node
2080 * DESCRIPTION: Construct a long "WordBusNumber" descriptor
2082 ******************************************************************************/
2085 RsDoWordBusNumberDescriptor (
2086 ACPI_PARSE_OBJECT *Op,
2087 UINT32 CurrentByteOffset)
2089 AML_RESOURCE *Descriptor;
2090 ACPI_PARSE_OBJECT *InitializerOp;
2091 ASL_RESOURCE_NODE *Rnode;
2092 UINT8 *OptionalFields;
2093 UINT16 StringLength = 0;
2094 UINT32 OptionIndex = 0;
2096 BOOLEAN ResSourceIndex = FALSE;
2099 InitializerOp = Op->Asl.Child;
2100 StringLength = RsGetStringDataLength (InitializerOp);
2102 Rnode = RsAllocateResourceNode (
2103 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
2105 Descriptor = Rnode->Buffer;
2106 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
2107 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE;
2110 * Initial descriptor length -- may be enlarged if there are
2111 * optional fields present
2113 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
2114 Descriptor->Address16.ResourceLength = (UINT16)
2115 (sizeof (AML_RESOURCE_ADDRESS16) -
2116 sizeof (AML_RESOURCE_LARGE_HEADER));
2118 /* Process all child initialization nodes */
2120 for (i = 0; InitializerOp; i++)
2124 case 0: /* Resource Usage */
2126 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
2129 case 1: /* MinType */
2131 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
2132 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
2133 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
2136 case 2: /* MaxType */
2138 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
2139 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
2140 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
2143 case 3: /* DecodeType */
2145 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
2146 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
2147 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
2150 case 4: /* Address Granularity */
2152 Descriptor->Address16.Granularity =
2153 (UINT16) InitializerOp->Asl.Value.Integer;
2154 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
2155 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
2158 case 5: /* Min Address */
2160 Descriptor->Address16.Minimum =
2161 (UINT16) InitializerOp->Asl.Value.Integer;
2162 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
2163 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
2166 case 6: /* Max Address */
2168 Descriptor->Address16.Maximum =
2169 (UINT16) InitializerOp->Asl.Value.Integer;
2170 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
2171 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
2174 case 7: /* Translation Offset */
2176 Descriptor->Address16.TranslationOffset =
2177 (UINT16) InitializerOp->Asl.Value.Integer;
2178 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
2179 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
2182 case 8: /* Address Length */
2184 Descriptor->Address16.AddressLength =
2185 (UINT16) InitializerOp->Asl.Value.Integer;
2186 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
2187 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
2190 case 9: /* ResSourceIndex [Optional Field - BYTE] */
2192 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2194 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
2196 Descriptor->Address16.ResourceLength++;
2197 ResSourceIndex = TRUE;
2201 case 10: /* ResSource [Optional Field - STRING] */
2203 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2204 (InitializerOp->Asl.Value.String))
2208 Descriptor->Address16.ResourceLength = (UINT16)
2209 (Descriptor->Address16.ResourceLength + StringLength);
2212 &OptionalFields[OptionIndex],
2213 InitializerOp->Asl.Value.String);
2215 /* ResourceSourceIndex must also be valid */
2217 if (!ResSourceIndex)
2219 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2220 InitializerOp, NULL);
2227 * Not a valid ResourceSource, ResourceSourceIndex must also
2230 else if (ResSourceIndex)
2232 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2233 InitializerOp, NULL);
2238 case 11: /* ResourceTag */
2240 UtAttachNamepathToOwner (Op, InitializerOp);
2245 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2249 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2252 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2253 OptionIndex + StringLength;
2258 /*******************************************************************************
2260 * FUNCTION: RsDoWordSpaceDescriptor
2262 * PARAMETERS: Op - Parent resource descriptor parse node
2263 * CurrentByteOffset - Offset into the resource template AML
2264 * buffer (to track references to the desc)
2266 * RETURN: Completed resource node
2268 * DESCRIPTION: Construct a long "WordSpace" descriptor
2270 ******************************************************************************/
2273 RsDoWordSpaceDescriptor (
2274 ACPI_PARSE_OBJECT *Op,
2275 UINT32 CurrentByteOffset)
2277 AML_RESOURCE *Descriptor;
2278 ACPI_PARSE_OBJECT *InitializerOp;
2279 ASL_RESOURCE_NODE *Rnode;
2280 UINT8 *OptionalFields;
2281 UINT16 StringLength = 0;
2282 UINT32 OptionIndex = 0;
2284 BOOLEAN ResSourceIndex = FALSE;
2287 InitializerOp = Op->Asl.Child;
2288 StringLength = RsGetStringDataLength (InitializerOp);
2290 Rnode = RsAllocateResourceNode (
2291 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
2293 Descriptor = Rnode->Buffer;
2294 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
2297 * Initial descriptor length -- may be enlarged if there are
2298 * optional fields present
2300 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
2301 Descriptor->Address16.ResourceLength = (UINT16)
2302 (sizeof (AML_RESOURCE_ADDRESS16) -
2303 sizeof (AML_RESOURCE_LARGE_HEADER));
2305 /* Process all child initialization nodes */
2307 for (i = 0; InitializerOp; i++)
2311 case 0: /* Resource Type */
2313 Descriptor->Address16.ResourceType =
2314 (UINT8) InitializerOp->Asl.Value.Integer;
2317 case 1: /* Resource Usage */
2319 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
2322 case 2: /* DecodeType */
2324 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
2325 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
2326 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
2329 case 3: /* MinType */
2331 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
2332 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
2333 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
2336 case 4: /* MaxType */
2338 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
2339 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
2340 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
2343 case 5: /* Type-Specific flags */
2345 Descriptor->Address16.SpecificFlags =
2346 (UINT8) InitializerOp->Asl.Value.Integer;
2349 case 6: /* Address Granularity */
2351 Descriptor->Address16.Granularity =
2352 (UINT16) InitializerOp->Asl.Value.Integer;
2353 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
2354 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
2357 case 7: /* Min Address */
2359 Descriptor->Address16.Minimum =
2360 (UINT16) InitializerOp->Asl.Value.Integer;
2361 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
2362 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
2365 case 8: /* Max Address */
2367 Descriptor->Address16.Maximum =
2368 (UINT16) InitializerOp->Asl.Value.Integer;
2369 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
2370 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
2373 case 9: /* Translation Offset */
2375 Descriptor->Address16.TranslationOffset =
2376 (UINT16) InitializerOp->Asl.Value.Integer;
2377 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
2378 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
2381 case 10: /* Address Length */
2383 Descriptor->Address16.AddressLength =
2384 (UINT16) InitializerOp->Asl.Value.Integer;
2385 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
2386 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
2389 case 11: /* ResSourceIndex [Optional Field - BYTE] */
2391 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2393 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
2395 Descriptor->Address16.ResourceLength++;
2396 ResSourceIndex = TRUE;
2400 case 12: /* ResSource [Optional Field - STRING] */
2402 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2403 (InitializerOp->Asl.Value.String))
2407 Descriptor->Address16.ResourceLength = (UINT16)
2408 (Descriptor->Address16.ResourceLength + StringLength);
2411 &OptionalFields[OptionIndex],
2412 InitializerOp->Asl.Value.String);
2414 /* ResourceSourceIndex must also be valid */
2416 if (!ResSourceIndex)
2418 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2419 InitializerOp, NULL);
2426 * Not a valid ResourceSource, ResourceSourceIndex must also
2429 else if (ResSourceIndex)
2431 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2432 InitializerOp, NULL);
2437 case 13: /* ResourceTag */
2439 UtAttachNamepathToOwner (Op, InitializerOp);
2444 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2448 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2451 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2452 OptionIndex + StringLength;
2457 /*******************************************************************************
2459 * FUNCTION: RsDoInterruptDescriptor
2461 * PARAMETERS: Op - Parent resource descriptor parse node
2462 * CurrentByteOffset - Offset into the resource template AML
2463 * buffer (to track references to the desc)
2465 * RETURN: Completed resource node
2467 * DESCRIPTION: Construct a long "Interrupt" descriptor
2469 ******************************************************************************/
2472 RsDoInterruptDescriptor (
2473 ACPI_PARSE_OBJECT *Op,
2474 UINT32 CurrentByteOffset)
2476 AML_RESOURCE *Descriptor;
2477 AML_RESOURCE *Rover = NULL;
2478 ACPI_PARSE_OBJECT *InitializerOp;
2479 ASL_RESOURCE_NODE *Rnode;
2480 UINT16 StringLength = 0;
2481 UINT32 OptionIndex = 0;
2483 BOOLEAN HasResSourceIndex = FALSE;
2484 UINT8 ResSourceIndex = 0;
2485 UINT8 *ResSourceString = NULL;
2488 InitializerOp = Op->Asl.Child;
2489 StringLength = RsGetStringDataLength (InitializerOp);
2491 /* Count the interrupt numbers */
2493 for (i = 0; InitializerOp; i++)
2495 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
2500 InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2503 * ResourceSourceIndex was specified, always make room for
2504 * it, even if the ResourceSource was omitted.
2515 InitializerOp = Op->Asl.Child;
2516 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_EXTENDED_IRQ) +
2517 1 + OptionIndex + StringLength);
2519 Descriptor = Rnode->Buffer;
2520 Descriptor->ExtendedIrq.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_IRQ;
2523 * Initial descriptor length -- may be enlarged if there are
2524 * optional fields present
2526 Descriptor->ExtendedIrq.ResourceLength = 2; /* Flags and table length byte */
2527 Descriptor->ExtendedIrq.InterruptCount = 0;
2529 Rover = ACPI_CAST_PTR (AML_RESOURCE,
2530 (&(Descriptor->ExtendedIrq.Interrupts[0])));
2532 /* Process all child initialization nodes */
2534 for (i = 0; InitializerOp; i++)
2538 case 0: /* Resource Usage (Default: consumer (1) */
2540 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 0, 1);
2543 case 1: /* Interrupt Type (or Mode - edge/level) */
2545 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 1, 0);
2546 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE,
2547 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 1);
2550 case 2: /* Interrupt Level (or Polarity - Active high/low) */
2552 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 2, 0);
2553 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL,
2554 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 2);
2557 case 3: /* Share Type - Default: exclusive (0) */
2559 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 3, 0);
2560 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
2561 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 3);
2564 case 4: /* ResSourceIndex [Optional Field - BYTE] */
2566 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2568 HasResSourceIndex = TRUE;
2569 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
2573 case 5: /* ResSource [Optional Field - STRING] */
2575 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2576 (InitializerOp->Asl.Value.String))
2580 ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String;
2583 /* ResourceSourceIndex must also be valid */
2585 if (!HasResSourceIndex)
2587 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2588 InitializerOp, NULL);
2594 * Not a valid ResourceSource, ResourceSourceIndex must also
2597 else if (HasResSourceIndex)
2599 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2600 InitializerOp, NULL);
2605 case 6: /* ResourceTag */
2607 UtAttachNamepathToOwner (Op, InitializerOp);
2612 * Interrupt Numbers come through here, repeatedly
2615 /* Maximum 255 interrupts allowed for this descriptor */
2617 if (Descriptor->ExtendedIrq.InterruptCount == 255)
2619 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST,
2620 InitializerOp, NULL);
2624 /* Each interrupt number must be a 32-bit value */
2626 if (InitializerOp->Asl.Value.Integer > ACPI_UINT32_MAX)
2628 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_NUMBER,
2629 InitializerOp, NULL);
2632 /* Save the integer and move pointer to the next one */
2634 Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer;
2635 Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4);
2636 Descriptor->ExtendedIrq.InterruptCount++;
2637 Descriptor->ExtendedIrq.ResourceLength += 4;
2639 /* Case 7: First interrupt number in list */
2643 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
2645 /* Must be at least one interrupt */
2647 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
2648 InitializerOp, NULL);
2651 /* Check now for duplicates in list */
2653 RsCheckListForDuplicates (InitializerOp);
2655 /* Create a named field at the start of the list */
2657 RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
2659 ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]));
2663 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2667 /* Add optional ResSourceIndex if present */
2669 if (HasResSourceIndex)
2671 Rover->ByteItem = ResSourceIndex;
2672 Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1);
2673 Descriptor->ExtendedIrq.ResourceLength += 1;
2676 /* Add optional ResSource string if present */
2678 if (StringLength && ResSourceString)
2681 strcpy ((char *) Rover, (char *) ResSourceString);
2682 Rover = ACPI_ADD_PTR (
2683 AML_RESOURCE, &(Rover->ByteItem), StringLength);
2685 Descriptor->ExtendedIrq.ResourceLength = (UINT16)
2686 (Descriptor->ExtendedIrq.ResourceLength + StringLength);
2689 Rnode->BufferLength = (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) -
2690 ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType))
2691 + OptionIndex + StringLength;
2696 /*******************************************************************************
2698 * FUNCTION: RsDoVendorLargeDescriptor
2700 * PARAMETERS: Op - Parent resource descriptor parse node
2701 * CurrentByteOffset - Offset into the resource template AML
2702 * buffer (to track references to the desc)
2704 * RETURN: Completed resource node
2706 * DESCRIPTION: Construct a long "VendorLong" descriptor
2708 ******************************************************************************/
2711 RsDoVendorLargeDescriptor (
2712 ACPI_PARSE_OBJECT *Op,
2713 UINT32 CurrentByteOffset)
2715 AML_RESOURCE *Descriptor;
2716 ACPI_PARSE_OBJECT *InitializerOp;
2717 ASL_RESOURCE_NODE *Rnode;
2722 /* Count the number of data bytes */
2724 InitializerOp = Op->Asl.Child;
2725 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2727 for (i = 0; InitializerOp; i++)
2729 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
2733 InitializerOp = InitializerOp->Asl.Next;
2736 InitializerOp = Op->Asl.Child;
2737 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2738 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_LARGE) + i);
2740 Descriptor = Rnode->Buffer;
2741 Descriptor->VendorLarge.DescriptorType = ACPI_RESOURCE_NAME_VENDOR_LARGE;
2742 Descriptor->VendorLarge.ResourceLength = (UINT16) i;
2744 /* Point to end-of-descriptor for vendor data */
2746 VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_LARGE_HEADER);
2748 /* Process all child initialization nodes */
2750 for (i = 0; InitializerOp; i++)
2752 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
2757 VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
2758 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2765 /*******************************************************************************
2767 * FUNCTION: RsDoGeneralRegisterDescriptor
2769 * PARAMETERS: Op - Parent resource descriptor parse node
2770 * CurrentByteOffset - Offset into the resource template AML
2771 * buffer (to track references to the desc)
2773 * RETURN: Completed resource node
2775 * DESCRIPTION: Construct a long "Register" descriptor
2777 ******************************************************************************/
2780 RsDoGeneralRegisterDescriptor (
2781 ACPI_PARSE_OBJECT *Op,
2782 UINT32 CurrentByteOffset)
2784 AML_RESOURCE *Descriptor;
2785 ACPI_PARSE_OBJECT *InitializerOp;
2786 ASL_RESOURCE_NODE *Rnode;
2790 InitializerOp = Op->Asl.Child;
2791 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_GENERIC_REGISTER));
2793 Descriptor = Rnode->Buffer;
2794 Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER;
2795 Descriptor->GenericReg.ResourceLength = 12;
2797 /* Process all child initialization nodes */
2799 for (i = 0; InitializerOp; i++)
2803 case 0: /* Address space */
2805 Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
2806 RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE,
2807 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));
2810 case 1: /* Register Bit Width */
2812 Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
2813 RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH,
2814 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));
2817 case 2: /* Register Bit Offset */
2819 Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
2820 RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET,
2821 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));
2824 case 3: /* Register Address */
2826 Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;
2827 RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESS,
2828 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));
2831 case 4: /* Access Size (ACPI 3.0) */
2833 Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;
2834 RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,
2835 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
2838 case 5: /* ResourceTag (ACPI 3.0b) */
2840 UtAttachNamepathToOwner (Op, InitializerOp);
2845 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2849 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);