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