1 /****************************************************************************** 2 * 3 * Module Name: aslrestype2w - Large Word 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 #include "aslcompiler.h" 45 #include "aslcompiler.y.h" 46 47 #define _COMPONENT ACPI_COMPILER 48 ACPI_MODULE_NAME ("aslrestype2w") 49 50 /* 51 * This module contains the Word (16-bit) address space descriptors: 52 * 53 * WordIO 54 * WordMemory 55 * WordSpace 56 */ 57 58 /******************************************************************************* 59 * 60 * FUNCTION: RsDoWordIoDescriptor 61 * 62 * PARAMETERS: Op - Parent resource descriptor parse node 63 * CurrentByteOffset - Offset into the resource template AML 64 * buffer (to track references to the desc) 65 * 66 * RETURN: Completed resource node 67 * 68 * DESCRIPTION: Construct a long "WordIO" descriptor 69 * 70 ******************************************************************************/ 71 72 ASL_RESOURCE_NODE * 73 RsDoWordIoDescriptor ( 74 ACPI_PARSE_OBJECT *Op, 75 UINT32 CurrentByteOffset) 76 { 77 AML_RESOURCE *Descriptor; 78 ACPI_PARSE_OBJECT *InitializerOp; 79 ACPI_PARSE_OBJECT *MinOp = NULL; 80 ACPI_PARSE_OBJECT *MaxOp = NULL; 81 ACPI_PARSE_OBJECT *LengthOp = NULL; 82 ACPI_PARSE_OBJECT *GranOp = NULL; 83 ASL_RESOURCE_NODE *Rnode; 84 UINT8 *OptionalFields; 85 UINT16 StringLength = 0; 86 UINT32 OptionIndex = 0; 87 UINT32 i; 88 BOOLEAN ResSourceIndex = FALSE; 89 90 91 InitializerOp = Op->Asl.Child; 92 StringLength = RsGetStringDataLength (InitializerOp); 93 94 Rnode = RsAllocateResourceNode ( 95 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 96 97 Descriptor = Rnode->Buffer; 98 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 99 Descriptor->Address16.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_ADDRESS16); 106 Descriptor->Address16.ResourceLength = (UINT16) 107 (sizeof (AML_RESOURCE_ADDRESS16) - 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->Address16.Flags, InitializerOp, 0, 1); 119 break; 120 121 case 1: /* MinType */ 122 123 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 124 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 125 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 126 break; 127 128 case 2: /* MaxType */ 129 130 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 131 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 132 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 133 break; 134 135 case 3: /* DecodeType */ 136 137 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 138 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 139 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 140 break; 141 142 case 4: /* Range Type */ 143 144 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3); 145 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 146 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0, 2); 147 break; 148 149 case 5: /* Address Granularity */ 150 151 Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer; 152 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 153 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 154 GranOp = InitializerOp; 155 break; 156 157 case 6: /* Address Min */ 158 159 Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer; 160 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, 161 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 162 MinOp = InitializerOp; 163 break; 164 165 case 7: /* Address Max */ 166 167 Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer; 168 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, 169 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 170 MaxOp = InitializerOp; 171 break; 172 173 case 8: /* Translation Offset */ 174 175 Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; 176 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 177 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 178 break; 179 180 case 9: /* Address Length */ 181 182 Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; 183 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, 184 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.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->Address16.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->Address16.ResourceLength = (UINT16) 207 (Descriptor->Address16.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 (Op, InitializerOp); 239 break; 240 241 case 13: /* Type */ 242 243 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0); 244 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 245 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4); 246 break; 247 248 case 14: /* Translation Type */ 249 250 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0); 251 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 252 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.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 (UINT64) Descriptor->Address16.Minimum, 268 (UINT64) Descriptor->Address16.Maximum, 269 (UINT64) Descriptor->Address16.AddressLength, 270 (UINT64) Descriptor->Address16.Granularity, 271 Descriptor->Address16.Flags, 272 MinOp, MaxOp, LengthOp, GranOp, Op); 273 274 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 275 OptionIndex + StringLength; 276 return (Rnode); 277 } 278 279 280 /******************************************************************************* 281 * 282 * FUNCTION: RsDoWordBusNumberDescriptor 283 * 284 * PARAMETERS: Op - Parent resource descriptor parse node 285 * CurrentByteOffset - Offset into the resource template AML 286 * buffer (to track references to the desc) 287 * 288 * RETURN: Completed resource node 289 * 290 * DESCRIPTION: Construct a long "WordBusNumber" descriptor 291 * 292 ******************************************************************************/ 293 294 ASL_RESOURCE_NODE * 295 RsDoWordBusNumberDescriptor ( 296 ACPI_PARSE_OBJECT *Op, 297 UINT32 CurrentByteOffset) 298 { 299 AML_RESOURCE *Descriptor; 300 ACPI_PARSE_OBJECT *InitializerOp; 301 ACPI_PARSE_OBJECT *MinOp = NULL; 302 ACPI_PARSE_OBJECT *MaxOp = NULL; 303 ACPI_PARSE_OBJECT *LengthOp = NULL; 304 ACPI_PARSE_OBJECT *GranOp = NULL; 305 ASL_RESOURCE_NODE *Rnode; 306 UINT8 *OptionalFields; 307 UINT16 StringLength = 0; 308 UINT32 OptionIndex = 0; 309 UINT32 i; 310 BOOLEAN ResSourceIndex = FALSE; 311 312 313 InitializerOp = Op->Asl.Child; 314 StringLength = RsGetStringDataLength (InitializerOp); 315 316 Rnode = RsAllocateResourceNode ( 317 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 318 319 Descriptor = Rnode->Buffer; 320 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 321 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE; 322 323 /* 324 * Initial descriptor length -- may be enlarged if there are 325 * optional fields present 326 */ 327 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); 328 Descriptor->Address16.ResourceLength = (UINT16) 329 (sizeof (AML_RESOURCE_ADDRESS16) - 330 sizeof (AML_RESOURCE_LARGE_HEADER)); 331 332 /* Process all child initialization nodes */ 333 334 for (i = 0; InitializerOp; i++) 335 { 336 switch (i) 337 { 338 case 0: /* Resource Usage */ 339 340 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1); 341 break; 342 343 case 1: /* MinType */ 344 345 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 346 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 347 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 348 break; 349 350 case 2: /* MaxType */ 351 352 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 353 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 354 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 355 break; 356 357 case 3: /* DecodeType */ 358 359 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 360 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 361 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 362 break; 363 364 case 4: /* Address Granularity */ 365 366 Descriptor->Address16.Granularity = 367 (UINT16) InitializerOp->Asl.Value.Integer; 368 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 369 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 370 GranOp = InitializerOp; 371 break; 372 373 case 5: /* Min Address */ 374 375 Descriptor->Address16.Minimum = 376 (UINT16) InitializerOp->Asl.Value.Integer; 377 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, 378 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 379 MinOp = InitializerOp; 380 break; 381 382 case 6: /* Max Address */ 383 384 Descriptor->Address16.Maximum = 385 (UINT16) InitializerOp->Asl.Value.Integer; 386 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, 387 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 388 MaxOp = InitializerOp; 389 break; 390 391 case 7: /* Translation Offset */ 392 393 Descriptor->Address16.TranslationOffset = 394 (UINT16) InitializerOp->Asl.Value.Integer; 395 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 396 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 397 break; 398 399 case 8: /* Address Length */ 400 401 Descriptor->Address16.AddressLength = 402 (UINT16) InitializerOp->Asl.Value.Integer; 403 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, 404 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); 405 LengthOp = InitializerOp; 406 break; 407 408 case 9: /* ResSourceIndex [Optional Field - BYTE] */ 409 410 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 411 { 412 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 413 OptionIndex++; 414 Descriptor->Address16.ResourceLength++; 415 ResSourceIndex = TRUE; 416 } 417 break; 418 419 case 10: /* ResSource [Optional Field - STRING] */ 420 421 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 422 (InitializerOp->Asl.Value.String)) 423 { 424 if (StringLength) 425 { 426 Descriptor->Address16.ResourceLength = (UINT16) 427 (Descriptor->Address16.ResourceLength + StringLength); 428 429 strcpy ((char *) 430 &OptionalFields[OptionIndex], 431 InitializerOp->Asl.Value.String); 432 433 /* ResourceSourceIndex must also be valid */ 434 435 if (!ResSourceIndex) 436 { 437 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 438 InitializerOp, NULL); 439 } 440 } 441 } 442 443 #if 0 444 /* 445 * Not a valid ResourceSource, ResourceSourceIndex must also 446 * be invalid 447 */ 448 else if (ResSourceIndex) 449 { 450 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 451 InitializerOp, NULL); 452 } 453 #endif 454 break; 455 456 case 11: /* ResourceTag */ 457 458 UtAttachNamepathToOwner (Op, InitializerOp); 459 break; 460 461 default: 462 463 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 464 break; 465 } 466 467 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 468 } 469 470 /* Validate the Min/Max/Len/Gran values */ 471 472 RsLargeAddressCheck ( 473 (UINT64) Descriptor->Address16.Minimum, 474 (UINT64) Descriptor->Address16.Maximum, 475 (UINT64) Descriptor->Address16.AddressLength, 476 (UINT64) Descriptor->Address16.Granularity, 477 Descriptor->Address16.Flags, 478 MinOp, MaxOp, LengthOp, GranOp, Op); 479 480 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 481 OptionIndex + StringLength; 482 return (Rnode); 483 } 484 485 486 /******************************************************************************* 487 * 488 * FUNCTION: RsDoWordSpaceDescriptor 489 * 490 * PARAMETERS: Op - Parent resource descriptor parse node 491 * CurrentByteOffset - Offset into the resource template AML 492 * buffer (to track references to the desc) 493 * 494 * RETURN: Completed resource node 495 * 496 * DESCRIPTION: Construct a long "WordSpace" descriptor 497 * 498 ******************************************************************************/ 499 500 ASL_RESOURCE_NODE * 501 RsDoWordSpaceDescriptor ( 502 ACPI_PARSE_OBJECT *Op, 503 UINT32 CurrentByteOffset) 504 { 505 AML_RESOURCE *Descriptor; 506 ACPI_PARSE_OBJECT *InitializerOp; 507 ACPI_PARSE_OBJECT *MinOp = NULL; 508 ACPI_PARSE_OBJECT *MaxOp = NULL; 509 ACPI_PARSE_OBJECT *LengthOp = NULL; 510 ACPI_PARSE_OBJECT *GranOp = NULL; 511 ASL_RESOURCE_NODE *Rnode; 512 UINT8 *OptionalFields; 513 UINT16 StringLength = 0; 514 UINT32 OptionIndex = 0; 515 UINT32 i; 516 BOOLEAN ResSourceIndex = FALSE; 517 518 519 InitializerOp = Op->Asl.Child; 520 StringLength = RsGetStringDataLength (InitializerOp); 521 522 Rnode = RsAllocateResourceNode ( 523 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 524 525 Descriptor = Rnode->Buffer; 526 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 527 528 /* 529 * Initial descriptor length -- may be enlarged if there are 530 * optional fields present 531 */ 532 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); 533 Descriptor->Address16.ResourceLength = (UINT16) 534 (sizeof (AML_RESOURCE_ADDRESS16) - 535 sizeof (AML_RESOURCE_LARGE_HEADER)); 536 537 /* Process all child initialization nodes */ 538 539 for (i = 0; InitializerOp; i++) 540 { 541 switch (i) 542 { 543 case 0: /* Resource Type */ 544 545 Descriptor->Address16.ResourceType = 546 (UINT8) InitializerOp->Asl.Value.Integer; 547 break; 548 549 case 1: /* Resource Usage */ 550 551 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1); 552 break; 553 554 case 2: /* DecodeType */ 555 556 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 557 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 558 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 559 break; 560 561 case 3: /* MinType */ 562 563 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 564 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 565 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 566 break; 567 568 case 4: /* MaxType */ 569 570 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 571 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 572 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 573 break; 574 575 case 5: /* Type-Specific flags */ 576 577 Descriptor->Address16.SpecificFlags = 578 (UINT8) InitializerOp->Asl.Value.Integer; 579 break; 580 581 case 6: /* Address Granularity */ 582 583 Descriptor->Address16.Granularity = 584 (UINT16) InitializerOp->Asl.Value.Integer; 585 RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 586 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 587 GranOp = InitializerOp; 588 break; 589 590 case 7: /* Min Address */ 591 592 Descriptor->Address16.Minimum = 593 (UINT16) InitializerOp->Asl.Value.Integer; 594 RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, 595 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 596 MinOp = InitializerOp; 597 break; 598 599 case 8: /* Max Address */ 600 601 Descriptor->Address16.Maximum = 602 (UINT16) InitializerOp->Asl.Value.Integer; 603 RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, 604 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 605 MaxOp = InitializerOp; 606 break; 607 608 case 9: /* Translation Offset */ 609 610 Descriptor->Address16.TranslationOffset = 611 (UINT16) InitializerOp->Asl.Value.Integer; 612 RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 613 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 614 break; 615 616 case 10: /* Address Length */ 617 618 Descriptor->Address16.AddressLength = 619 (UINT16) InitializerOp->Asl.Value.Integer; 620 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, 621 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); 622 LengthOp = InitializerOp; 623 break; 624 625 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 626 627 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 628 { 629 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 630 OptionIndex++; 631 Descriptor->Address16.ResourceLength++; 632 ResSourceIndex = TRUE; 633 } 634 break; 635 636 case 12: /* ResSource [Optional Field - STRING] */ 637 638 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 639 (InitializerOp->Asl.Value.String)) 640 { 641 if (StringLength) 642 { 643 Descriptor->Address16.ResourceLength = (UINT16) 644 (Descriptor->Address16.ResourceLength + StringLength); 645 646 strcpy ((char *) 647 &OptionalFields[OptionIndex], 648 InitializerOp->Asl.Value.String); 649 650 /* ResourceSourceIndex must also be valid */ 651 652 if (!ResSourceIndex) 653 { 654 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 655 InitializerOp, NULL); 656 } 657 } 658 } 659 660 #if 0 661 /* 662 * Not a valid ResourceSource, ResourceSourceIndex must also 663 * be invalid 664 */ 665 else if (ResSourceIndex) 666 { 667 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 668 InitializerOp, NULL); 669 } 670 #endif 671 break; 672 673 case 13: /* ResourceTag */ 674 675 UtAttachNamepathToOwner (Op, InitializerOp); 676 break; 677 678 default: 679 680 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 681 break; 682 } 683 684 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 685 } 686 687 /* Validate the Min/Max/Len/Gran values */ 688 689 RsLargeAddressCheck ( 690 (UINT64) Descriptor->Address16.Minimum, 691 (UINT64) Descriptor->Address16.Maximum, 692 (UINT64) Descriptor->Address16.AddressLength, 693 (UINT64) Descriptor->Address16.Granularity, 694 Descriptor->Address16.Flags, 695 MinOp, MaxOp, LengthOp, GranOp, Op); 696 697 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 698 OptionIndex + StringLength; 699 return (Rnode); 700 } 701