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