1 /******************************************************************************
2 *
3 * Module Name: aslrestype2d - Large DWord address resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44 #include "aslcompiler.h"
45 #include "aslcompiler.y.h"
46
47 #define _COMPONENT ACPI_COMPILER
48 ACPI_MODULE_NAME ("aslrestype2d")
49
50 /*
51 * This module contains the Dword (32-bit) address space descriptors:
52 *
53 * DwordIO
54 * DwordMemory
55 * DwordSpace
56 */
57
58 /*******************************************************************************
59 *
60 * FUNCTION: RsDoDwordIoDescriptor
61 *
62 * PARAMETERS: Info - Parse Op and resource template offset
63 *
64 * RETURN: Completed resource node
65 *
66 * DESCRIPTION: Construct a long "DwordIO" descriptor
67 *
68 ******************************************************************************/
69
70 ASL_RESOURCE_NODE *
RsDoDwordIoDescriptor(ASL_RESOURCE_INFO * Info)71 RsDoDwordIoDescriptor (
72 ASL_RESOURCE_INFO *Info)
73 {
74 AML_RESOURCE *Descriptor;
75 ACPI_PARSE_OBJECT *InitializerOp;
76 ACPI_PARSE_OBJECT *MinOp = NULL;
77 ACPI_PARSE_OBJECT *MaxOp = NULL;
78 ACPI_PARSE_OBJECT *LengthOp = NULL;
79 ACPI_PARSE_OBJECT *GranOp = NULL;
80 ASL_RESOURCE_NODE *Rnode;
81 UINT16 StringLength = 0;
82 UINT32 OptionIndex = 0;
83 UINT8 *OptionalFields;
84 UINT32 CurrentByteOffset;
85 UINT32 i;
86 BOOLEAN ResSourceIndex = FALSE;
87
88
89 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
90 StringLength = RsGetStringDataLength (InitializerOp);
91 CurrentByteOffset = Info->CurrentByteOffset;
92
93 Rnode = RsAllocateResourceNode (
94 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
95
96 Descriptor = Rnode->Buffer;
97 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
98 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE;
99
100 /*
101 * Initial descriptor length -- may be enlarged if there are
102 * optional fields present
103 */
104 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
105 Descriptor->Address32.ResourceLength = (UINT16)
106 (sizeof (AML_RESOURCE_ADDRESS32) -
107 sizeof (AML_RESOURCE_LARGE_HEADER));
108
109 /* Process all child initialization nodes */
110
111 for (i = 0; InitializerOp; i++)
112 {
113 switch (i)
114 {
115 case 0: /* Resource Usage */
116
117 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
118 break;
119
120 case 1: /* MinType */
121
122 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
124 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
125 break;
126
127 case 2: /* MaxType */
128
129 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
130 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
131 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
132 break;
133
134 case 3: /* DecodeType */
135
136 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
137 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
138 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
139 break;
140
141 case 4: /* Range Type */
142
143 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3);
144 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
145 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0, 2);
146 break;
147
148 case 5: /* Address Granularity */
149
150 Descriptor->Address32.Granularity =
151 (UINT32) InitializerOp->Asl.Value.Integer;
152 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
153 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
154 GranOp = InitializerOp;
155 break;
156
157 case 6: /* Address Min */
158
159 Descriptor->Address32.Minimum =
160 (UINT32) InitializerOp->Asl.Value.Integer;
161 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
162 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
163 MinOp = InitializerOp;
164 break;
165
166 case 7: /* Address Max */
167
168 Descriptor->Address32.Maximum =
169 (UINT32) InitializerOp->Asl.Value.Integer;
170 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
171 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
172 MaxOp = InitializerOp;
173 break;
174
175 case 8: /* Translation Offset */
176
177 Descriptor->Address32.TranslationOffset =
178 (UINT32) InitializerOp->Asl.Value.Integer;
179 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
180 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
181 break;
182
183 case 9: /* Address Length */
184
185 Descriptor->Address32.AddressLength =
186 (UINT32) InitializerOp->Asl.Value.Integer;
187 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
188 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
189 LengthOp = InitializerOp;
190 break;
191
192 case 10: /* ResSourceIndex [Optional Field - BYTE] */
193
194 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
195 {
196 /* Found a valid ResourceSourceIndex */
197
198 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
199 OptionIndex++;
200 Descriptor->Address32.ResourceLength++;
201 ResSourceIndex = TRUE;
202 }
203 break;
204
205 case 11: /* ResSource [Optional Field - STRING] */
206
207 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
208 (InitializerOp->Asl.Value.String))
209 {
210 if (StringLength)
211 {
212 /* Found a valid ResourceSource */
213
214 Descriptor->Address32.ResourceLength = (UINT16)
215 (Descriptor->Address32.ResourceLength + StringLength);
216
217 strcpy ((char *)
218 &OptionalFields[OptionIndex],
219 InitializerOp->Asl.Value.String);
220
221 /* ResourceSourceIndex must also be valid */
222
223 if (!ResSourceIndex)
224 {
225 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
226 InitializerOp, NULL);
227 }
228 }
229 }
230
231 #if 0
232 /*
233 * Not a valid ResourceSource, ResourceSourceIndex must also
234 * be invalid
235 */
236 else if (ResSourceIndex)
237 {
238 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
239 InitializerOp, NULL);
240 }
241 #endif
242 break;
243
244 case 12: /* ResourceTag */
245
246 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
247 break;
248
249 case 13: /* Type */
250
251 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0);
252 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
253 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4);
254 break;
255
256 case 14: /* Translation Type */
257
258 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
259 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
260 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
261 break;
262
263 default:
264
265 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
266 break;
267 }
268
269 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
270 }
271
272 /* Validate the Min/Max/Len/Gran values */
273
274 RsLargeAddressCheck (
275 (UINT64) Descriptor->Address32.Minimum,
276 (UINT64) Descriptor->Address32.Maximum,
277 (UINT64) Descriptor->Address32.AddressLength,
278 (UINT64) Descriptor->Address32.Granularity,
279 Descriptor->Address32.Flags,
280 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
281
282 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
283 OptionIndex + StringLength;
284 return (Rnode);
285 }
286
287
288 /*******************************************************************************
289 *
290 * FUNCTION: RsDoDwordMemoryDescriptor
291 *
292 * PARAMETERS: Info - Parse Op and resource template offset
293 *
294 * RETURN: Completed resource node
295 *
296 * DESCRIPTION: Construct a long "DwordMemory" descriptor
297 *
298 ******************************************************************************/
299
300 ASL_RESOURCE_NODE *
RsDoDwordMemoryDescriptor(ASL_RESOURCE_INFO * Info)301 RsDoDwordMemoryDescriptor (
302 ASL_RESOURCE_INFO *Info)
303 {
304 AML_RESOURCE *Descriptor;
305 ACPI_PARSE_OBJECT *InitializerOp;
306 ACPI_PARSE_OBJECT *MinOp = NULL;
307 ACPI_PARSE_OBJECT *MaxOp = NULL;
308 ACPI_PARSE_OBJECT *LengthOp = NULL;
309 ACPI_PARSE_OBJECT *GranOp = NULL;
310 ASL_RESOURCE_NODE *Rnode;
311 UINT8 *OptionalFields;
312 UINT16 StringLength = 0;
313 UINT32 OptionIndex = 0;
314 UINT32 CurrentByteOffset;
315 UINT32 i;
316 BOOLEAN ResSourceIndex = FALSE;
317
318
319 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
320 StringLength = RsGetStringDataLength (InitializerOp);
321 CurrentByteOffset = Info->CurrentByteOffset;
322
323 Rnode = RsAllocateResourceNode (
324 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
325
326 Descriptor = Rnode->Buffer;
327 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
328 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
329
330 /*
331 * Initial descriptor length -- may be enlarged if there are
332 * optional fields present
333 */
334 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
335 Descriptor->Address32.ResourceLength = (UINT16)
336 (sizeof (AML_RESOURCE_ADDRESS32) -
337 sizeof (AML_RESOURCE_LARGE_HEADER));
338
339
340 /* Process all child initialization nodes */
341
342 for (i = 0; InitializerOp; i++)
343 {
344 switch (i)
345 {
346 case 0: /* Resource Usage */
347
348 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
349 break;
350
351 case 1: /* DecodeType */
352
353 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
354 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
355 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
356 break;
357
358 case 2: /* MinType */
359
360 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
361 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
362 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
363 break;
364
365 case 3: /* MaxType */
366
367 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
368 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
369 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
370 break;
371
372 case 4: /* Memory Type */
373
374 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0);
375 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
376 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1, 2);
377 break;
378
379 case 5: /* Read/Write Type */
380
381 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1);
382 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
383 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0);
384 break;
385
386 case 6: /* Address Granularity */
387
388 Descriptor->Address32.Granularity =
389 (UINT32) InitializerOp->Asl.Value.Integer;
390 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
391 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
392 GranOp = InitializerOp;
393 break;
394
395 case 7: /* Min Address */
396
397 Descriptor->Address32.Minimum =
398 (UINT32) InitializerOp->Asl.Value.Integer;
399 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
400 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
401 MinOp = InitializerOp;
402 break;
403
404 case 8: /* Max Address */
405
406 Descriptor->Address32.Maximum =
407 (UINT32) InitializerOp->Asl.Value.Integer;
408 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
409 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
410 MaxOp = InitializerOp;
411 break;
412
413 case 9: /* Translation Offset */
414
415 Descriptor->Address32.TranslationOffset =
416 (UINT32) InitializerOp->Asl.Value.Integer;
417 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
418 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
419 break;
420
421 case 10: /* Address Length */
422
423 Descriptor->Address32.AddressLength =
424 (UINT32) InitializerOp->Asl.Value.Integer;
425 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
426 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
427 LengthOp = InitializerOp;
428 break;
429
430 case 11: /* ResSourceIndex [Optional Field - BYTE] */
431
432 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
433 {
434 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
435 OptionIndex++;
436 Descriptor->Address32.ResourceLength++;
437 ResSourceIndex = TRUE;
438 }
439 break;
440
441 case 12: /* ResSource [Optional Field - STRING] */
442
443 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
444 (InitializerOp->Asl.Value.String))
445 {
446 if (StringLength)
447 {
448 Descriptor->Address32.ResourceLength = (UINT16)
449 (Descriptor->Address32.ResourceLength + StringLength);
450
451 strcpy ((char *)
452 &OptionalFields[OptionIndex],
453 InitializerOp->Asl.Value.String);
454
455 /* ResourceSourceIndex must also be valid */
456
457 if (!ResSourceIndex)
458 {
459 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
460 InitializerOp, NULL);
461 }
462 }
463 }
464
465 #if 0
466 /*
467 * Not a valid ResourceSource, ResourceSourceIndex must also
468 * be invalid
469 */
470 else if (ResSourceIndex)
471 {
472 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
473 InitializerOp, NULL);
474 }
475 #endif
476 break;
477
478 case 13: /* ResourceTag */
479
480 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
481 break;
482
483
484 case 14: /* Address Range */
485
486 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0);
487 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
488 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3, 2);
489 break;
490
491 case 15: /* Type */
492
493 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0);
494 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
495 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5);
496 break;
497
498 default:
499
500 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
501 break;
502 }
503
504 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
505 }
506
507 /* Validate the Min/Max/Len/Gran values */
508
509 RsLargeAddressCheck (
510 (UINT64) Descriptor->Address32.Minimum,
511 (UINT64) Descriptor->Address32.Maximum,
512 (UINT64) Descriptor->Address32.AddressLength,
513 (UINT64) Descriptor->Address32.Granularity,
514 Descriptor->Address32.Flags,
515 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
516
517 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
518 OptionIndex + StringLength;
519 return (Rnode);
520 }
521
522
523 /*******************************************************************************
524 *
525 * FUNCTION: RsDoDwordSpaceDescriptor
526 *
527 * PARAMETERS: Info - Parse Op and resource template offset
528 *
529 * RETURN: Completed resource node
530 *
531 * DESCRIPTION: Construct a long "DwordSpace" descriptor
532 *
533 ******************************************************************************/
534
535 ASL_RESOURCE_NODE *
RsDoDwordSpaceDescriptor(ASL_RESOURCE_INFO * Info)536 RsDoDwordSpaceDescriptor (
537 ASL_RESOURCE_INFO *Info)
538 {
539 AML_RESOURCE *Descriptor;
540 ACPI_PARSE_OBJECT *InitializerOp;
541 ACPI_PARSE_OBJECT *MinOp = NULL;
542 ACPI_PARSE_OBJECT *MaxOp = NULL;
543 ACPI_PARSE_OBJECT *LengthOp = NULL;
544 ACPI_PARSE_OBJECT *GranOp = NULL;
545 ASL_RESOURCE_NODE *Rnode;
546 UINT8 *OptionalFields;
547 UINT16 StringLength = 0;
548 UINT32 OptionIndex = 0;
549 UINT32 CurrentByteOffset;
550 UINT32 i;
551 BOOLEAN ResSourceIndex = FALSE;
552
553
554 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
555 StringLength = RsGetStringDataLength (InitializerOp);
556 CurrentByteOffset = Info->CurrentByteOffset;
557
558 Rnode = RsAllocateResourceNode (
559 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength);
560
561 Descriptor = Rnode->Buffer;
562 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32;
563
564 /*
565 * Initial descriptor length -- may be enlarged if there are
566 * optional fields present
567 */
568 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32);
569 Descriptor->Address32.ResourceLength = (UINT16)
570 (sizeof (AML_RESOURCE_ADDRESS32) -
571 sizeof (AML_RESOURCE_LARGE_HEADER));
572
573 /* Process all child initialization nodes */
574
575 for (i = 0; InitializerOp; i++)
576 {
577 switch (i)
578 {
579 case 0: /* Resource Type */
580
581 Descriptor->Address32.ResourceType =
582 (UINT8) InitializerOp->Asl.Value.Integer;
583 break;
584
585 case 1: /* Resource Usage */
586
587 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1);
588 break;
589
590 case 2: /* DecodeType */
591
592 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0);
593 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
594 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1);
595 break;
596
597 case 3: /* MinType */
598
599 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0);
600 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
601 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2);
602 break;
603
604 case 4: /* MaxType */
605
606 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0);
607 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
608 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3);
609 break;
610
611 case 5: /* Type-Specific flags */
612
613 Descriptor->Address32.SpecificFlags =
614 (UINT8) InitializerOp->Asl.Value.Integer;
615 break;
616
617 case 6: /* Address Granularity */
618
619 Descriptor->Address32.Granularity =
620 (UINT32) InitializerOp->Asl.Value.Integer;
621 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
622 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity));
623 GranOp = InitializerOp;
624 break;
625
626 case 7: /* Min Address */
627
628 Descriptor->Address32.Minimum =
629 (UINT32) InitializerOp->Asl.Value.Integer;
630 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
631 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum));
632 MinOp = InitializerOp;
633 break;
634
635 case 8: /* Max Address */
636
637 Descriptor->Address32.Maximum =
638 (UINT32) InitializerOp->Asl.Value.Integer;
639 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
640 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum));
641 MaxOp = InitializerOp;
642 break;
643
644 case 9: /* Translation Offset */
645
646 Descriptor->Address32.TranslationOffset =
647 (UINT32) InitializerOp->Asl.Value.Integer;
648 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
649 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset));
650 break;
651
652 case 10: /* Address Length */
653
654 Descriptor->Address32.AddressLength =
655 (UINT32) InitializerOp->Asl.Value.Integer;
656 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
657 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength));
658 LengthOp = InitializerOp;
659 break;
660
661 case 11: /* ResSourceIndex [Optional Field - BYTE] */
662
663 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
664 {
665 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
666 OptionIndex++;
667 Descriptor->Address32.ResourceLength++;
668 ResSourceIndex = TRUE;
669 }
670 break;
671
672 case 12: /* ResSource [Optional Field - STRING] */
673
674 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
675 (InitializerOp->Asl.Value.String))
676 {
677 if (StringLength)
678 {
679 Descriptor->Address32.ResourceLength = (UINT16)
680 (Descriptor->Address32.ResourceLength + StringLength);
681
682 strcpy ((char *)
683 &OptionalFields[OptionIndex],
684 InitializerOp->Asl.Value.String);
685
686 /* ResourceSourceIndex must also be valid */
687
688 if (!ResSourceIndex)
689 {
690 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
691 InitializerOp, NULL);
692 }
693 }
694 }
695
696 #if 0
697 /*
698 * Not a valid ResourceSource, ResourceSourceIndex must also
699 * be invalid
700 */
701 else if (ResSourceIndex)
702 {
703 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
704 InitializerOp, NULL);
705 }
706 #endif
707 break;
708
709 case 13: /* ResourceTag */
710
711 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
712 break;
713
714 default:
715
716 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST,
717 InitializerOp, NULL);
718 break;
719 }
720
721 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
722 }
723
724 /* Validate the Min/Max/Len/Gran values */
725
726 RsLargeAddressCheck (
727 (UINT64) Descriptor->Address32.Minimum,
728 (UINT64) Descriptor->Address32.Maximum,
729 (UINT64) Descriptor->Address32.AddressLength,
730 (UINT64) Descriptor->Address32.Granularity,
731 Descriptor->Address32.Flags,
732 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
733
734 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) +
735 OptionIndex + StringLength;
736 return (Rnode);
737 }
738