2 /******************************************************************************
4 * Module Name: aslrestype2e - Large Extended address resource descriptors
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
48 #define _COMPONENT ACPI_COMPILER
49 ACPI_MODULE_NAME ("aslrestype2e")
52 * This module contains the Extended (64-bit) address space descriptors:
59 /*******************************************************************************
61 * FUNCTION: RsDoExtendedIoDescriptor
63 * PARAMETERS: Op - Parent resource descriptor parse node
64 * CurrentByteOffset - Offset into the resource template AML
65 * buffer (to track references to the desc)
67 * RETURN: Completed resource node
69 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
71 ******************************************************************************/
74 RsDoExtendedIoDescriptor (
75 ACPI_PARSE_OBJECT *Op,
76 UINT32 CurrentByteOffset)
78 AML_RESOURCE *Descriptor;
79 ACPI_PARSE_OBJECT *InitializerOp;
80 ACPI_PARSE_OBJECT *MinOp = NULL;
81 ACPI_PARSE_OBJECT *MaxOp = NULL;
82 ACPI_PARSE_OBJECT *LengthOp = NULL;
83 ACPI_PARSE_OBJECT *GranOp = NULL;
84 ASL_RESOURCE_NODE *Rnode;
85 UINT16 StringLength = 0;
89 InitializerOp = Op->Asl.Child;
90 StringLength = RsGetStringDataLength (InitializerOp);
92 Rnode = RsAllocateResourceNode (
93 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
95 Descriptor = Rnode->Buffer;
96 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
97 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
98 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
100 Descriptor->ExtAddress64.ResourceLength = (UINT16)
101 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
102 sizeof (AML_RESOURCE_LARGE_HEADER));
104 /* Process all child initialization nodes */
106 for (i = 0; InitializerOp; i++)
110 case 0: /* Resource Usage */
112 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
115 case 1: /* MinType */
117 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
118 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
119 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
122 case 2: /* MaxType */
124 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
125 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
126 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
129 case 3: /* DecodeType */
131 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
132 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
133 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
136 case 4: /* Range Type */
138 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
139 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
140 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
143 case 5: /* Address Granularity */
145 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
146 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
147 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
148 GranOp = InitializerOp;
151 case 6: /* Address Min */
153 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
154 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
155 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
156 MinOp = InitializerOp;
159 case 7: /* Address Max */
161 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
162 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
163 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
164 MaxOp = InitializerOp;
167 case 8: /* Translation Offset */
169 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
170 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
171 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
174 case 9: /* Address Length */
176 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
177 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
178 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
179 LengthOp = InitializerOp;
182 case 10: /* Type-Specific Attributes */
184 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
185 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
186 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
189 case 11: /* ResourceTag */
191 UtAttachNamepathToOwner (Op, InitializerOp);
196 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
197 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
198 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
201 case 13: /* Translation Type */
203 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
204 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
205 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
210 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
214 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
217 /* Validate the Min/Max/Len/Gran values */
219 RsLargeAddressCheck (
220 Descriptor->ExtAddress64.Minimum,
221 Descriptor->ExtAddress64.Maximum,
222 Descriptor->ExtAddress64.AddressLength,
223 Descriptor->ExtAddress64.Granularity,
224 Descriptor->ExtAddress64.Flags,
225 MinOp, MaxOp, LengthOp, GranOp, Op);
227 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
232 /*******************************************************************************
234 * FUNCTION: RsDoExtendedMemoryDescriptor
236 * PARAMETERS: Op - Parent resource descriptor parse node
237 * CurrentByteOffset - Offset into the resource template AML
238 * buffer (to track references to the desc)
240 * RETURN: Completed resource node
242 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
244 ******************************************************************************/
247 RsDoExtendedMemoryDescriptor (
248 ACPI_PARSE_OBJECT *Op,
249 UINT32 CurrentByteOffset)
251 AML_RESOURCE *Descriptor;
252 ACPI_PARSE_OBJECT *InitializerOp;
253 ACPI_PARSE_OBJECT *MinOp = NULL;
254 ACPI_PARSE_OBJECT *MaxOp = NULL;
255 ACPI_PARSE_OBJECT *LengthOp = NULL;
256 ACPI_PARSE_OBJECT *GranOp = NULL;
257 ASL_RESOURCE_NODE *Rnode;
258 UINT16 StringLength = 0;
262 InitializerOp = Op->Asl.Child;
263 StringLength = RsGetStringDataLength (InitializerOp);
265 Rnode = RsAllocateResourceNode (
266 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
268 Descriptor = Rnode->Buffer;
269 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
270 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
271 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
273 Descriptor->ExtAddress64.ResourceLength = (UINT16)
274 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
275 sizeof (AML_RESOURCE_LARGE_HEADER));
277 /* Process all child initialization nodes */
279 for (i = 0; InitializerOp; i++)
283 case 0: /* Resource Usage */
285 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
288 case 1: /* DecodeType */
290 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
291 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
292 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
295 case 2: /* MinType */
297 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
298 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
299 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
302 case 3: /* MaxType */
304 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
305 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
306 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
309 case 4: /* Memory Type */
311 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
312 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
313 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
316 case 5: /* Read/Write Type */
318 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
319 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
320 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
323 case 6: /* Address Granularity */
325 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
326 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
327 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
328 GranOp = InitializerOp;
331 case 7: /* Min Address */
333 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
334 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
335 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
336 MinOp = InitializerOp;
339 case 8: /* Max Address */
341 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
342 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
343 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
344 MaxOp = InitializerOp;
347 case 9: /* Translation Offset */
349 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
350 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
351 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
354 case 10: /* Address Length */
356 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
357 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
358 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
359 LengthOp = InitializerOp;
362 case 11: /* Type-Specific Attributes */
364 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
365 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
366 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
369 case 12: /* ResourceTag */
371 UtAttachNamepathToOwner (Op, InitializerOp);
375 case 13: /* Address Range */
377 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
378 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
379 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
384 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
385 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
386 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
391 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
395 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
398 /* Validate the Min/Max/Len/Gran values */
400 RsLargeAddressCheck (
401 Descriptor->ExtAddress64.Minimum,
402 Descriptor->ExtAddress64.Maximum,
403 Descriptor->ExtAddress64.AddressLength,
404 Descriptor->ExtAddress64.Granularity,
405 Descriptor->ExtAddress64.Flags,
406 MinOp, MaxOp, LengthOp, GranOp, Op);
408 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
413 /*******************************************************************************
415 * FUNCTION: RsDoExtendedSpaceDescriptor
417 * PARAMETERS: Op - Parent resource descriptor parse node
418 * CurrentByteOffset - Offset into the resource template AML
419 * buffer (to track references to the desc)
421 * RETURN: Completed resource node
423 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
425 ******************************************************************************/
428 RsDoExtendedSpaceDescriptor (
429 ACPI_PARSE_OBJECT *Op,
430 UINT32 CurrentByteOffset)
432 AML_RESOURCE *Descriptor;
433 ACPI_PARSE_OBJECT *InitializerOp;
434 ACPI_PARSE_OBJECT *MinOp = NULL;
435 ACPI_PARSE_OBJECT *MaxOp = NULL;
436 ACPI_PARSE_OBJECT *LengthOp = NULL;
437 ACPI_PARSE_OBJECT *GranOp = NULL;
438 ASL_RESOURCE_NODE *Rnode;
439 UINT16 StringLength = 0;
443 InitializerOp = Op->Asl.Child;
444 StringLength = RsGetStringDataLength (InitializerOp);
446 Rnode = RsAllocateResourceNode (
447 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
449 Descriptor = Rnode->Buffer;
450 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
451 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
453 Descriptor->ExtAddress64.ResourceLength = (UINT16)
454 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
455 sizeof (AML_RESOURCE_LARGE_HEADER));
457 /* Process all child initialization nodes */
459 for (i = 0; InitializerOp; i++)
463 case 0: /* Resource Type */
465 Descriptor->ExtAddress64.ResourceType =
466 (UINT8) InitializerOp->Asl.Value.Integer;
469 case 1: /* Resource Usage */
471 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
474 case 2: /* DecodeType */
476 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
477 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
478 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
481 case 3: /* MinType */
483 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
484 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
485 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
488 case 4: /* MaxType */
490 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
491 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
492 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
495 case 5: /* Type-Specific flags */
497 Descriptor->ExtAddress64.SpecificFlags =
498 (UINT8) InitializerOp->Asl.Value.Integer;
501 case 6: /* Address Granularity */
503 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
504 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
505 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
506 GranOp = InitializerOp;
509 case 7: /* Min Address */
511 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
512 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
513 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
514 MinOp = InitializerOp;
517 case 8: /* Max Address */
519 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
520 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
521 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
522 MaxOp = InitializerOp;
525 case 9: /* Translation Offset */
527 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
528 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
529 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
532 case 10: /* Address Length */
534 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
535 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
536 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
537 LengthOp = InitializerOp;
540 case 11: /* Type-Specific Attributes */
542 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
543 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
544 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
547 case 12: /* ResourceTag */
549 UtAttachNamepathToOwner (Op, InitializerOp);
554 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
558 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
561 /* Validate the Min/Max/Len/Gran values */
563 RsLargeAddressCheck (
564 Descriptor->ExtAddress64.Minimum,
565 Descriptor->ExtAddress64.Maximum,
566 Descriptor->ExtAddress64.AddressLength,
567 Descriptor->ExtAddress64.Granularity,
568 Descriptor->ExtAddress64.Flags,
569 MinOp, MaxOp, LengthOp, GranOp, Op);
571 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;