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