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