1 /******************************************************************************
2 *
3 * Module Name: aslrestype2e - Large Extended address resource descriptors
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2023, 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
154 #define _COMPONENT ACPI_COMPILER
155 ACPI_MODULE_NAME ("aslrestype2e")
156
157 /*
158 * This module contains the Extended (64-bit) address space descriptors:
159 *
160 * ExtendedIO
161 * ExtendedMemory
162 * ExtendedSpace
163 */
164
165 /*******************************************************************************
166 *
167 * FUNCTION: RsDoExtendedIoDescriptor
168 *
169 * PARAMETERS: Info - Parse Op and resource template offset
170 *
171 * RETURN: Completed resource node
172 *
173 * DESCRIPTION: Construct a long "ExtendedIO" descriptor
174 *
175 ******************************************************************************/
176
177 ASL_RESOURCE_NODE *
RsDoExtendedIoDescriptor(ASL_RESOURCE_INFO * Info)178 RsDoExtendedIoDescriptor (
179 ASL_RESOURCE_INFO *Info)
180 {
181 AML_RESOURCE *Descriptor;
182 ACPI_PARSE_OBJECT *InitializerOp;
183 ACPI_PARSE_OBJECT *MinOp = NULL;
184 ACPI_PARSE_OBJECT *MaxOp = NULL;
185 ACPI_PARSE_OBJECT *LengthOp = NULL;
186 ACPI_PARSE_OBJECT *GranOp = NULL;
187 ASL_RESOURCE_NODE *Rnode;
188 UINT16 StringLength = 0;
189 UINT32 CurrentByteOffset;
190 UINT32 i;
191
192
193 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
194 StringLength = RsGetStringDataLength (InitializerOp);
195 CurrentByteOffset = Info->CurrentByteOffset;
196
197 Rnode = RsAllocateResourceNode (
198 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
199
200 Descriptor = Rnode->Buffer;
201 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
202 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
203 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
204
205 Descriptor->ExtAddress64.ResourceLength = (UINT16)
206 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
207 sizeof (AML_RESOURCE_LARGE_HEADER));
208
209 /* Process all child initialization nodes */
210
211 for (i = 0; InitializerOp; i++)
212 {
213 switch (i)
214 {
215 case 0: /* Resource Usage */
216
217 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
218 break;
219
220 case 1: /* MinType */
221
222 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
223 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
224 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
225 break;
226
227 case 2: /* MaxType */
228
229 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
230 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
231 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
232 break;
233
234 case 3: /* DecodeType */
235
236 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
237 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
238 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
239 break;
240
241 case 4: /* Range Type */
242
243 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
244 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
245 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
246 break;
247
248 case 5: /* Address Granularity */
249
250 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
251 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
252 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
253 GranOp = InitializerOp;
254 break;
255
256 case 6: /* Address Min */
257
258 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
259 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
260 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
261 MinOp = InitializerOp;
262 break;
263
264 case 7: /* Address Max */
265
266 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
267 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
268 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
269 MaxOp = InitializerOp;
270 break;
271
272 case 8: /* Translation Offset */
273
274 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
275 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
276 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
277 break;
278
279 case 9: /* Address Length */
280
281 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
282 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
283 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
284 LengthOp = InitializerOp;
285 break;
286
287 case 10: /* Type-Specific Attributes */
288
289 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
290 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
291 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
292 break;
293
294 case 11: /* ResourceTag */
295
296 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
297 break;
298
299 case 12: /* Type */
300
301 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
302 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
303 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
304 break;
305
306 case 13: /* Translation Type */
307
308 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
309 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
310 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
311 break;
312
313 default:
314
315 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
316 break;
317 }
318
319 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
320 }
321
322 /* Validate the Min/Max/Len/Gran values */
323
324 RsLargeAddressCheck (
325 Descriptor->ExtAddress64.Minimum,
326 Descriptor->ExtAddress64.Maximum,
327 Descriptor->ExtAddress64.AddressLength,
328 Descriptor->ExtAddress64.Granularity,
329 Descriptor->ExtAddress64.Flags,
330 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
331
332 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
333 StringLength;
334 return (Rnode);
335 }
336
337
338 /*******************************************************************************
339 *
340 * FUNCTION: RsDoExtendedMemoryDescriptor
341 *
342 * PARAMETERS: Info - Parse Op and resource template offset
343 *
344 * RETURN: Completed resource node
345 *
346 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
347 *
348 ******************************************************************************/
349
350 ASL_RESOURCE_NODE *
RsDoExtendedMemoryDescriptor(ASL_RESOURCE_INFO * Info)351 RsDoExtendedMemoryDescriptor (
352 ASL_RESOURCE_INFO *Info)
353 {
354 AML_RESOURCE *Descriptor;
355 ACPI_PARSE_OBJECT *InitializerOp;
356 ACPI_PARSE_OBJECT *MinOp = NULL;
357 ACPI_PARSE_OBJECT *MaxOp = NULL;
358 ACPI_PARSE_OBJECT *LengthOp = NULL;
359 ACPI_PARSE_OBJECT *GranOp = NULL;
360 ASL_RESOURCE_NODE *Rnode;
361 UINT16 StringLength = 0;
362 UINT32 CurrentByteOffset;
363 UINT32 i;
364
365
366 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
367 StringLength = RsGetStringDataLength (InitializerOp);
368 CurrentByteOffset = Info->CurrentByteOffset;
369
370 Rnode = RsAllocateResourceNode (
371 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
372
373 Descriptor = Rnode->Buffer;
374 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
375 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
376 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
377
378 Descriptor->ExtAddress64.ResourceLength = (UINT16)
379 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
380 sizeof (AML_RESOURCE_LARGE_HEADER));
381
382 /* Process all child initialization nodes */
383
384 for (i = 0; InitializerOp; i++)
385 {
386 switch (i)
387 {
388 case 0: /* Resource Usage */
389
390 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
391 break;
392
393 case 1: /* DecodeType */
394
395 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
396 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
397 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
398 break;
399
400 case 2: /* MinType */
401
402 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
403 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
404 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
405 break;
406
407 case 3: /* MaxType */
408
409 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
410 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
411 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
412 break;
413
414 case 4: /* Memory Type */
415
416 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
417 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
418 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
419 break;
420
421 case 5: /* Read/Write Type */
422
423 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
424 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
425 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
426 break;
427
428 case 6: /* Address Granularity */
429
430 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
431 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
432 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
433 GranOp = InitializerOp;
434 break;
435
436 case 7: /* Min Address */
437
438 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
439 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
440 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
441 MinOp = InitializerOp;
442 break;
443
444 case 8: /* Max Address */
445
446 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
447 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
448 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
449 MaxOp = InitializerOp;
450 break;
451
452 case 9: /* Translation Offset */
453
454 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
455 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
456 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
457 break;
458
459 case 10: /* Address Length */
460
461 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
462 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
463 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
464 LengthOp = InitializerOp;
465 break;
466
467 case 11: /* Type-Specific Attributes */
468
469 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
470 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
471 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
472 break;
473
474 case 12: /* ResourceTag */
475
476 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
477 break;
478
479
480 case 13: /* Address Range */
481
482 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
483 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
484 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
485 break;
486
487 case 14: /* Type */
488
489 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
490 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
491 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
492 break;
493
494 default:
495
496 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
497 break;
498 }
499
500 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
501 }
502
503 /* Validate the Min/Max/Len/Gran values */
504
505 RsLargeAddressCheck (
506 Descriptor->ExtAddress64.Minimum,
507 Descriptor->ExtAddress64.Maximum,
508 Descriptor->ExtAddress64.AddressLength,
509 Descriptor->ExtAddress64.Granularity,
510 Descriptor->ExtAddress64.Flags,
511 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
512
513 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
514 StringLength;
515 return (Rnode);
516 }
517
518
519 /*******************************************************************************
520 *
521 * FUNCTION: RsDoExtendedSpaceDescriptor
522 *
523 * PARAMETERS: Info - Parse Op and resource template offset
524 *
525 * RETURN: Completed resource node
526 *
527 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
528 *
529 ******************************************************************************/
530
531 ASL_RESOURCE_NODE *
RsDoExtendedSpaceDescriptor(ASL_RESOURCE_INFO * Info)532 RsDoExtendedSpaceDescriptor (
533 ASL_RESOURCE_INFO *Info)
534 {
535 AML_RESOURCE *Descriptor;
536 ACPI_PARSE_OBJECT *InitializerOp;
537 ACPI_PARSE_OBJECT *MinOp = NULL;
538 ACPI_PARSE_OBJECT *MaxOp = NULL;
539 ACPI_PARSE_OBJECT *LengthOp = NULL;
540 ACPI_PARSE_OBJECT *GranOp = NULL;
541 ASL_RESOURCE_NODE *Rnode;
542 UINT16 StringLength = 0;
543 UINT32 CurrentByteOffset;
544 UINT32 i;
545
546
547 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
548 StringLength = RsGetStringDataLength (InitializerOp);
549 CurrentByteOffset = Info->CurrentByteOffset;
550
551 Rnode = RsAllocateResourceNode (
552 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
553
554 Descriptor = Rnode->Buffer;
555 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
556 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
557
558 Descriptor->ExtAddress64.ResourceLength = (UINT16)
559 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
560 sizeof (AML_RESOURCE_LARGE_HEADER));
561
562 /* Process all child initialization nodes */
563
564 for (i = 0; InitializerOp; i++)
565 {
566 switch (i)
567 {
568 case 0: /* Resource Type */
569
570 Descriptor->ExtAddress64.ResourceType =
571 (UINT8) InitializerOp->Asl.Value.Integer;
572 break;
573
574 case 1: /* Resource Usage */
575
576 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
577 break;
578
579 case 2: /* DecodeType */
580
581 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
582 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
583 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
584 break;
585
586 case 3: /* MinType */
587
588 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
589 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
590 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
591 break;
592
593 case 4: /* MaxType */
594
595 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
596 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
597 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
598 break;
599
600 case 5: /* Type-Specific flags */
601
602 Descriptor->ExtAddress64.SpecificFlags =
603 (UINT8) InitializerOp->Asl.Value.Integer;
604 break;
605
606 case 6: /* Address Granularity */
607
608 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
609 RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
610 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
611 GranOp = InitializerOp;
612 break;
613
614 case 7: /* Min Address */
615
616 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
617 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
618 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
619 MinOp = InitializerOp;
620 break;
621
622 case 8: /* Max Address */
623
624 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
625 RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
626 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
627 MaxOp = InitializerOp;
628 break;
629
630 case 9: /* Translation Offset */
631
632 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
633 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
634 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
635 break;
636
637 case 10: /* Address Length */
638
639 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
640 RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
641 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
642 LengthOp = InitializerOp;
643 break;
644
645 case 11: /* Type-Specific Attributes */
646
647 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
648 RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
649 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
650 break;
651
652 case 12: /* ResourceTag */
653
654 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
655 break;
656
657 default:
658
659 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
660 break;
661 }
662
663 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
664 }
665
666 /* Validate the Min/Max/Len/Gran values */
667
668 RsLargeAddressCheck (
669 Descriptor->ExtAddress64.Minimum,
670 Descriptor->ExtAddress64.Maximum,
671 Descriptor->ExtAddress64.AddressLength,
672 Descriptor->ExtAddress64.Granularity,
673 Descriptor->ExtAddress64.Flags,
674 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
675
676 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
677 StringLength;
678 return (Rnode);
679 }
680
