1 /****************************************************************************** 2 * 3 * Module Name: aslrestype2d - Large DWord address resource descriptors 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2025, 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 MERCHANTABILITY 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 * DWordPcc 54 * DwordIO 55 * DwordMemory 56 * DwordSpace 57 */ 58 59 60 /******************************************************************************* 61 * 62 * FUNCTION: RsDoDwordPccDescriptor 63 * 64 * PARAMETERS: Info - Parse Op and resource template offset 65 * 66 * RETURN: Completed resource node 67 * 68 * DESCRIPTION: Construct a long "DWordPcc" descriptor 69 * 70 ******************************************************************************/ 71 72 ASL_RESOURCE_NODE * 73 RsDoDwordPccDescriptor ( 74 ASL_RESOURCE_INFO *Info) 75 { 76 AML_RESOURCE *Descriptor; 77 ACPI_PARSE_OBJECT *InitializerOp; 78 ACPI_PARSE_OBJECT *MinOp = NULL; 79 ACPI_PARSE_OBJECT *MaxOp = NULL; 80 ACPI_PARSE_OBJECT *LengthOp = NULL; 81 ACPI_PARSE_OBJECT *GranOp = NULL; 82 ASL_RESOURCE_NODE *Rnode; 83 UINT16 StringLength = 0; 84 UINT32 OptionIndex = 0; 85 UINT8 *OptionalFields; 86 UINT32 i; 87 BOOLEAN ResSourceIndex = FALSE; 88 89 90 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 91 StringLength = RsGetStringDataLength (InitializerOp); 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_PCC_NUMBER; 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 110 /* 111 * Bit [3] Max Address Fixed, _MAF: 1 (max address is fixed) 112 * Bit [2] Min Address Fixed,_MIF: 1 (min address is fixed) 113 * Bit [1] Decode Type, _DEC: 0 (do not care) 114 * BIT [0] Ignored (must be zero) 115 */ 116 Descriptor->Address32.Flags = 0b1100; 117 118 // No type specific flags. Set to 0. 119 Descriptor->Address32.SpecificFlags = 0; 120 121 // must be set to zero if _MAX == _MIN. 122 Descriptor->Address32.Granularity = 0x0; 123 /* Process all child initialization nodes */ 124 125 // No translation offset. 126 Descriptor->Address32.TranslationOffset = 0; 127 128 // Pcc is unique address. 129 Descriptor->Address32.AddressLength = 1; 130 131 for (i = 0; InitializerOp; i++) 132 { 133 switch (i) 134 { 135 136 case 0: /* Address Min = Max */ 137 138 Descriptor->Address32.Minimum = 139 (UINT32) InitializerOp->Asl.Value.Integer; 140 Descriptor->Address32.Maximum = 141 (UINT32) InitializerOp->Asl.Value.Integer; 142 143 break; 144 145 case 1: /* ResSourceIndex [Optional Field - BYTE] */ 146 147 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 148 { 149 /* Found a valid ResourceSourceIndex */ 150 151 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 152 OptionIndex++; 153 Descriptor->Address32.ResourceLength++; 154 ResSourceIndex = TRUE; 155 } 156 break; 157 158 case 2: /* ResSource [Optional Field - STRING] */ 159 160 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 161 (InitializerOp->Asl.Value.String)) 162 { 163 if (StringLength) 164 { 165 /* Found a valid ResourceSource */ 166 167 Descriptor->Address32.ResourceLength = (UINT16) 168 (Descriptor->Address32.ResourceLength + StringLength); 169 170 strcpy ((char *) 171 &OptionalFields[OptionIndex], 172 InitializerOp->Asl.Value.String); 173 174 /* ResourceSourceIndex must also be valid */ 175 176 if (!ResSourceIndex) 177 { 178 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 179 InitializerOp, NULL); 180 } 181 } 182 } 183 184 break; 185 186 case 3: // DescriptorName 187 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 188 break; 189 190 default: 191 192 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 193 break; 194 } 195 196 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 197 } 198 199 /* Validate the Min/Max/Len/Gran values */ 200 201 RsLargeAddressCheck ( 202 (UINT64) Descriptor->Address32.Minimum, 203 (UINT64) Descriptor->Address32.Maximum, 204 (UINT64) Descriptor->Address32.AddressLength, 205 (UINT64) Descriptor->Address32.Granularity, 206 Descriptor->Address32.Flags, 207 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 208 209 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 210 OptionIndex + StringLength; 211 return (Rnode); 212 } 213 214 215 /******************************************************************************* 216 * 217 * FUNCTION: RsDoDwordIoDescriptor 218 * 219 * PARAMETERS: Info - Parse Op and resource template offset 220 * 221 * RETURN: Completed resource node 222 * 223 * DESCRIPTION: Construct a long "DwordIO" descriptor 224 * 225 ******************************************************************************/ 226 227 ASL_RESOURCE_NODE * 228 RsDoDwordIoDescriptor ( 229 ASL_RESOURCE_INFO *Info) 230 { 231 AML_RESOURCE *Descriptor; 232 ACPI_PARSE_OBJECT *InitializerOp; 233 ACPI_PARSE_OBJECT *MinOp = NULL; 234 ACPI_PARSE_OBJECT *MaxOp = NULL; 235 ACPI_PARSE_OBJECT *LengthOp = NULL; 236 ACPI_PARSE_OBJECT *GranOp = NULL; 237 ASL_RESOURCE_NODE *Rnode; 238 UINT16 StringLength = 0; 239 UINT32 OptionIndex = 0; 240 UINT8 *OptionalFields; 241 UINT32 CurrentByteOffset; 242 UINT32 i; 243 BOOLEAN ResSourceIndex = FALSE; 244 245 246 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 247 StringLength = RsGetStringDataLength (InitializerOp); 248 CurrentByteOffset = Info->CurrentByteOffset; 249 250 Rnode = RsAllocateResourceNode ( 251 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 252 253 Descriptor = Rnode->Buffer; 254 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 255 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 256 257 /* 258 * Initial descriptor length -- may be enlarged if there are 259 * optional fields present 260 */ 261 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 262 Descriptor->Address32.ResourceLength = (UINT16) 263 (sizeof (AML_RESOURCE_ADDRESS32) - 264 sizeof (AML_RESOURCE_LARGE_HEADER)); 265 266 /* Process all child initialization nodes */ 267 268 for (i = 0; InitializerOp; i++) 269 { 270 switch (i) 271 { 272 case 0: /* Resource Usage */ 273 274 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 275 break; 276 277 case 1: /* MinType */ 278 279 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 280 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 281 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 282 break; 283 284 case 2: /* MaxType */ 285 286 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 287 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 288 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 289 break; 290 291 case 3: /* DecodeType */ 292 293 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 294 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 295 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 296 break; 297 298 case 4: /* Range Type */ 299 300 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3); 301 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 302 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0, 2); 303 break; 304 305 case 5: /* Address Granularity */ 306 307 Descriptor->Address32.Granularity = 308 (UINT32) InitializerOp->Asl.Value.Integer; 309 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 310 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 311 GranOp = InitializerOp; 312 break; 313 314 case 6: /* Address Min */ 315 316 Descriptor->Address32.Minimum = 317 (UINT32) InitializerOp->Asl.Value.Integer; 318 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 319 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 320 MinOp = InitializerOp; 321 break; 322 323 case 7: /* Address Max */ 324 325 Descriptor->Address32.Maximum = 326 (UINT32) InitializerOp->Asl.Value.Integer; 327 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 328 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 329 MaxOp = InitializerOp; 330 break; 331 332 case 8: /* Translation Offset */ 333 334 Descriptor->Address32.TranslationOffset = 335 (UINT32) InitializerOp->Asl.Value.Integer; 336 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 337 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 338 break; 339 340 case 9: /* Address Length */ 341 342 Descriptor->Address32.AddressLength = 343 (UINT32) InitializerOp->Asl.Value.Integer; 344 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 345 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 346 LengthOp = InitializerOp; 347 break; 348 349 case 10: /* ResSourceIndex [Optional Field - BYTE] */ 350 351 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 352 { 353 /* Found a valid ResourceSourceIndex */ 354 355 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 356 OptionIndex++; 357 Descriptor->Address32.ResourceLength++; 358 ResSourceIndex = TRUE; 359 } 360 break; 361 362 case 11: /* ResSource [Optional Field - STRING] */ 363 364 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 365 (InitializerOp->Asl.Value.String)) 366 { 367 if (StringLength) 368 { 369 /* Found a valid ResourceSource */ 370 371 Descriptor->Address32.ResourceLength = (UINT16) 372 (Descriptor->Address32.ResourceLength + StringLength); 373 374 strcpy ((char *) 375 &OptionalFields[OptionIndex], 376 InitializerOp->Asl.Value.String); 377 378 /* ResourceSourceIndex must also be valid */ 379 380 if (!ResSourceIndex) 381 { 382 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 383 InitializerOp, NULL); 384 } 385 } 386 } 387 388 #if 0 389 /* 390 * Not a valid ResourceSource, ResourceSourceIndex must also 391 * be invalid 392 */ 393 else if (ResSourceIndex) 394 { 395 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 396 InitializerOp, NULL); 397 } 398 #endif 399 break; 400 401 case 12: /* ResourceTag */ 402 403 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 404 break; 405 406 case 13: /* Type */ 407 408 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0); 409 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 410 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4); 411 break; 412 413 case 14: /* Translation Type */ 414 415 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 416 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 417 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 418 break; 419 420 default: 421 422 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 423 break; 424 } 425 426 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 427 } 428 429 /* Validate the Min/Max/Len/Gran values */ 430 431 RsLargeAddressCheck ( 432 (UINT64) Descriptor->Address32.Minimum, 433 (UINT64) Descriptor->Address32.Maximum, 434 (UINT64) Descriptor->Address32.AddressLength, 435 (UINT64) Descriptor->Address32.Granularity, 436 Descriptor->Address32.Flags, 437 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 438 439 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 440 OptionIndex + StringLength; 441 return (Rnode); 442 } 443 444 445 /******************************************************************************* 446 * 447 * FUNCTION: RsDoDwordMemoryDescriptor 448 * 449 * PARAMETERS: Info - Parse Op and resource template offset 450 * 451 * RETURN: Completed resource node 452 * 453 * DESCRIPTION: Construct a long "DwordMemory" descriptor 454 * 455 ******************************************************************************/ 456 457 ASL_RESOURCE_NODE * 458 RsDoDwordMemoryDescriptor ( 459 ASL_RESOURCE_INFO *Info) 460 { 461 AML_RESOURCE *Descriptor; 462 ACPI_PARSE_OBJECT *InitializerOp; 463 ACPI_PARSE_OBJECT *MinOp = NULL; 464 ACPI_PARSE_OBJECT *MaxOp = NULL; 465 ACPI_PARSE_OBJECT *LengthOp = NULL; 466 ACPI_PARSE_OBJECT *GranOp = NULL; 467 ASL_RESOURCE_NODE *Rnode; 468 UINT8 *OptionalFields; 469 UINT16 StringLength = 0; 470 UINT32 OptionIndex = 0; 471 UINT32 CurrentByteOffset; 472 UINT32 i; 473 BOOLEAN ResSourceIndex = FALSE; 474 475 476 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 477 StringLength = RsGetStringDataLength (InitializerOp); 478 CurrentByteOffset = Info->CurrentByteOffset; 479 480 Rnode = RsAllocateResourceNode ( 481 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 482 483 Descriptor = Rnode->Buffer; 484 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 485 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 486 487 /* 488 * Initial descriptor length -- may be enlarged if there are 489 * optional fields present 490 */ 491 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 492 Descriptor->Address32.ResourceLength = (UINT16) 493 (sizeof (AML_RESOURCE_ADDRESS32) - 494 sizeof (AML_RESOURCE_LARGE_HEADER)); 495 496 497 /* Process all child initialization nodes */ 498 499 for (i = 0; InitializerOp; i++) 500 { 501 switch (i) 502 { 503 case 0: /* Resource Usage */ 504 505 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 506 break; 507 508 case 1: /* DecodeType */ 509 510 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 511 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 512 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 513 break; 514 515 case 2: /* MinType */ 516 517 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 518 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 519 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 520 break; 521 522 case 3: /* MaxType */ 523 524 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 525 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 526 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 527 break; 528 529 case 4: /* Memory Type */ 530 531 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0); 532 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 533 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1, 2); 534 break; 535 536 case 5: /* Read/Write Type */ 537 538 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1); 539 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 540 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0); 541 break; 542 543 case 6: /* Address Granularity */ 544 545 Descriptor->Address32.Granularity = 546 (UINT32) InitializerOp->Asl.Value.Integer; 547 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 548 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 549 GranOp = InitializerOp; 550 break; 551 552 case 7: /* Min Address */ 553 554 Descriptor->Address32.Minimum = 555 (UINT32) InitializerOp->Asl.Value.Integer; 556 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 557 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 558 MinOp = InitializerOp; 559 break; 560 561 case 8: /* Max Address */ 562 563 Descriptor->Address32.Maximum = 564 (UINT32) InitializerOp->Asl.Value.Integer; 565 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 566 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 567 MaxOp = InitializerOp; 568 break; 569 570 case 9: /* Translation Offset */ 571 572 Descriptor->Address32.TranslationOffset = 573 (UINT32) InitializerOp->Asl.Value.Integer; 574 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 575 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 576 break; 577 578 case 10: /* Address Length */ 579 580 Descriptor->Address32.AddressLength = 581 (UINT32) InitializerOp->Asl.Value.Integer; 582 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 583 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 584 LengthOp = InitializerOp; 585 break; 586 587 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 588 589 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 590 { 591 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 592 OptionIndex++; 593 Descriptor->Address32.ResourceLength++; 594 ResSourceIndex = TRUE; 595 } 596 break; 597 598 case 12: /* ResSource [Optional Field - STRING] */ 599 600 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 601 (InitializerOp->Asl.Value.String)) 602 { 603 if (StringLength) 604 { 605 Descriptor->Address32.ResourceLength = (UINT16) 606 (Descriptor->Address32.ResourceLength + StringLength); 607 608 strcpy ((char *) 609 &OptionalFields[OptionIndex], 610 InitializerOp->Asl.Value.String); 611 612 /* ResourceSourceIndex must also be valid */ 613 614 if (!ResSourceIndex) 615 { 616 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 617 InitializerOp, NULL); 618 } 619 } 620 } 621 622 #if 0 623 /* 624 * Not a valid ResourceSource, ResourceSourceIndex must also 625 * be invalid 626 */ 627 else if (ResSourceIndex) 628 { 629 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 630 InitializerOp, NULL); 631 } 632 #endif 633 break; 634 635 case 13: /* ResourceTag */ 636 637 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 638 break; 639 640 641 case 14: /* Address Range */ 642 643 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0); 644 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 645 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3, 2); 646 break; 647 648 case 15: /* Type */ 649 650 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 651 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 652 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 653 break; 654 655 default: 656 657 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 658 break; 659 } 660 661 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 662 } 663 664 /* Validate the Min/Max/Len/Gran values */ 665 666 RsLargeAddressCheck ( 667 (UINT64) Descriptor->Address32.Minimum, 668 (UINT64) Descriptor->Address32.Maximum, 669 (UINT64) Descriptor->Address32.AddressLength, 670 (UINT64) Descriptor->Address32.Granularity, 671 Descriptor->Address32.Flags, 672 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 673 674 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 675 OptionIndex + StringLength; 676 return (Rnode); 677 } 678 679 680 /******************************************************************************* 681 * 682 * FUNCTION: RsDoDwordSpaceDescriptor 683 * 684 * PARAMETERS: Info - Parse Op and resource template offset 685 * 686 * RETURN: Completed resource node 687 * 688 * DESCRIPTION: Construct a long "DwordSpace" descriptor 689 * 690 ******************************************************************************/ 691 692 ASL_RESOURCE_NODE * 693 RsDoDwordSpaceDescriptor ( 694 ASL_RESOURCE_INFO *Info) 695 { 696 AML_RESOURCE *Descriptor; 697 ACPI_PARSE_OBJECT *InitializerOp; 698 ACPI_PARSE_OBJECT *MinOp = NULL; 699 ACPI_PARSE_OBJECT *MaxOp = NULL; 700 ACPI_PARSE_OBJECT *LengthOp = NULL; 701 ACPI_PARSE_OBJECT *GranOp = NULL; 702 ASL_RESOURCE_NODE *Rnode; 703 UINT8 *OptionalFields; 704 UINT16 StringLength = 0; 705 UINT32 OptionIndex = 0; 706 UINT32 CurrentByteOffset; 707 UINT32 i; 708 BOOLEAN ResSourceIndex = FALSE; 709 710 711 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 712 StringLength = RsGetStringDataLength (InitializerOp); 713 CurrentByteOffset = Info->CurrentByteOffset; 714 715 Rnode = RsAllocateResourceNode ( 716 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 717 718 Descriptor = Rnode->Buffer; 719 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 720 721 /* 722 * Initial descriptor length -- may be enlarged if there are 723 * optional fields present 724 */ 725 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 726 Descriptor->Address32.ResourceLength = (UINT16) 727 (sizeof (AML_RESOURCE_ADDRESS32) - 728 sizeof (AML_RESOURCE_LARGE_HEADER)); 729 730 /* Process all child initialization nodes */ 731 732 for (i = 0; InitializerOp; i++) 733 { 734 switch (i) 735 { 736 case 0: /* Resource Type */ 737 738 Descriptor->Address32.ResourceType = 739 (UINT8) InitializerOp->Asl.Value.Integer; 740 break; 741 742 case 1: /* Resource Usage */ 743 744 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 745 break; 746 747 case 2: /* DecodeType */ 748 749 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 750 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 751 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 752 break; 753 754 case 3: /* MinType */ 755 756 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 757 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 758 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 759 break; 760 761 case 4: /* MaxType */ 762 763 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 764 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 765 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 766 break; 767 768 case 5: /* Type-Specific flags */ 769 770 Descriptor->Address32.SpecificFlags = 771 (UINT8) InitializerOp->Asl.Value.Integer; 772 break; 773 774 case 6: /* Address Granularity */ 775 776 Descriptor->Address32.Granularity = 777 (UINT32) InitializerOp->Asl.Value.Integer; 778 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 779 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 780 GranOp = InitializerOp; 781 break; 782 783 case 7: /* Min Address */ 784 785 Descriptor->Address32.Minimum = 786 (UINT32) InitializerOp->Asl.Value.Integer; 787 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 788 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 789 MinOp = InitializerOp; 790 break; 791 792 case 8: /* Max Address */ 793 794 Descriptor->Address32.Maximum = 795 (UINT32) InitializerOp->Asl.Value.Integer; 796 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 797 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 798 MaxOp = InitializerOp; 799 break; 800 801 case 9: /* Translation Offset */ 802 803 Descriptor->Address32.TranslationOffset = 804 (UINT32) InitializerOp->Asl.Value.Integer; 805 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 806 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 807 break; 808 809 case 10: /* Address Length */ 810 811 Descriptor->Address32.AddressLength = 812 (UINT32) InitializerOp->Asl.Value.Integer; 813 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 814 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 815 LengthOp = InitializerOp; 816 break; 817 818 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 819 820 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 821 { 822 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 823 OptionIndex++; 824 Descriptor->Address32.ResourceLength++; 825 ResSourceIndex = TRUE; 826 } 827 break; 828 829 case 12: /* ResSource [Optional Field - STRING] */ 830 831 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 832 (InitializerOp->Asl.Value.String)) 833 { 834 if (StringLength) 835 { 836 Descriptor->Address32.ResourceLength = (UINT16) 837 (Descriptor->Address32.ResourceLength + StringLength); 838 839 strcpy ((char *) 840 &OptionalFields[OptionIndex], 841 InitializerOp->Asl.Value.String); 842 843 /* ResourceSourceIndex must also be valid */ 844 845 if (!ResSourceIndex) 846 { 847 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 848 InitializerOp, NULL); 849 } 850 } 851 } 852 853 #if 0 854 /* 855 * Not a valid ResourceSource, ResourceSourceIndex must also 856 * be invalid 857 */ 858 else if (ResSourceIndex) 859 { 860 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 861 InitializerOp, NULL); 862 } 863 #endif 864 break; 865 866 case 13: /* ResourceTag */ 867 868 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 869 break; 870 871 default: 872 873 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, 874 InitializerOp, NULL); 875 break; 876 } 877 878 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 879 } 880 881 /* Validate the Min/Max/Len/Gran values */ 882 883 RsLargeAddressCheck ( 884 (UINT64) Descriptor->Address32.Minimum, 885 (UINT64) Descriptor->Address32.Maximum, 886 (UINT64) Descriptor->Address32.AddressLength, 887 (UINT64) Descriptor->Address32.Granularity, 888 Descriptor->Address32.Flags, 889 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 890 891 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 892 OptionIndex + StringLength; 893 return (Rnode); 894 } 895
Indexes created Mon Feb 23 01:20:22 UTC 2026