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