1 /******************************************************************************
3 * Module Name: aslrestype2e - Large Extended address resource descriptors
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2015, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
46 #define _COMPONENT ACPI_COMPILER
47 ACPI_MODULE_NAME ("aslrestype2e")
50 * This module contains the Extended (64-bit) address space descriptors:
57 /*******************************************************************************
59 * FUNCTION: RsDoExtendedIoDescriptor
61 * PARAMETERS: Info - Parse Op and resource template offset
63 * RETURN: Completed resource node
65 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
67 ******************************************************************************/
70 RsDoExtendedIoDescriptor (
71 ASL_RESOURCE_INFO *Info)
73 AML_RESOURCE *Descriptor;
74 ACPI_PARSE_OBJECT *InitializerOp;
75 ACPI_PARSE_OBJECT *MinOp = NULL;
76 ACPI_PARSE_OBJECT *MaxOp = NULL;
77 ACPI_PARSE_OBJECT *LengthOp = NULL;
78 ACPI_PARSE_OBJECT *GranOp = NULL;
79 ASL_RESOURCE_NODE *Rnode;
80 UINT16 StringLength = 0;
81 UINT32 CurrentByteOffset;
85 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
86 StringLength = RsGetStringDataLength (InitializerOp);
87 CurrentByteOffset = Info->CurrentByteOffset;
89 Rnode = RsAllocateResourceNode (
90 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
92 Descriptor = Rnode->Buffer;
93 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
94 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
95 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
97 Descriptor->ExtAddress64.ResourceLength = (UINT16)
98 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
99 sizeof (AML_RESOURCE_LARGE_HEADER));
101 /* Process all child initialization nodes */
103 for (i = 0; InitializerOp; i++)
107 case 0: /* Resource Usage */
109 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
112 case 1: /* MinType */
114 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
115 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
116 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
119 case 2: /* MaxType */
121 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
122 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
123 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
126 case 3: /* DecodeType */
128 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
129 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
130 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
133 case 4: /* Range Type */
135 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
136 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
137 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
140 case 5: /* Address Granularity */
142 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
143 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
144 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
145 GranOp = InitializerOp;
148 case 6: /* Address Min */
150 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
151 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
152 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
153 MinOp = InitializerOp;
156 case 7: /* Address Max */
158 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
159 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
160 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
161 MaxOp = InitializerOp;
164 case 8: /* Translation Offset */
166 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
167 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
168 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
171 case 9: /* Address Length */
173 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
174 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
175 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
176 LengthOp = InitializerOp;
179 case 10: /* Type-Specific Attributes */
181 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
182 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
183 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
186 case 11: /* ResourceTag */
188 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
193 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
194 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
195 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
198 case 13: /* Translation Type */
200 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
201 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
202 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
207 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
211 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
214 /* Validate the Min/Max/Len/Gran values */
216 RsLargeAddressCheck (
217 Descriptor->ExtAddress64.Minimum,
218 Descriptor->ExtAddress64.Maximum,
219 Descriptor->ExtAddress64.AddressLength,
220 Descriptor->ExtAddress64.Granularity,
221 Descriptor->ExtAddress64.Flags,
222 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
224 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
230 /*******************************************************************************
232 * FUNCTION: RsDoExtendedMemoryDescriptor
234 * PARAMETERS: Info - Parse Op and resource template offset
236 * RETURN: Completed resource node
238 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
240 ******************************************************************************/
243 RsDoExtendedMemoryDescriptor (
244 ASL_RESOURCE_INFO *Info)
246 AML_RESOURCE *Descriptor;
247 ACPI_PARSE_OBJECT *InitializerOp;
248 ACPI_PARSE_OBJECT *MinOp = NULL;
249 ACPI_PARSE_OBJECT *MaxOp = NULL;
250 ACPI_PARSE_OBJECT *LengthOp = NULL;
251 ACPI_PARSE_OBJECT *GranOp = NULL;
252 ASL_RESOURCE_NODE *Rnode;
253 UINT16 StringLength = 0;
254 UINT32 CurrentByteOffset;
258 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
259 StringLength = RsGetStringDataLength (InitializerOp);
260 CurrentByteOffset = Info->CurrentByteOffset;
262 Rnode = RsAllocateResourceNode (
263 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
265 Descriptor = Rnode->Buffer;
266 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
267 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
268 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
270 Descriptor->ExtAddress64.ResourceLength = (UINT16)
271 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
272 sizeof (AML_RESOURCE_LARGE_HEADER));
274 /* Process all child initialization nodes */
276 for (i = 0; InitializerOp; i++)
280 case 0: /* Resource Usage */
282 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
285 case 1: /* DecodeType */
287 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
288 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
289 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
292 case 2: /* MinType */
294 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
295 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
296 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
299 case 3: /* MaxType */
301 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
302 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
303 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
306 case 4: /* Memory Type */
308 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
309 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
310 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
313 case 5: /* Read/Write Type */
315 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
316 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
317 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
320 case 6: /* Address Granularity */
322 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
323 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
324 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
325 GranOp = InitializerOp;
328 case 7: /* Min Address */
330 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
331 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
332 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
333 MinOp = InitializerOp;
336 case 8: /* Max Address */
338 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
339 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
340 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
341 MaxOp = InitializerOp;
344 case 9: /* Translation Offset */
346 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
347 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
348 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
351 case 10: /* Address Length */
353 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
354 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
355 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
356 LengthOp = InitializerOp;
359 case 11: /* Type-Specific Attributes */
361 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
362 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
363 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
366 case 12: /* ResourceTag */
368 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
372 case 13: /* Address Range */
374 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
375 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
376 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
381 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
382 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
383 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
388 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
392 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
395 /* Validate the Min/Max/Len/Gran values */
397 RsLargeAddressCheck (
398 Descriptor->ExtAddress64.Minimum,
399 Descriptor->ExtAddress64.Maximum,
400 Descriptor->ExtAddress64.AddressLength,
401 Descriptor->ExtAddress64.Granularity,
402 Descriptor->ExtAddress64.Flags,
403 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
405 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
411 /*******************************************************************************
413 * FUNCTION: RsDoExtendedSpaceDescriptor
415 * PARAMETERS: Info - Parse Op and resource template offset
417 * RETURN: Completed resource node
419 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
421 ******************************************************************************/
424 RsDoExtendedSpaceDescriptor (
425 ASL_RESOURCE_INFO *Info)
427 AML_RESOURCE *Descriptor;
428 ACPI_PARSE_OBJECT *InitializerOp;
429 ACPI_PARSE_OBJECT *MinOp = NULL;
430 ACPI_PARSE_OBJECT *MaxOp = NULL;
431 ACPI_PARSE_OBJECT *LengthOp = NULL;
432 ACPI_PARSE_OBJECT *GranOp = NULL;
433 ASL_RESOURCE_NODE *Rnode;
434 UINT16 StringLength = 0;
435 UINT32 CurrentByteOffset;
439 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
440 StringLength = RsGetStringDataLength (InitializerOp);
441 CurrentByteOffset = Info->CurrentByteOffset;
443 Rnode = RsAllocateResourceNode (
444 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
446 Descriptor = Rnode->Buffer;
447 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
448 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
450 Descriptor->ExtAddress64.ResourceLength = (UINT16)
451 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
452 sizeof (AML_RESOURCE_LARGE_HEADER));
454 /* Process all child initialization nodes */
456 for (i = 0; InitializerOp; i++)
460 case 0: /* Resource Type */
462 Descriptor->ExtAddress64.ResourceType =
463 (UINT8) InitializerOp->Asl.Value.Integer;
466 case 1: /* Resource Usage */
468 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
471 case 2: /* DecodeType */
473 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
474 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
475 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
478 case 3: /* MinType */
480 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
481 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
482 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
485 case 4: /* MaxType */
487 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
488 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
489 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
492 case 5: /* Type-Specific flags */
494 Descriptor->ExtAddress64.SpecificFlags =
495 (UINT8) InitializerOp->Asl.Value.Integer;
498 case 6: /* Address Granularity */
500 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
501 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
502 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
503 GranOp = InitializerOp;
506 case 7: /* Min Address */
508 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
509 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
510 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
511 MinOp = InitializerOp;
514 case 8: /* Max Address */
516 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
517 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
518 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
519 MaxOp = InitializerOp;
522 case 9: /* Translation Offset */
524 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
525 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
526 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
529 case 10: /* Address Length */
531 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
532 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
533 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
534 LengthOp = InitializerOp;
537 case 11: /* Type-Specific Attributes */
539 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
540 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
541 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
544 case 12: /* ResourceTag */
546 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
551 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
555 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
558 /* Validate the Min/Max/Len/Gran values */
560 RsLargeAddressCheck (
561 Descriptor->ExtAddress64.Minimum,
562 Descriptor->ExtAddress64.Maximum,
563 Descriptor->ExtAddress64.AddressLength,
564 Descriptor->ExtAddress64.Granularity,
565 Descriptor->ExtAddress64.Flags,
566 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
568 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +