aslrestype2d.c revision 306536
1/****************************************************************************** 2 * 3 * Module Name: aslrestype2d - Large DWord 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 ("aslrestype2d") 49 50/* 51 * This module contains the Dword (32-bit) address space descriptors: 52 * 53 * DwordIO 54 * DwordMemory 55 * DwordSpace 56 */ 57 58/******************************************************************************* 59 * 60 * FUNCTION: RsDoDwordIoDescriptor 61 * 62 * PARAMETERS: Info - Parse Op and resource template offset 63 * 64 * RETURN: Completed resource node 65 * 66 * DESCRIPTION: Construct a long "DwordIO" descriptor 67 * 68 ******************************************************************************/ 69 70ASL_RESOURCE_NODE * 71RsDoDwordIoDescriptor ( 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 UINT16 StringLength = 0; 82 UINT32 OptionIndex = 0; 83 UINT8 *OptionalFields; 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_ADDRESS32) + 1 + StringLength); 95 96 Descriptor = Rnode->Buffer; 97 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 98 Descriptor->Address32.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_ADDRESS32); 105 Descriptor->Address32.ResourceLength = (UINT16) 106 (sizeof (AML_RESOURCE_ADDRESS32) - 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->Address32.Flags, InitializerOp, 0, 1); 118 break; 119 120 case 1: /* MinType */ 121 122 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 123 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 124 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 125 break; 126 127 case 2: /* MaxType */ 128 129 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 130 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 131 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 132 break; 133 134 case 3: /* DecodeType */ 135 136 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 137 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 138 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 139 break; 140 141 case 4: /* Range Type */ 142 143 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3); 144 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 145 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0, 2); 146 break; 147 148 case 5: /* Address Granularity */ 149 150 Descriptor->Address32.Granularity = 151 (UINT32) InitializerOp->Asl.Value.Integer; 152 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 153 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 154 GranOp = InitializerOp; 155 break; 156 157 case 6: /* Address Min */ 158 159 Descriptor->Address32.Minimum = 160 (UINT32) InitializerOp->Asl.Value.Integer; 161 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 162 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 163 MinOp = InitializerOp; 164 break; 165 166 case 7: /* Address Max */ 167 168 Descriptor->Address32.Maximum = 169 (UINT32) InitializerOp->Asl.Value.Integer; 170 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 171 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 172 MaxOp = InitializerOp; 173 break; 174 175 case 8: /* Translation Offset */ 176 177 Descriptor->Address32.TranslationOffset = 178 (UINT32) InitializerOp->Asl.Value.Integer; 179 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 180 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 181 break; 182 183 case 9: /* Address Length */ 184 185 Descriptor->Address32.AddressLength = 186 (UINT32) InitializerOp->Asl.Value.Integer; 187 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 188 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 189 LengthOp = InitializerOp; 190 break; 191 192 case 10: /* ResSourceIndex [Optional Field - BYTE] */ 193 194 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 195 { 196 /* Found a valid ResourceSourceIndex */ 197 198 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 199 OptionIndex++; 200 Descriptor->Address32.ResourceLength++; 201 ResSourceIndex = TRUE; 202 } 203 break; 204 205 case 11: /* ResSource [Optional Field - STRING] */ 206 207 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 208 (InitializerOp->Asl.Value.String)) 209 { 210 if (StringLength) 211 { 212 /* Found a valid ResourceSource */ 213 214 Descriptor->Address32.ResourceLength = (UINT16) 215 (Descriptor->Address32.ResourceLength + StringLength); 216 217 strcpy ((char *) 218 &OptionalFields[OptionIndex], 219 InitializerOp->Asl.Value.String); 220 221 /* ResourceSourceIndex must also be valid */ 222 223 if (!ResSourceIndex) 224 { 225 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 226 InitializerOp, NULL); 227 } 228 } 229 } 230 231#if 0 232 /* 233 * Not a valid ResourceSource, ResourceSourceIndex must also 234 * be invalid 235 */ 236 else if (ResSourceIndex) 237 { 238 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 239 InitializerOp, NULL); 240 } 241#endif 242 break; 243 244 case 12: /* ResourceTag */ 245 246 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 247 break; 248 249 case 13: /* Type */ 250 251 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0); 252 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 253 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4); 254 break; 255 256 case 14: /* Translation Type */ 257 258 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 259 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 260 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 261 break; 262 263 default: 264 265 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 266 break; 267 } 268 269 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 270 } 271 272 /* Validate the Min/Max/Len/Gran values */ 273 274 RsLargeAddressCheck ( 275 (UINT64) Descriptor->Address32.Minimum, 276 (UINT64) Descriptor->Address32.Maximum, 277 (UINT64) Descriptor->Address32.AddressLength, 278 (UINT64) Descriptor->Address32.Granularity, 279 Descriptor->Address32.Flags, 280 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 281 282 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 283 OptionIndex + StringLength; 284 return (Rnode); 285} 286 287 288/******************************************************************************* 289 * 290 * FUNCTION: RsDoDwordMemoryDescriptor 291 * 292 * PARAMETERS: Info - Parse Op and resource template offset 293 * 294 * RETURN: Completed resource node 295 * 296 * DESCRIPTION: Construct a long "DwordMemory" descriptor 297 * 298 ******************************************************************************/ 299 300ASL_RESOURCE_NODE * 301RsDoDwordMemoryDescriptor ( 302 ASL_RESOURCE_INFO *Info) 303{ 304 AML_RESOURCE *Descriptor; 305 ACPI_PARSE_OBJECT *InitializerOp; 306 ACPI_PARSE_OBJECT *MinOp = NULL; 307 ACPI_PARSE_OBJECT *MaxOp = NULL; 308 ACPI_PARSE_OBJECT *LengthOp = NULL; 309 ACPI_PARSE_OBJECT *GranOp = NULL; 310 ASL_RESOURCE_NODE *Rnode; 311 UINT8 *OptionalFields; 312 UINT16 StringLength = 0; 313 UINT32 OptionIndex = 0; 314 UINT32 CurrentByteOffset; 315 UINT32 i; 316 BOOLEAN ResSourceIndex = FALSE; 317 318 319 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 320 StringLength = RsGetStringDataLength (InitializerOp); 321 CurrentByteOffset = Info->CurrentByteOffset; 322 323 Rnode = RsAllocateResourceNode ( 324 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 325 326 Descriptor = Rnode->Buffer; 327 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 328 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 329 330 /* 331 * Initial descriptor length -- may be enlarged if there are 332 * optional fields present 333 */ 334 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 335 Descriptor->Address32.ResourceLength = (UINT16) 336 (sizeof (AML_RESOURCE_ADDRESS32) - 337 sizeof (AML_RESOURCE_LARGE_HEADER)); 338 339 340 /* Process all child initialization nodes */ 341 342 for (i = 0; InitializerOp; i++) 343 { 344 switch (i) 345 { 346 case 0: /* Resource Usage */ 347 348 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 349 break; 350 351 case 1: /* DecodeType */ 352 353 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 354 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 355 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 356 break; 357 358 case 2: /* MinType */ 359 360 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 361 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 362 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 363 break; 364 365 case 3: /* MaxType */ 366 367 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 368 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 369 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 370 break; 371 372 case 4: /* Memory Type */ 373 374 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0); 375 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 376 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1, 2); 377 break; 378 379 case 5: /* Read/Write Type */ 380 381 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1); 382 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 383 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0); 384 break; 385 386 case 6: /* Address Granularity */ 387 388 Descriptor->Address32.Granularity = 389 (UINT32) InitializerOp->Asl.Value.Integer; 390 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 391 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 392 GranOp = InitializerOp; 393 break; 394 395 case 7: /* Min Address */ 396 397 Descriptor->Address32.Minimum = 398 (UINT32) InitializerOp->Asl.Value.Integer; 399 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 400 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 401 MinOp = InitializerOp; 402 break; 403 404 case 8: /* Max Address */ 405 406 Descriptor->Address32.Maximum = 407 (UINT32) InitializerOp->Asl.Value.Integer; 408 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 409 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 410 MaxOp = InitializerOp; 411 break; 412 413 case 9: /* Translation Offset */ 414 415 Descriptor->Address32.TranslationOffset = 416 (UINT32) InitializerOp->Asl.Value.Integer; 417 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 418 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 419 break; 420 421 case 10: /* Address Length */ 422 423 Descriptor->Address32.AddressLength = 424 (UINT32) InitializerOp->Asl.Value.Integer; 425 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 426 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 427 LengthOp = InitializerOp; 428 break; 429 430 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 431 432 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 433 { 434 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 435 OptionIndex++; 436 Descriptor->Address32.ResourceLength++; 437 ResSourceIndex = TRUE; 438 } 439 break; 440 441 case 12: /* ResSource [Optional Field - STRING] */ 442 443 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 444 (InitializerOp->Asl.Value.String)) 445 { 446 if (StringLength) 447 { 448 Descriptor->Address32.ResourceLength = (UINT16) 449 (Descriptor->Address32.ResourceLength + StringLength); 450 451 strcpy ((char *) 452 &OptionalFields[OptionIndex], 453 InitializerOp->Asl.Value.String); 454 455 /* ResourceSourceIndex must also be valid */ 456 457 if (!ResSourceIndex) 458 { 459 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 460 InitializerOp, NULL); 461 } 462 } 463 } 464 465#if 0 466 /* 467 * Not a valid ResourceSource, ResourceSourceIndex must also 468 * be invalid 469 */ 470 else if (ResSourceIndex) 471 { 472 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 473 InitializerOp, NULL); 474 } 475#endif 476 break; 477 478 case 13: /* ResourceTag */ 479 480 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 481 break; 482 483 484 case 14: /* Address Range */ 485 486 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0); 487 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 488 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3, 2); 489 break; 490 491 case 15: /* Type */ 492 493 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 494 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 495 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 496 break; 497 498 default: 499 500 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 501 break; 502 } 503 504 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 505 } 506 507 /* Validate the Min/Max/Len/Gran values */ 508 509 RsLargeAddressCheck ( 510 (UINT64) Descriptor->Address32.Minimum, 511 (UINT64) Descriptor->Address32.Maximum, 512 (UINT64) Descriptor->Address32.AddressLength, 513 (UINT64) Descriptor->Address32.Granularity, 514 Descriptor->Address32.Flags, 515 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 516 517 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 518 OptionIndex + StringLength; 519 return (Rnode); 520} 521 522 523/******************************************************************************* 524 * 525 * FUNCTION: RsDoDwordSpaceDescriptor 526 * 527 * PARAMETERS: Info - Parse Op and resource template offset 528 * 529 * RETURN: Completed resource node 530 * 531 * DESCRIPTION: Construct a long "DwordSpace" descriptor 532 * 533 ******************************************************************************/ 534 535ASL_RESOURCE_NODE * 536RsDoDwordSpaceDescriptor ( 537 ASL_RESOURCE_INFO *Info) 538{ 539 AML_RESOURCE *Descriptor; 540 ACPI_PARSE_OBJECT *InitializerOp; 541 ACPI_PARSE_OBJECT *MinOp = NULL; 542 ACPI_PARSE_OBJECT *MaxOp = NULL; 543 ACPI_PARSE_OBJECT *LengthOp = NULL; 544 ACPI_PARSE_OBJECT *GranOp = NULL; 545 ASL_RESOURCE_NODE *Rnode; 546 UINT8 *OptionalFields; 547 UINT16 StringLength = 0; 548 UINT32 OptionIndex = 0; 549 UINT32 CurrentByteOffset; 550 UINT32 i; 551 BOOLEAN ResSourceIndex = FALSE; 552 553 554 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 555 StringLength = RsGetStringDataLength (InitializerOp); 556 CurrentByteOffset = Info->CurrentByteOffset; 557 558 Rnode = RsAllocateResourceNode ( 559 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 560 561 Descriptor = Rnode->Buffer; 562 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 563 564 /* 565 * Initial descriptor length -- may be enlarged if there are 566 * optional fields present 567 */ 568 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 569 Descriptor->Address32.ResourceLength = (UINT16) 570 (sizeof (AML_RESOURCE_ADDRESS32) - 571 sizeof (AML_RESOURCE_LARGE_HEADER)); 572 573 /* Process all child initialization nodes */ 574 575 for (i = 0; InitializerOp; i++) 576 { 577 switch (i) 578 { 579 case 0: /* Resource Type */ 580 581 Descriptor->Address32.ResourceType = 582 (UINT8) InitializerOp->Asl.Value.Integer; 583 break; 584 585 case 1: /* Resource Usage */ 586 587 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 588 break; 589 590 case 2: /* DecodeType */ 591 592 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 593 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 594 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 595 break; 596 597 case 3: /* MinType */ 598 599 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 600 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 601 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 602 break; 603 604 case 4: /* MaxType */ 605 606 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 607 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 608 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 609 break; 610 611 case 5: /* Type-Specific flags */ 612 613 Descriptor->Address32.SpecificFlags = 614 (UINT8) InitializerOp->Asl.Value.Integer; 615 break; 616 617 case 6: /* Address Granularity */ 618 619 Descriptor->Address32.Granularity = 620 (UINT32) InitializerOp->Asl.Value.Integer; 621 RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, 622 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 623 GranOp = InitializerOp; 624 break; 625 626 case 7: /* Min Address */ 627 628 Descriptor->Address32.Minimum = 629 (UINT32) InitializerOp->Asl.Value.Integer; 630 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, 631 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 632 MinOp = InitializerOp; 633 break; 634 635 case 8: /* Max Address */ 636 637 Descriptor->Address32.Maximum = 638 (UINT32) InitializerOp->Asl.Value.Integer; 639 RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, 640 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 641 MaxOp = InitializerOp; 642 break; 643 644 case 9: /* Translation Offset */ 645 646 Descriptor->Address32.TranslationOffset = 647 (UINT32) InitializerOp->Asl.Value.Integer; 648 RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, 649 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 650 break; 651 652 case 10: /* Address Length */ 653 654 Descriptor->Address32.AddressLength = 655 (UINT32) InitializerOp->Asl.Value.Integer; 656 RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, 657 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 658 LengthOp = InitializerOp; 659 break; 660 661 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 662 663 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 664 { 665 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 666 OptionIndex++; 667 Descriptor->Address32.ResourceLength++; 668 ResSourceIndex = TRUE; 669 } 670 break; 671 672 case 12: /* ResSource [Optional Field - STRING] */ 673 674 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 675 (InitializerOp->Asl.Value.String)) 676 { 677 if (StringLength) 678 { 679 Descriptor->Address32.ResourceLength = (UINT16) 680 (Descriptor->Address32.ResourceLength + StringLength); 681 682 strcpy ((char *) 683 &OptionalFields[OptionIndex], 684 InitializerOp->Asl.Value.String); 685 686 /* ResourceSourceIndex must also be valid */ 687 688 if (!ResSourceIndex) 689 { 690 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 691 InitializerOp, NULL); 692 } 693 } 694 } 695 696#if 0 697 /* 698 * Not a valid ResourceSource, ResourceSourceIndex must also 699 * be invalid 700 */ 701 else if (ResSourceIndex) 702 { 703 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 704 InitializerOp, NULL); 705 } 706#endif 707 break; 708 709 case 13: /* ResourceTag */ 710 711 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 712 break; 713 714 default: 715 716 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, 717 InitializerOp, NULL); 718 break; 719 } 720 721 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 722 } 723 724 /* Validate the Min/Max/Len/Gran values */ 725 726 RsLargeAddressCheck ( 727 (UINT64) Descriptor->Address32.Minimum, 728 (UINT64) Descriptor->Address32.Maximum, 729 (UINT64) Descriptor->Address32.AddressLength, 730 (UINT64) Descriptor->Address32.Granularity, 731 Descriptor->Address32.Flags, 732 MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp); 733 734 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 735 OptionIndex + StringLength; 736 return (Rnode); 737} 738