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