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