xref: /illumos-gate/usr/src/cmd/acpi/iasl/aslrestype2w.c (revision 35786f6866ae52207d0f1a25fe7ca5f652f32ce0)
1 /******************************************************************************
2  *
3  * Module Name: aslrestype2w - Large Word address resource descriptors
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #include "aslcompiler.h"
153 #include "aslcompiler.y.h"
154 
155 #define _COMPONENT          ACPI_COMPILER
156         ACPI_MODULE_NAME    ("aslrestype2w")
157 
158 /*
159  * This module contains the Word (16-bit) address space descriptors:
160  *
161  * WordIO
162  * WordMemory
163  * WordSpace
164  */
165 
166 /*******************************************************************************
167  *
168  * FUNCTION:    RsDoWordIoDescriptor
169  *
170  * PARAMETERS:  Info                - Parse Op and resource template offset
171  *
172  * RETURN:      Completed resource node
173  *
174  * DESCRIPTION: Construct a long "WordIO" descriptor
175  *
176  ******************************************************************************/
177 
178 ASL_RESOURCE_NODE *
RsDoWordIoDescriptor(ASL_RESOURCE_INFO * Info)179 RsDoWordIoDescriptor (
180     ASL_RESOURCE_INFO       *Info)
181 {
182     AML_RESOURCE            *Descriptor;
183     ACPI_PARSE_OBJECT       *InitializerOp;
184     ACPI_PARSE_OBJECT       *MinOp = NULL;
185     ACPI_PARSE_OBJECT       *MaxOp = NULL;
186     ACPI_PARSE_OBJECT       *LengthOp = NULL;
187     ACPI_PARSE_OBJECT       *GranOp = NULL;
188     ASL_RESOURCE_NODE       *Rnode;
189     UINT8                   *OptionalFields;
190     UINT16                  StringLength = 0;
191     UINT32                  OptionIndex = 0;
192     UINT32                  CurrentByteOffset;
193     UINT32                  i;
194     BOOLEAN                 ResSourceIndex = FALSE;
195 
196 
197     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
198     StringLength = RsGetStringDataLength (InitializerOp);
199     CurrentByteOffset = Info->CurrentByteOffset;
200 
201     Rnode = RsAllocateResourceNode (
202         sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
203 
204     Descriptor = Rnode->Buffer;
205     Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
206     Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
207 
208     /*
209      * Initial descriptor length -- may be enlarged if there are
210      * optional fields present
211      */
212     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
213     Descriptor->Address16.ResourceLength = (UINT16)
214         (sizeof (AML_RESOURCE_ADDRESS16) -
215          sizeof (AML_RESOURCE_LARGE_HEADER));
216 
217     /* Process all child initialization nodes */
218 
219     for (i = 0; InitializerOp; i++)
220     {
221         switch (i)
222         {
223         case 0: /* Resource Usage */
224 
225             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
226             break;
227 
228         case 1: /* MinType */
229 
230             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
231             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
232                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
233             break;
234 
235         case 2: /* MaxType */
236 
237             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
238             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
239                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
240             break;
241 
242         case 3: /* DecodeType */
243 
244             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
245             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
246                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
247             break;
248 
249         case 4: /* Range Type */
250 
251             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
252             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
253                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0, 2);
254             break;
255 
256         case 5: /* Address Granularity */
257 
258             Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
259             RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
260                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
261             GranOp = InitializerOp;
262             break;
263 
264         case 6: /* Address Min */
265 
266             Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
267             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
268                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
269             MinOp = InitializerOp;
270             break;
271 
272         case 7: /* Address Max */
273 
274             Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
275             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
276                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
277             MaxOp = InitializerOp;
278             break;
279 
280         case 8: /* Translation Offset */
281 
282             Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
283             RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
284                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
285             break;
286 
287         case 9: /* Address Length */
288 
289             Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
290             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
291                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
292             LengthOp = InitializerOp;
293             break;
294 
295         case 10: /* ResSourceIndex [Optional Field - BYTE] */
296 
297             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
298             {
299                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
300                 OptionIndex++;
301                 Descriptor->Address16.ResourceLength++;
302                 ResSourceIndex = TRUE;
303             }
304             break;
305 
306         case 11: /* ResSource [Optional Field - STRING] */
307 
308             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
309                 (InitializerOp->Asl.Value.String))
310             {
311                 if (StringLength)
312                 {
313                     Descriptor->Address16.ResourceLength = (UINT16)
314                         (Descriptor->Address16.ResourceLength + StringLength);
315 
316                     strcpy ((char *)
317                         &OptionalFields[OptionIndex],
318                         InitializerOp->Asl.Value.String);
319 
320                     /* ResourceSourceIndex must also be valid */
321 
322                     if (!ResSourceIndex)
323                     {
324                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
325                             InitializerOp, NULL);
326                     }
327                 }
328             }
329 
330 #if 0
331             /*
332              * Not a valid ResourceSource, ResourceSourceIndex must also
333              * be invalid
334              */
335             else if (ResSourceIndex)
336             {
337                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
338                     InitializerOp, NULL);
339             }
340 #endif
341             break;
342 
343         case 12: /* ResourceTag */
344 
345             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
346             break;
347 
348         case 13: /* Type */
349 
350             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0);
351             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
352                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4);
353             break;
354 
355         case 14: /* Translation Type */
356 
357             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0);
358             RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
359                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5);
360             break;
361 
362         default:
363 
364             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
365             break;
366         }
367 
368         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
369     }
370 
371     /* Validate the Min/Max/Len/Gran values */
372 
373     RsLargeAddressCheck (
374         (UINT64) Descriptor->Address16.Minimum,
375         (UINT64) Descriptor->Address16.Maximum,
376         (UINT64) Descriptor->Address16.AddressLength,
377         (UINT64) Descriptor->Address16.Granularity,
378         Descriptor->Address16.Flags,
379         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
380 
381     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
382         OptionIndex + StringLength;
383     return (Rnode);
384 }
385 
386 
387 /*******************************************************************************
388  *
389  * FUNCTION:    RsDoWordBusNumberDescriptor
390  *
391  * PARAMETERS:  Info                - Parse Op and resource template offset
392  *
393  * RETURN:      Completed resource node
394  *
395  * DESCRIPTION: Construct a long "WordBusNumber" descriptor
396  *
397  ******************************************************************************/
398 
399 ASL_RESOURCE_NODE *
RsDoWordBusNumberDescriptor(ASL_RESOURCE_INFO * Info)400 RsDoWordBusNumberDescriptor (
401     ASL_RESOURCE_INFO       *Info)
402 {
403     AML_RESOURCE            *Descriptor;
404     ACPI_PARSE_OBJECT       *InitializerOp;
405     ACPI_PARSE_OBJECT       *MinOp = NULL;
406     ACPI_PARSE_OBJECT       *MaxOp = NULL;
407     ACPI_PARSE_OBJECT       *LengthOp = NULL;
408     ACPI_PARSE_OBJECT       *GranOp = NULL;
409     ASL_RESOURCE_NODE       *Rnode;
410     UINT8                   *OptionalFields;
411     UINT16                  StringLength = 0;
412     UINT32                  OptionIndex = 0;
413     UINT32                  CurrentByteOffset;
414     UINT32                  i;
415     BOOLEAN                 ResSourceIndex = FALSE;
416 
417 
418     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
419     StringLength = RsGetStringDataLength (InitializerOp);
420     CurrentByteOffset = Info->CurrentByteOffset;
421 
422     Rnode = RsAllocateResourceNode (
423         sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
424 
425     Descriptor = Rnode->Buffer;
426     Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
427     Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE;
428 
429     /*
430      * Initial descriptor length -- may be enlarged if there are
431      * optional fields present
432      */
433     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
434     Descriptor->Address16.ResourceLength = (UINT16)
435         (sizeof (AML_RESOURCE_ADDRESS16) -
436          sizeof (AML_RESOURCE_LARGE_HEADER));
437 
438     /* Process all child initialization nodes */
439 
440     for (i = 0; InitializerOp; i++)
441     {
442         switch (i)
443         {
444         case 0: /* Resource Usage */
445 
446             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
447             break;
448 
449         case 1: /* MinType */
450 
451             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
452             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
453                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
454             break;
455 
456         case 2: /* MaxType */
457 
458             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
459             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
460                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
461             break;
462 
463         case 3: /* DecodeType */
464 
465             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
466             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
467                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
468             break;
469 
470         case 4: /* Address Granularity */
471 
472             Descriptor->Address16.Granularity =
473                 (UINT16) InitializerOp->Asl.Value.Integer;
474             RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
475                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
476             GranOp = InitializerOp;
477             break;
478 
479         case 5: /* Min Address */
480 
481             Descriptor->Address16.Minimum =
482                 (UINT16) InitializerOp->Asl.Value.Integer;
483             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
484                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
485             MinOp = InitializerOp;
486             break;
487 
488         case 6: /* Max Address */
489 
490             Descriptor->Address16.Maximum =
491                 (UINT16) InitializerOp->Asl.Value.Integer;
492             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
493                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
494             MaxOp = InitializerOp;
495             break;
496 
497         case 7: /* Translation Offset */
498 
499             Descriptor->Address16.TranslationOffset =
500                 (UINT16) InitializerOp->Asl.Value.Integer;
501             RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
502                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
503             break;
504 
505         case 8: /* Address Length */
506 
507             Descriptor->Address16.AddressLength =
508                 (UINT16) InitializerOp->Asl.Value.Integer;
509             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
510                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
511             LengthOp = InitializerOp;
512             break;
513 
514         case 9: /* ResSourceIndex [Optional Field - BYTE] */
515 
516             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
517             {
518                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
519                 OptionIndex++;
520                 Descriptor->Address16.ResourceLength++;
521                 ResSourceIndex = TRUE;
522             }
523             break;
524 
525         case 10: /* ResSource [Optional Field - STRING] */
526 
527             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
528                 (InitializerOp->Asl.Value.String))
529             {
530                 if (StringLength)
531                 {
532                     Descriptor->Address16.ResourceLength = (UINT16)
533                         (Descriptor->Address16.ResourceLength + StringLength);
534 
535                     strcpy ((char *)
536                         &OptionalFields[OptionIndex],
537                         InitializerOp->Asl.Value.String);
538 
539                     /* ResourceSourceIndex must also be valid */
540 
541                     if (!ResSourceIndex)
542                     {
543                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
544                             InitializerOp, NULL);
545                     }
546                 }
547             }
548 
549 #if 0
550             /*
551              * Not a valid ResourceSource, ResourceSourceIndex must also
552              * be invalid
553              */
554             else if (ResSourceIndex)
555             {
556                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
557                     InitializerOp, NULL);
558             }
559 #endif
560             break;
561 
562         case 11: /* ResourceTag */
563 
564             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
565             break;
566 
567         default:
568 
569             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
570             break;
571         }
572 
573         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
574     }
575 
576     /* Validate the Min/Max/Len/Gran values */
577 
578     RsLargeAddressCheck (
579         (UINT64) Descriptor->Address16.Minimum,
580         (UINT64) Descriptor->Address16.Maximum,
581         (UINT64) Descriptor->Address16.AddressLength,
582         (UINT64) Descriptor->Address16.Granularity,
583         Descriptor->Address16.Flags,
584         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
585 
586     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
587         OptionIndex + StringLength;
588     return (Rnode);
589 }
590 
591 
592 /*******************************************************************************
593  *
594  * FUNCTION:    RsDoWordSpaceDescriptor
595  *
596  * PARAMETERS:  Info                - Parse Op and resource template offset
597  *
598  * RETURN:      Completed resource node
599  *
600  * DESCRIPTION: Construct a long "WordSpace" descriptor
601  *
602  ******************************************************************************/
603 
604 ASL_RESOURCE_NODE *
RsDoWordSpaceDescriptor(ASL_RESOURCE_INFO * Info)605 RsDoWordSpaceDescriptor (
606     ASL_RESOURCE_INFO       *Info)
607 {
608     AML_RESOURCE            *Descriptor;
609     ACPI_PARSE_OBJECT       *InitializerOp;
610     ACPI_PARSE_OBJECT       *MinOp = NULL;
611     ACPI_PARSE_OBJECT       *MaxOp = NULL;
612     ACPI_PARSE_OBJECT       *LengthOp = NULL;
613     ACPI_PARSE_OBJECT       *GranOp = NULL;
614     ASL_RESOURCE_NODE       *Rnode;
615     UINT8                   *OptionalFields;
616     UINT16                  StringLength = 0;
617     UINT32                  OptionIndex = 0;
618     UINT32                  CurrentByteOffset;
619     UINT32                  i;
620     BOOLEAN                 ResSourceIndex = FALSE;
621 
622 
623     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
624     StringLength = RsGetStringDataLength (InitializerOp);
625     CurrentByteOffset = Info->CurrentByteOffset;
626 
627     Rnode = RsAllocateResourceNode (
628         sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
629 
630     Descriptor = Rnode->Buffer;
631     Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16;
632 
633     /*
634      * Initial descriptor length -- may be enlarged if there are
635      * optional fields present
636      */
637     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
638     Descriptor->Address16.ResourceLength = (UINT16)
639         (sizeof (AML_RESOURCE_ADDRESS16) -
640          sizeof (AML_RESOURCE_LARGE_HEADER));
641 
642     /* Process all child initialization nodes */
643 
644     for (i = 0; InitializerOp; i++)
645     {
646         switch (i)
647         {
648         case 0: /* Resource Type */
649 
650             Descriptor->Address16.ResourceType =
651                 (UINT8) InitializerOp->Asl.Value.Integer;
652             break;
653 
654         case 1: /* Resource Usage */
655 
656             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
657             break;
658 
659         case 2: /* DecodeType */
660 
661             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
662             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
663                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
664             break;
665 
666         case 3: /* MinType */
667 
668             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
669             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
670                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
671             break;
672 
673         case 4: /* MaxType */
674 
675             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
676             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
677                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
678             break;
679 
680         case 5: /* Type-Specific flags */
681 
682             Descriptor->Address16.SpecificFlags =
683                 (UINT8) InitializerOp->Asl.Value.Integer;
684             break;
685 
686         case 6: /* Address Granularity */
687 
688             Descriptor->Address16.Granularity =
689                 (UINT16) InitializerOp->Asl.Value.Integer;
690             RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
691                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
692             GranOp = InitializerOp;
693             break;
694 
695         case 7: /* Min Address */
696 
697             Descriptor->Address16.Minimum =
698                 (UINT16) InitializerOp->Asl.Value.Integer;
699             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
700                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
701             MinOp = InitializerOp;
702             break;
703 
704         case 8: /* Max Address */
705 
706             Descriptor->Address16.Maximum =
707                 (UINT16) InitializerOp->Asl.Value.Integer;
708             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
709                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
710             MaxOp = InitializerOp;
711             break;
712 
713         case 9: /* Translation Offset */
714 
715             Descriptor->Address16.TranslationOffset =
716                 (UINT16) InitializerOp->Asl.Value.Integer;
717             RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
718                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
719             break;
720 
721         case 10: /* Address Length */
722 
723             Descriptor->Address16.AddressLength =
724                 (UINT16) InitializerOp->Asl.Value.Integer;
725             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
726                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
727             LengthOp = InitializerOp;
728             break;
729 
730         case 11: /* ResSourceIndex [Optional Field - BYTE] */
731 
732             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
733             {
734                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
735                 OptionIndex++;
736                 Descriptor->Address16.ResourceLength++;
737                 ResSourceIndex = TRUE;
738             }
739             break;
740 
741         case 12: /* ResSource [Optional Field - STRING] */
742 
743             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
744                 (InitializerOp->Asl.Value.String))
745             {
746                 if (StringLength)
747                 {
748                     Descriptor->Address16.ResourceLength = (UINT16)
749                         (Descriptor->Address16.ResourceLength + StringLength);
750 
751                     strcpy ((char *)
752                         &OptionalFields[OptionIndex],
753                         InitializerOp->Asl.Value.String);
754 
755                     /* ResourceSourceIndex must also be valid */
756 
757                     if (!ResSourceIndex)
758                     {
759                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
760                             InitializerOp, NULL);
761                     }
762                 }
763             }
764 
765 #if 0
766             /*
767              * Not a valid ResourceSource, ResourceSourceIndex must also
768              * be invalid
769              */
770             else if (ResSourceIndex)
771             {
772                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
773                     InitializerOp, NULL);
774             }
775 #endif
776             break;
777 
778         case 13: /* ResourceTag */
779 
780             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
781             break;
782 
783         default:
784 
785             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
786             break;
787         }
788 
789         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
790     }
791 
792     /* Validate the Min/Max/Len/Gran values */
793 
794     RsLargeAddressCheck (
795         (UINT64) Descriptor->Address16.Minimum,
796         (UINT64) Descriptor->Address16.Maximum,
797         (UINT64) Descriptor->Address16.AddressLength,
798         (UINT64) Descriptor->Address16.Granularity,
799         Descriptor->Address16.Flags,
800         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
801 
802     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
803         OptionIndex + StringLength;
804     return (Rnode);
805 }
806