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