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