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