2 /******************************************************************************
4 * Module Name: aslrestype2 - Long (type2) resource templates and descriptors
7 *****************************************************************************/
9 /******************************************************************************
13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
14 * All rights reserved.
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights. You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code. No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
39 * The above copyright and patent license is granted only if the following
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision. In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change. Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee. Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution. In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
74 * 3.4. Intel retains all right, title, and interest in and to the Original
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
82 * 4. Disclaimer and Export Compliance
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government. In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
116 *****************************************************************************/
119 #include "aslcompiler.h"
120 #include "aslcompiler.y.h"
122 #define _COMPONENT ACPI_COMPILER
123 ACPI_MODULE_NAME ("aslrestype2")
126 /*******************************************************************************
128 * FUNCTION: RsGetStringDataLength
130 * PARAMETERS: InitializerOp - Start of a subtree of init nodes
132 * RETURN: Valid string length if a string node is found
134 * DESCRIPTION: In a list of peer nodes, find the first one that contains a
135 * string and return the length of the string.
137 ******************************************************************************/
140 RsGetStringDataLength (
141 ACPI_PARSE_OBJECT *InitializerOp)
144 while (InitializerOp)
146 if (InitializerOp->Asl.ParseOpcode == PARSEOP_STRING_LITERAL)
148 return (strlen (InitializerOp->Asl.Value.String) + 1);
150 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
157 /*******************************************************************************
159 * FUNCTION: RsDoDwordIoDescriptor
161 * PARAMETERS: Op - Parent resource descriptor parse node
162 * CurrentByteOffset - Offset into the resource template AML
163 * buffer (to track references to the desc)
165 * RETURN: Completed resource node
167 * DESCRIPTION: Construct a long "DwordIO" descriptor
169 ******************************************************************************/
172 RsDoDwordIoDescriptor (
173 ACPI_PARSE_OBJECT *Op,
174 UINT32 CurrentByteOffset)
176 ASL_RESOURCE_DESC *Descriptor;
177 ACPI_PARSE_OBJECT *InitializerOp;
178 ASL_RESOURCE_NODE *Rnode;
179 UINT32 StringLength = 0;
180 UINT32 OptionIndex = 0;
184 InitializerOp = Op->Asl.Child;
185 StringLength = RsGetStringDataLength (InitializerOp);
187 Rnode = RsAllocateResourceNode (sizeof (ASL_DWORD_ADDRESS_DESC) +
190 Descriptor = Rnode->Buffer;
191 Descriptor->Das.DescriptorType = ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE;
192 Descriptor->Das.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
195 * Initial descriptor length -- may be enlarged if there are
196 * optional fields present
198 Descriptor->Das.Length = (UINT16) (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
199 ASL_RESDESC_OFFSET (Das.ResourceType));
202 * Process all child initialization nodes
204 for (i = 0; InitializerOp; i++)
208 case 0: /* Resource Type */
210 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 0, 1);
213 case 1: /* MinType */
215 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 2, 0);
216 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
217 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 2);
220 case 2: /* MaxType */
222 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 3, 0);
223 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
224 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 3);
227 case 3: /* DecodeType */
229 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 1, 0);
230 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
231 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 1);
234 case 4: /* Range Type */
236 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 0, 3);
237 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
238 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 0);
241 case 5: /* Address Granularity */
243 Descriptor->Das.Granularity = (UINT32) InitializerOp->Asl.Value.Integer;
244 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
245 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Granularity));
248 case 6: /* Address Min */
250 Descriptor->Das.AddressMin = (UINT32) InitializerOp->Asl.Value.Integer;
251 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
252 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMin));
255 case 7: /* Address Max */
257 Descriptor->Das.AddressMax = (UINT32) InitializerOp->Asl.Value.Integer;
258 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
259 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMax));
262 case 8: /* Translation Offset */
264 Descriptor->Das.TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer;
265 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
266 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.TranslationOffset));
269 case 9: /* Address Length */
271 Descriptor->Das.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
272 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
273 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressLength));
276 case 10: /* ResSourceIndex [Optional Field - BYTE] */
278 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
280 Descriptor->Das.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
282 Descriptor->Das.Length++;
286 case 11: /* ResSource [Optional Field - STRING] */
288 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
289 (InitializerOp->Asl.Value.String))
293 Descriptor->Das.Length = (UINT16) (Descriptor->Das.Length + StringLength);
295 strcpy ((char *) &Descriptor->Das.OptionalFields[OptionIndex],
296 InitializerOp->Asl.Value.String);
301 case 12: /* ResourceTag */
303 UtAttachNamepathToOwner (Op, InitializerOp);
308 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 4, 0);
309 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
310 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 4);
313 case 14: /* Translation Type */
315 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 5, 0);
316 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
317 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 5);
322 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
326 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
329 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
330 ASL_RESDESC_OFFSET (Das.DescriptorType))
331 + OptionIndex + StringLength;
336 /*******************************************************************************
338 * FUNCTION: RsDoDwordMemoryDescriptor
340 * PARAMETERS: Op - Parent resource descriptor parse node
341 * CurrentByteOffset - Offset into the resource template AML
342 * buffer (to track references to the desc)
344 * RETURN: Completed resource node
346 * DESCRIPTION: Construct a long "DwordMemory" descriptor
348 ******************************************************************************/
351 RsDoDwordMemoryDescriptor (
352 ACPI_PARSE_OBJECT *Op,
353 UINT32 CurrentByteOffset)
355 ASL_RESOURCE_DESC *Descriptor;
356 ACPI_PARSE_OBJECT *InitializerOp;
357 ASL_RESOURCE_NODE *Rnode;
358 UINT32 StringLength = 0;
359 UINT32 OptionIndex = 0;
363 InitializerOp = Op->Asl.Child;
364 StringLength = RsGetStringDataLength (InitializerOp);
366 Rnode = RsAllocateResourceNode (sizeof (ASL_DWORD_ADDRESS_DESC) +
369 Descriptor = Rnode->Buffer;
370 Descriptor->Das.DescriptorType = ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE;
371 Descriptor->Das.ResourceType = ACPI_RESOURCE_TYPE_MEMORY_RANGE;
374 * Initial descriptor length -- may be enlarged if there are
375 * optional fields present
377 Descriptor->Das.Length = (UINT16) (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
378 ASL_RESDESC_OFFSET (Das.ResourceType));
381 * Process all child initialization nodes
383 for (i = 0; InitializerOp; i++)
387 case 0: /* Resource Type */
389 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 0, 1);
392 case 1: /* DecodeType */
394 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 1, 0);
395 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
396 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 1);
399 case 2: /* MinType */
401 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 2, 0);
402 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
403 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 2);
406 case 3: /* MaxType */
408 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 3, 0);
409 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
410 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 3);
413 case 4: /* Memory Type */
415 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 1, 0);
416 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
417 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 1);
420 case 5: /* Read/Write Type */
422 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 0, 1);
423 RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
424 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 0);
427 case 6: /* Address Granularity */
429 Descriptor->Das.Granularity = (UINT32) InitializerOp->Asl.Value.Integer;
430 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
431 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Granularity));
434 case 7: /* Min Address */
436 Descriptor->Das.AddressMin = (UINT32) InitializerOp->Asl.Value.Integer;
437 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
438 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMin));
441 case 8: /* Max Address */
443 Descriptor->Das.AddressMax = (UINT32) InitializerOp->Asl.Value.Integer;
444 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
445 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMax));
448 case 9: /* Translation Offset */
450 Descriptor->Das.TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer;
451 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
452 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.TranslationOffset));
455 case 10: /* Address Length */
457 Descriptor->Das.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
458 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
459 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressLength));
462 case 11: /* ResSourceIndex [Optional Field - BYTE] */
464 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
466 Descriptor->Das.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
468 Descriptor->Das.Length++;
472 case 12: /* ResSource [Optional Field - STRING] */
474 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
475 (InitializerOp->Asl.Value.String))
479 Descriptor->Das.Length = (UINT16) (Descriptor->Das.Length + StringLength);
481 strcpy ((char *) &Descriptor->Das.OptionalFields[OptionIndex],
482 InitializerOp->Asl.Value.String);
487 case 13: /* ResourceTag */
489 UtAttachNamepathToOwner (Op, InitializerOp);
493 case 14: /* Address Range */
495 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 3, 0);
496 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
497 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 3);
502 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 5, 0);
503 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
504 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 5);
509 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
513 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
516 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
517 ASL_RESDESC_OFFSET (Das.DescriptorType))
518 + OptionIndex + StringLength;
523 /*******************************************************************************
525 * FUNCTION: RsDoQwordIoDescriptor
527 * PARAMETERS: Op - Parent resource descriptor parse node
528 * CurrentByteOffset - Offset into the resource template AML
529 * buffer (to track references to the desc)
531 * RETURN: Completed resource node
533 * DESCRIPTION: Construct a long "QwordIO" descriptor
535 ******************************************************************************/
538 RsDoQwordIoDescriptor (
539 ACPI_PARSE_OBJECT *Op,
540 UINT32 CurrentByteOffset)
542 ASL_RESOURCE_DESC *Descriptor;
543 ACPI_PARSE_OBJECT *InitializerOp;
544 ASL_RESOURCE_NODE *Rnode;
545 UINT32 StringLength = 0;
546 UINT32 OptionIndex = 0;
550 InitializerOp = Op->Asl.Child;
551 StringLength = RsGetStringDataLength (InitializerOp);
553 Rnode = RsAllocateResourceNode (sizeof (ASL_QWORD_ADDRESS_DESC) +
556 Descriptor = Rnode->Buffer;
557 Descriptor->Qas.DescriptorType = ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE;
558 Descriptor->Qas.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
561 * Initial descriptor length -- may be enlarged if there are
562 * optional fields present
564 Descriptor->Qas.Length = (UINT16) (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
565 ASL_RESDESC_OFFSET (Qas.ResourceType));
567 * Process all child initialization nodes
569 for (i = 0; InitializerOp; i++)
573 case 0: /* Resource Type */
575 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 0, 1);
578 case 1: /* MinType */
580 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 2, 0);
581 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
582 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 2);
585 case 2: /* MaxType */
587 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 3, 0);
588 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
589 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 3);
592 case 3: /* DecodeType */
594 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 1, 0);
595 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
596 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 1);
599 case 4: /* Range Type */
601 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 0, 3);
602 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
603 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 0);
606 case 5: /* Address Granularity */
608 Descriptor->Qas.Granularity = InitializerOp->Asl.Value.Integer;
609 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
610 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Granularity));
613 case 6: /* Address Min */
615 Descriptor->Qas.AddressMin = InitializerOp->Asl.Value.Integer;
616 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
617 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMin));
620 case 7: /* Address Max */
622 Descriptor->Qas.AddressMax = InitializerOp->Asl.Value.Integer;
623 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
624 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMax));
627 case 8: /* Translation Offset */
629 Descriptor->Qas.TranslationOffset = InitializerOp->Asl.Value.Integer;
630 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
631 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.TranslationOffset));
634 case 9: /* Address Length */
636 Descriptor->Qas.AddressLength = InitializerOp->Asl.Value.Integer;
637 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
638 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressLength));
641 case 10: /* ResSourceIndex [Optional Field - BYTE] */
643 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
645 Descriptor->Qas.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
647 Descriptor->Qas.Length++;
651 case 11: /* ResSource [Optional Field - STRING] */
653 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
654 (InitializerOp->Asl.Value.String))
658 Descriptor->Qas.Length = (UINT16) (Descriptor->Qas.Length + StringLength);
660 strcpy ((char *) &Descriptor->Qas.OptionalFields[OptionIndex],
661 InitializerOp->Asl.Value.String);
666 case 12: /* ResourceTag */
668 UtAttachNamepathToOwner (Op, InitializerOp);
673 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 4, 0);
674 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
675 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 4);
678 case 14: /* Translation Type */
680 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 5, 0);
681 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
682 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 5);
687 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
691 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
694 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
695 ASL_RESDESC_OFFSET (Qas.DescriptorType))
696 + OptionIndex + StringLength;
701 /*******************************************************************************
703 * FUNCTION: RsDoQwordMemoryDescriptor
705 * PARAMETERS: Op - Parent resource descriptor parse node
706 * CurrentByteOffset - Offset into the resource template AML
707 * buffer (to track references to the desc)
709 * RETURN: Completed resource node
711 * DESCRIPTION: Construct a long "QwordMemory" descriptor
713 ******************************************************************************/
716 RsDoQwordMemoryDescriptor (
717 ACPI_PARSE_OBJECT *Op,
718 UINT32 CurrentByteOffset)
720 ASL_RESOURCE_DESC *Descriptor;
721 ACPI_PARSE_OBJECT *InitializerOp;
722 ASL_RESOURCE_NODE *Rnode;
723 UINT32 StringLength = 0;
724 UINT32 OptionIndex = 0;
728 InitializerOp = Op->Asl.Child;
729 StringLength = RsGetStringDataLength (InitializerOp);
731 Rnode = RsAllocateResourceNode (sizeof (ASL_QWORD_ADDRESS_DESC) +
734 Descriptor = Rnode->Buffer;
735 Descriptor->Qas.DescriptorType = ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE;
736 Descriptor->Qas.ResourceType = ACPI_RESOURCE_TYPE_MEMORY_RANGE;
739 * Initial descriptor length -- may be enlarged if there are
740 * optional fields present
742 Descriptor->Qas.Length = (UINT16) (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
743 ASL_RESDESC_OFFSET (Qas.ResourceType));
745 * Process all child initialization nodes
747 for (i = 0; InitializerOp; i++)
751 case 0: /* Resource Type */
753 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 0, 1);
756 case 1: /* DecodeType */
758 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 1, 0);
759 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
760 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 1);
763 case 2: /* MinType */
765 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 2, 0);
766 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
767 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 2);
770 case 3: /* MaxType */
772 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 3, 0);
773 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
774 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 3);
777 case 4: /* Memory Type */
779 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 1, 0);
780 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
781 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 1);
784 case 5: /* Read/Write Type */
786 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 0, 1);
787 RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
788 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 0);
791 case 6: /* Address Granularity */
793 Descriptor->Qas.Granularity = InitializerOp->Asl.Value.Integer;
794 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
795 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Granularity));
798 case 7: /* Min Address */
800 Descriptor->Qas.AddressMin = InitializerOp->Asl.Value.Integer;
801 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
802 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMin));
805 case 8: /* Max Address */
807 Descriptor->Qas.AddressMax = InitializerOp->Asl.Value.Integer;
808 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
809 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMax));
812 case 9: /* Translation Offset */
814 Descriptor->Qas.TranslationOffset = InitializerOp->Asl.Value.Integer;
815 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
816 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.TranslationOffset));
819 case 10: /* Address Length */
821 Descriptor->Qas.AddressLength = InitializerOp->Asl.Value.Integer;
822 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
823 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressLength));
826 case 11: /* ResSourceIndex [Optional Field - BYTE] */
828 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
830 Descriptor->Qas.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
832 Descriptor->Qas.Length++;
836 case 12: /* ResSource [Optional Field - STRING] */
838 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
839 (InitializerOp->Asl.Value.String))
843 Descriptor->Qas.Length = (UINT16) (Descriptor->Qas.Length + StringLength);
845 strcpy ((char *) &Descriptor->Qas.OptionalFields[OptionIndex],
846 InitializerOp->Asl.Value.String);
851 case 13: /* ResourceTag */
853 UtAttachNamepathToOwner (Op, InitializerOp);
857 case 14: /* Address Range */
859 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 3, 0);
860 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
861 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 3);
866 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 5, 0);
867 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
868 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 5);
873 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
877 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
880 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
881 ASL_RESDESC_OFFSET (Qas.DescriptorType))
882 + OptionIndex + StringLength;
887 /*******************************************************************************
889 * FUNCTION: RsDoWordIoDescriptor
891 * PARAMETERS: Op - Parent resource descriptor parse node
892 * CurrentByteOffset - Offset into the resource template AML
893 * buffer (to track references to the desc)
895 * RETURN: Completed resource node
897 * DESCRIPTION: Construct a long "WordIO" descriptor
899 ******************************************************************************/
902 RsDoWordIoDescriptor (
903 ACPI_PARSE_OBJECT *Op,
904 UINT32 CurrentByteOffset)
906 ASL_RESOURCE_DESC *Descriptor;
907 ACPI_PARSE_OBJECT *InitializerOp;
908 ASL_RESOURCE_NODE *Rnode;
909 UINT32 StringLength = 0;
910 UINT32 OptionIndex = 0;
914 InitializerOp = Op->Asl.Child;
915 StringLength = RsGetStringDataLength (InitializerOp);
917 Rnode = RsAllocateResourceNode (sizeof (ASL_WORD_ADDRESS_DESC) +
920 Descriptor = Rnode->Buffer;
921 Descriptor->Was.DescriptorType = ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE;
922 Descriptor->Was.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
925 * Initial descriptor length -- may be enlarged if there are
926 * optional fields present
928 Descriptor->Was.Length = (UINT16) (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
929 ASL_RESDESC_OFFSET (Was.ResourceType));
932 * Process all child initialization nodes
934 for (i = 0; InitializerOp; i++)
938 case 0: /* Resource Type */
940 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 0, 1);
943 case 1: /* MinType */
945 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 2, 0);
946 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
947 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 2);
950 case 2: /* MaxType */
952 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 3, 0);
953 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
954 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 3);
957 case 3: /* DecodeType */
959 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 1, 0);
960 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
961 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 1);
964 case 4: /* Range Type */
966 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 0, 3);
967 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
968 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 0);
971 case 5: /* Address Granularity */
973 Descriptor->Was.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
974 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
975 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Granularity));
978 case 6: /* Address Min */
980 Descriptor->Was.AddressMin = (UINT16) InitializerOp->Asl.Value.Integer;
981 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
982 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMin));
985 case 7: /* Address Max */
987 Descriptor->Was.AddressMax = (UINT16) InitializerOp->Asl.Value.Integer;
988 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
989 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMax));
992 case 8: /* Translation Offset */
994 Descriptor->Was.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
995 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
996 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.TranslationOffset));
999 case 9: /* Address Length */
1001 Descriptor->Was.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1002 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1003 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressLength));
1006 case 10: /* ResSourceIndex [Optional Field - BYTE] */
1008 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1010 Descriptor->Was.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1012 Descriptor->Was.Length++;
1016 case 11: /* ResSource [Optional Field - STRING] */
1018 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1019 (InitializerOp->Asl.Value.String))
1023 Descriptor->Was.Length = (UINT16) (Descriptor->Was.Length +StringLength);
1025 strcpy ((char *) &Descriptor->Was.OptionalFields[OptionIndex],
1026 InitializerOp->Asl.Value.String);
1031 case 12: /* ResourceTag */
1033 UtAttachNamepathToOwner (Op, InitializerOp);
1038 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 4, 0);
1039 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
1040 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 4);
1043 case 14: /* Translation Type */
1045 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 5, 0);
1046 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
1047 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 5);
1052 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1056 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1059 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1060 ASL_RESDESC_OFFSET (Was.DescriptorType))
1061 + OptionIndex + StringLength;
1066 /*******************************************************************************
1068 * FUNCTION: RsDoWordBusNumberDescriptor
1070 * PARAMETERS: Op - Parent resource descriptor parse node
1071 * CurrentByteOffset - Offset into the resource template AML
1072 * buffer (to track references to the desc)
1074 * RETURN: Completed resource node
1076 * DESCRIPTION: Construct a long "WordBusNumber" descriptor
1078 ******************************************************************************/
1081 RsDoWordBusNumberDescriptor (
1082 ACPI_PARSE_OBJECT *Op,
1083 UINT32 CurrentByteOffset)
1085 ASL_RESOURCE_DESC *Descriptor;
1086 ACPI_PARSE_OBJECT *InitializerOp;
1087 ASL_RESOURCE_NODE *Rnode;
1088 UINT32 StringLength = 0;
1089 UINT32 OptionIndex = 0;
1093 InitializerOp = Op->Asl.Child;
1094 StringLength = RsGetStringDataLength (InitializerOp);
1096 Rnode = RsAllocateResourceNode (sizeof (ASL_WORD_ADDRESS_DESC) +
1099 Descriptor = Rnode->Buffer;
1100 Descriptor->Was.DescriptorType = ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE;
1101 Descriptor->Was.ResourceType = ACPI_RESOURCE_TYPE_BUS_NUMBER_RANGE;
1104 * Initial descriptor length -- may be enlarged if there are
1105 * optional fields present
1107 Descriptor->Was.Length = (UINT16) (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1108 ASL_RESDESC_OFFSET (Was.ResourceType));
1111 * Process all child initialization nodes
1113 for (i = 0; InitializerOp; i++)
1117 case 0: /* Resource Type */
1119 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 0, 1);
1122 case 1: /* MinType */
1124 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 2, 0);
1125 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1126 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 2);
1129 case 2: /* MaxType */
1131 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 3, 0);
1132 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1133 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 3);
1136 case 3: /* DecodeType */
1138 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 1, 0);
1139 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1140 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 1);
1143 case 4: /* Address Granularity */
1145 Descriptor->Was.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
1146 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1147 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Granularity));
1150 case 5: /* Min Address */
1152 Descriptor->Was.AddressMin = (UINT16) InitializerOp->Asl.Value.Integer;
1153 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1154 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMin));
1157 case 6: /* Max Address */
1159 Descriptor->Was.AddressMax = (UINT16) InitializerOp->Asl.Value.Integer;
1160 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1161 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMax));
1164 case 7: /* Translation Offset */
1166 Descriptor->Was.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
1167 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1168 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.TranslationOffset));
1171 case 8: /* Address Length */
1173 Descriptor->Was.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1174 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1175 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressLength));
1178 case 9: /* ResSourceIndex [Optional Field - BYTE] */
1180 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1182 Descriptor->Was.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1184 Descriptor->Was.Length++;
1188 case 10: /* ResSource [Optional Field - STRING] */
1190 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1191 (InitializerOp->Asl.Value.String))
1195 Descriptor->Was.Length = (UINT16) (Descriptor->Was.Length + StringLength);
1197 strcpy ((char *) &Descriptor->Was.OptionalFields[OptionIndex],
1198 InitializerOp->Asl.Value.String);
1203 case 11: /* ResourceTag */
1205 UtAttachNamepathToOwner (Op, InitializerOp);
1210 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1214 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1217 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1218 ASL_RESDESC_OFFSET (Was.DescriptorType))
1219 + OptionIndex + StringLength;
1224 /*******************************************************************************
1226 * FUNCTION: RsDoInterruptDescriptor
1228 * PARAMETERS: Op - Parent resource descriptor parse node
1229 * CurrentByteOffset - Offset into the resource template AML
1230 * buffer (to track references to the desc)
1232 * RETURN: Completed resource node
1234 * DESCRIPTION: Construct a long "Interrupt" descriptor
1236 ******************************************************************************/
1239 RsDoInterruptDescriptor (
1240 ACPI_PARSE_OBJECT *Op,
1241 UINT32 CurrentByteOffset)
1243 ASL_RESOURCE_DESC *Descriptor;
1244 ASL_RESOURCE_DESC *Rover = NULL;
1245 ACPI_PARSE_OBJECT *InitializerOp;
1246 ASL_RESOURCE_NODE *Rnode;
1247 UINT32 StringLength = 0;
1248 UINT32 OptionIndex = 0;
1250 BOOLEAN HasResSourceIndex = FALSE;
1251 UINT8 ResSourceIndex = 0;
1252 UINT8 *ResSourceString = NULL;
1255 InitializerOp = Op->Asl.Child;
1256 StringLength = RsGetStringDataLength (InitializerOp);
1259 /* Make room for the ResourceSourceIndex */
1264 /* Count the interrupt numbers */
1266 for (i = 0; InitializerOp; i++)
1268 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
1277 InitializerOp = Op->Asl.Child;
1278 Rnode = RsAllocateResourceNode (sizeof (ASL_EXTENDED_XRUPT_DESC) +
1279 OptionIndex + StringLength);
1280 Descriptor = Rnode->Buffer;
1281 Descriptor->Exx.DescriptorType = ACPI_RDESC_TYPE_EXTENDED_XRUPT;
1284 * Initial descriptor length -- may be enlarged if there are
1285 * optional fields present
1287 Descriptor->Exx.Length = 2; /* Flags and table length byte */
1288 Descriptor->Exx.TableLength = 0;
1290 Rover = ACPI_CAST_PTR (ASL_RESOURCE_DESC, (&(Descriptor->Exx.InterruptNumber[0])));
1293 * Process all child initialization nodes
1295 for (i = 0; InitializerOp; i++)
1299 case 0: /* Resource Type (Default: consumer (1) */
1301 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 0, 1);
1304 case 1: /* Interrupt Type (or Mode - edge/level) */
1306 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 1, 0);
1307 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTTYPE,
1308 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 0);
1311 case 2: /* Interrupt Level (or Polarity - Active high/low) */
1313 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 2, 0);
1314 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTLEVEL,
1315 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 2);
1318 case 3: /* Share Type - Default: exclusive (0) */
1320 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 3, 0);
1321 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTSHARE,
1322 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 3);
1325 case 4: /* ResSourceIndex [Optional Field - BYTE] */
1327 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1329 HasResSourceIndex = TRUE;
1330 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
1334 case 5: /* ResSource [Optional Field - STRING] */
1336 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1337 (InitializerOp->Asl.Value.String))
1341 ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String;
1346 case 6: /* ResourceTag */
1348 UtAttachNamepathToOwner (Op, InitializerOp);
1353 * Interrupt Numbers come through here, repeatedly.
1354 * Store the integer and move pointer to the next one.
1356 Rover->U32Item = (UINT32) InitializerOp->Asl.Value.Integer;
1357 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U32Item), 4);
1359 Descriptor->Exx.TableLength++;
1360 Descriptor->Exx.Length += 4;
1362 if (i == 7) /* case 7: First interrupt number */
1364 RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
1365 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.InterruptNumber[0]));
1369 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1373 * Add optional ResSourceIndex if present
1375 if (HasResSourceIndex)
1377 Rover->U8Item = ResSourceIndex;
1378 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U8Item), 1);
1379 Descriptor->Exx.Length += 1;
1383 * Add optional ResSource string if present
1385 if (StringLength && ResSourceString)
1388 strcpy ((char *) Rover, (char *) ResSourceString);
1389 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U8Item), StringLength);
1390 Descriptor->Exx.Length = (UINT16) (Descriptor->Exx.Length + StringLength);
1393 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Exx.InterruptNumber[0]) -
1394 ASL_RESDESC_OFFSET (Exx.DescriptorType))
1395 + OptionIndex + StringLength;
1400 /*******************************************************************************
1402 * FUNCTION: RsDoVendorLargeDescriptor
1404 * PARAMETERS: Op - Parent resource descriptor parse node
1405 * CurrentByteOffset - Offset into the resource template AML
1406 * buffer (to track references to the desc)
1408 * RETURN: Completed resource node
1410 * DESCRIPTION: Construct a long "VendorLong" descriptor
1412 ******************************************************************************/
1415 RsDoVendorLargeDescriptor (
1416 ACPI_PARSE_OBJECT *Op,
1417 UINT32 CurrentByteOffset)
1419 ASL_RESOURCE_DESC *Descriptor;
1420 ACPI_PARSE_OBJECT *InitializerOp;
1421 ASL_RESOURCE_NODE *Rnode;
1425 /* Count the number of data bytes */
1427 InitializerOp = Op->Asl.Child;
1428 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1430 for (i = 0; InitializerOp; i++)
1432 InitializerOp = InitializerOp->Asl.Next;
1435 InitializerOp = Op->Asl.Child;
1436 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1437 Rnode = RsAllocateResourceNode (sizeof (ASL_LARGE_VENDOR_DESC) + (i - 1));
1439 Descriptor = Rnode->Buffer;
1440 Descriptor->Lgv.DescriptorType = ACPI_RDESC_TYPE_LARGE_VENDOR;
1441 Descriptor->Lgv.Length = (UINT16) i;
1444 * Process all child initialization nodes
1446 for (i = 0; InitializerOp; i++)
1448 Descriptor->Lgv.VendorDefined[i] = (UINT8) InitializerOp->Asl.Value.Integer;
1450 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1457 /*******************************************************************************
1459 * FUNCTION: RsDoGeneralRegisterDescriptor
1461 * PARAMETERS: Op - Parent resource descriptor parse node
1462 * CurrentByteOffset - Offset into the resource template AML
1463 * buffer (to track references to the desc)
1465 * RETURN: Completed resource node
1467 * DESCRIPTION: Construct a long "Register" descriptor
1469 ******************************************************************************/
1472 RsDoGeneralRegisterDescriptor (
1473 ACPI_PARSE_OBJECT *Op,
1474 UINT32 CurrentByteOffset)
1476 ASL_RESOURCE_DESC *Descriptor;
1477 ACPI_PARSE_OBJECT *InitializerOp;
1478 ASL_RESOURCE_NODE *Rnode;
1482 InitializerOp = Op->Asl.Child;
1483 Rnode = RsAllocateResourceNode (sizeof (ASL_GENERAL_REGISTER_DESC));
1485 Descriptor = Rnode->Buffer;
1486 Descriptor->Grg.DescriptorType = ACPI_RDESC_TYPE_GENERAL_REGISTER;
1487 Descriptor->Grg.Length = 12;
1490 * Process all child initialization nodes
1492 for (i = 0; InitializerOp; i++)
1496 case 0: /* Address space */
1498 Descriptor->Grg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
1499 RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESSSPACE,
1500 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.AddressSpaceId));
1503 case 1: /* Register Bit Width */
1505 Descriptor->Grg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
1506 RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITWIDTH,
1507 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.BitWidth));
1510 case 2: /* Register Bit Offset */
1512 Descriptor->Grg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
1513 RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITOFFSET,
1514 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.BitOffset));
1517 case 3: /* Register Address */
1519 Descriptor->Grg.Address = InitializerOp->Asl.Value.Integer;
1520 RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESS,
1521 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.Address));
1527 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1531 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);