1 /****************************************************************************** 2 * 3 * Module Name: aslrestype2s - Serial Large 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 "aslcompiler.h" 45 #include "aslcompiler.y.h" 46 #include "amlcode.h" 47 48 #define _COMPONENT ACPI_COMPILER 49 ACPI_MODULE_NAME ("aslrestype2s") 50 51 52 static UINT16 53 RsGetBufferDataLength ( 54 ACPI_PARSE_OBJECT *InitializerOp); 55 56 static UINT16 57 RsGetInterruptDataLength ( 58 ACPI_PARSE_OBJECT *InitializerOp); 59 60 static BOOLEAN 61 RsGetVendorData ( 62 ACPI_PARSE_OBJECT *InitializerOp, 63 UINT8 *VendorData, 64 ACPI_SIZE DescriptorOffset); 65 66 /* 67 * This module contains descriptors for serial buses and GPIO: 68 * 69 * GpioInt 70 * GpioIo 71 * I2cSerialBus 72 * SpiSerialBus 73 * UartSerialBus 74 */ 75 76 77 /******************************************************************************* 78 * 79 * FUNCTION: RsGetBufferDataLength 80 * 81 * PARAMETERS: InitializerOp - Current parse op, start of the resource 82 * descriptor 83 * 84 * RETURN: Length of the data buffer 85 * 86 * DESCRIPTION: Get the length of a RawDataBuffer, used for vendor data. 87 * 88 ******************************************************************************/ 89 90 static UINT16 91 RsGetBufferDataLength ( 92 ACPI_PARSE_OBJECT *InitializerOp) 93 { 94 UINT16 ExtraDataSize = 0; 95 ACPI_PARSE_OBJECT *DataList; 96 97 98 /* Find the byte-initializer list */ 99 100 while (InitializerOp) 101 { 102 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DATABUFFER) 103 { 104 /* First child is the optional length (ignore it here) */ 105 106 DataList = InitializerOp->Asl.Child; 107 DataList = ASL_GET_PEER_NODE (DataList); 108 109 /* Count the data items (each one is a byte of data) */ 110 111 while (DataList) 112 { 113 ExtraDataSize++; 114 DataList = ASL_GET_PEER_NODE (DataList); 115 } 116 117 return (ExtraDataSize); 118 } 119 120 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 121 } 122 123 return (ExtraDataSize); 124 } 125 126 127 /******************************************************************************* 128 * 129 * FUNCTION: RsGetInterruptDataLength 130 * 131 * PARAMETERS: InitializerOp - Current parse op, start of the resource 132 * descriptor 133 * 134 * RETURN: Length of the interrupt data list 135 * 136 * DESCRIPTION: Get the length of a list of interrupt DWORDs for the GPIO 137 * descriptors. 138 * 139 ******************************************************************************/ 140 141 static UINT16 142 RsGetInterruptDataLength ( 143 ACPI_PARSE_OBJECT *InitializerOp) 144 { 145 UINT16 InterruptLength; 146 UINT32 i; 147 148 149 /* Count the interrupt numbers */ 150 151 InterruptLength = 0; 152 for (i = 0; InitializerOp; i++) 153 { 154 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 155 156 /* Interrupt list starts at offset 10 (Gpio descriptors) */ 157 158 if (i >= 10) 159 { 160 InterruptLength += 2; 161 } 162 } 163 164 return (InterruptLength); 165 } 166 167 168 /******************************************************************************* 169 * 170 * FUNCTION: RsGetVendorData 171 * 172 * PARAMETERS: InitializerOp - Current parse op, start of the resource 173 * descriptor. 174 * VendorData - Where the vendor data is returned 175 * DescriptorOffset - Where vendor data begins in descriptor 176 * 177 * RETURN: TRUE if valid vendor data was returned, FALSE otherwise. 178 * 179 * DESCRIPTION: Extract the vendor data and construct a vendor data buffer. 180 * 181 ******************************************************************************/ 182 183 static BOOLEAN 184 RsGetVendorData ( 185 ACPI_PARSE_OBJECT *InitializerOp, 186 UINT8 *VendorData, 187 ACPI_SIZE DescriptorOffset) 188 { 189 ACPI_PARSE_OBJECT *BufferOp; 190 UINT32 SpecifiedLength = ACPI_UINT32_MAX; 191 UINT16 ActualLength = 0; 192 193 194 /* Vendor Data field is always optional */ 195 196 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 197 { 198 return (FALSE); 199 } 200 201 BufferOp = InitializerOp->Asl.Child; 202 if (!BufferOp) 203 { 204 AslError (ASL_ERROR, ASL_MSG_SYNTAX, InitializerOp, ""); 205 return (FALSE); 206 } 207 208 /* First child is the optional buffer length (WORD) */ 209 210 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 211 { 212 SpecifiedLength = (UINT16) BufferOp->Asl.Value.Integer; 213 } 214 215 /* Insert field tag _VEN */ 216 217 RsCreateByteField (InitializerOp, ACPI_RESTAG_VENDORDATA, 218 (UINT16) DescriptorOffset); 219 220 /* Walk the list of buffer initializers (each is one byte) */ 221 222 BufferOp = RsCompleteNodeAndGetNext (BufferOp); 223 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 224 { 225 while (BufferOp) 226 { 227 *VendorData = (UINT8) BufferOp->Asl.Value.Integer; 228 VendorData++; 229 ActualLength++; 230 BufferOp = RsCompleteNodeAndGetNext (BufferOp); 231 } 232 } 233 234 /* Length validation. Buffer cannot be of zero length */ 235 236 if ((SpecifiedLength == 0) || 237 ((SpecifiedLength == ACPI_UINT32_MAX) && (ActualLength == 0))) 238 { 239 AslError (ASL_ERROR, ASL_MSG_BUFFER_LENGTH, InitializerOp, NULL); 240 return (FALSE); 241 } 242 243 if (SpecifiedLength != ACPI_UINT32_MAX) 244 { 245 /* ActualLength > SpecifiedLength -> error */ 246 247 if (ActualLength > SpecifiedLength) 248 { 249 AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG, InitializerOp, NULL); 250 return (FALSE); 251 } 252 253 /* ActualLength < SpecifiedLength -> remark */ 254 255 else if (ActualLength < SpecifiedLength) 256 { 257 AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT, InitializerOp, NULL); 258 return (FALSE); 259 } 260 } 261 262 return (TRUE); 263 } 264 265 266 /******************************************************************************* 267 * 268 * FUNCTION: RsDoGpioIntDescriptor 269 * 270 * PARAMETERS: Info - Parse Op and resource template offset 271 * 272 * RETURN: Completed resource node 273 * 274 * DESCRIPTION: Construct a long "GpioInt" descriptor 275 * 276 ******************************************************************************/ 277 278 ASL_RESOURCE_NODE * 279 RsDoGpioIntDescriptor ( 280 ASL_RESOURCE_INFO *Info) 281 { 282 AML_RESOURCE *Descriptor; 283 ACPI_PARSE_OBJECT *InitializerOp; 284 ASL_RESOURCE_NODE *Rnode; 285 char *ResourceSource = NULL; 286 UINT8 *VendorData = NULL; 287 UINT16 *InterruptList = NULL; 288 UINT16 *PinList = NULL; 289 UINT16 ResSourceLength; 290 UINT16 VendorLength; 291 UINT16 InterruptLength; 292 UINT16 DescriptorSize; 293 UINT32 CurrentByteOffset; 294 UINT32 PinCount = 0; 295 UINT32 i; 296 297 298 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 299 CurrentByteOffset = Info->CurrentByteOffset; 300 301 /* 302 * Calculate lengths for fields that have variable length: 303 * 1) Resource Source string 304 * 2) Vendor Data buffer 305 * 3) PIN (interrupt) list 306 */ 307 ResSourceLength = RsGetStringDataLength (InitializerOp); 308 VendorLength = RsGetBufferDataLength (InitializerOp); 309 InterruptLength = RsGetInterruptDataLength (InitializerOp); 310 311 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) + 312 ResSourceLength + VendorLength + InterruptLength; 313 314 /* Allocate the local resource node and initialize */ 315 316 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER)); 317 318 Descriptor = Rnode->Buffer; 319 Descriptor->Gpio.ResourceLength = DescriptorSize; 320 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO; 321 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION; 322 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT; 323 324 /* Build pointers to optional areas */ 325 326 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO)); 327 PinList = InterruptList; 328 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength); 329 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength); 330 331 /* Setup offsets within the descriptor */ 332 333 Descriptor->Gpio.PinTableOffset = (UINT16) 334 ACPI_PTR_DIFF (InterruptList, Descriptor); 335 336 Descriptor->Gpio.ResSourceOffset = (UINT16) 337 ACPI_PTR_DIFF (ResourceSource, Descriptor); 338 339 DbgPrint (ASL_DEBUG_OUTPUT, 340 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n", 341 "GpioInt", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO), 342 ResSourceLength, VendorLength, InterruptLength); 343 344 /* Process all child initialization nodes */ 345 346 for (i = 0; InitializerOp; i++) 347 { 348 switch (i) 349 { 350 case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */ 351 352 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); 353 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 354 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0); 355 break; 356 357 case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */ 358 359 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0); 360 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY, 361 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2); 362 break; 363 364 case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */ 365 366 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); 367 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 368 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2); 369 break; 370 371 case 3: /* Pin Config [BYTE] (_PPI) */ 372 373 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer; 374 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG, 375 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig)); 376 break; 377 378 case 4: /* Debounce Timeout [WORD] (_DBT) */ 379 380 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; 381 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, 382 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); 383 break; 384 385 case 5: /* ResSource [Optional Field - STRING] */ 386 387 if (ResSourceLength) 388 { 389 /* Copy string to the descriptor */ 390 391 strcpy (ResourceSource, 392 InitializerOp->Asl.Value.String); 393 } 394 break; 395 396 case 6: /* Resource Index */ 397 398 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 399 { 400 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 401 } 402 break; 403 404 case 7: /* Resource Usage (consumer/producer) */ 405 406 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); 407 break; 408 409 case 8: /* Resource Tag (Descriptor Name) */ 410 411 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 412 break; 413 414 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 415 416 /* 417 * Always set the VendorOffset even if there is no Vendor Data. 418 * This field is required in order to calculate the length 419 * of the ResourceSource at runtime. 420 */ 421 Descriptor->Gpio.VendorOffset = (UINT16) 422 ACPI_PTR_DIFF (VendorData, Descriptor); 423 424 if (RsGetVendorData (InitializerOp, VendorData, 425 (CurrentByteOffset + Descriptor->Gpio.VendorOffset))) 426 { 427 Descriptor->Gpio.VendorLength = VendorLength; 428 } 429 break; 430 431 default: 432 /* 433 * PINs come through here, repeatedly. Each PIN must be a DWORD. 434 * NOTE: there is no "length" field for this, so from ACPI spec: 435 * The number of pins in the table can be calculated from: 436 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2 437 * (implies resource source must immediately follow the pin list.) 438 * Name: _PIN 439 */ 440 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer; 441 InterruptList++; 442 PinCount++; 443 444 /* Case 10: First interrupt number in list */ 445 446 if (i == 10) 447 { 448 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 449 { 450 /* Must be at least one interrupt */ 451 452 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN, 453 InitializerOp, NULL); 454 } 455 456 /* Check now for duplicates in list */ 457 458 RsCheckListForDuplicates (InitializerOp); 459 460 /* Create a named field at the start of the list */ 461 462 RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN, 463 CurrentByteOffset + Descriptor->Gpio.PinTableOffset); 464 } 465 break; 466 } 467 468 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 469 } 470 471 MpSaveGpioInfo (Info->MappingOp, Descriptor, PinCount, PinList, ResourceSource); 472 return (Rnode); 473 } 474 475 476 /******************************************************************************* 477 * 478 * FUNCTION: RsDoGpioIoDescriptor 479 * 480 * PARAMETERS: Info - Parse Op and resource template offset 481 * 482 * RETURN: Completed resource node 483 * 484 * DESCRIPTION: Construct a long "GpioIo" descriptor 485 * 486 ******************************************************************************/ 487 488 ASL_RESOURCE_NODE * 489 RsDoGpioIoDescriptor ( 490 ASL_RESOURCE_INFO *Info) 491 { 492 AML_RESOURCE *Descriptor; 493 ACPI_PARSE_OBJECT *InitializerOp; 494 ASL_RESOURCE_NODE *Rnode; 495 char *ResourceSource = NULL; 496 UINT8 *VendorData = NULL; 497 UINT16 *InterruptList = NULL; 498 UINT16 *PinList = NULL; 499 UINT16 ResSourceLength; 500 UINT16 VendorLength; 501 UINT16 InterruptLength; 502 UINT16 DescriptorSize; 503 UINT32 CurrentByteOffset; 504 UINT32 PinCount = 0; 505 UINT32 i; 506 507 508 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 509 CurrentByteOffset = Info->CurrentByteOffset; 510 511 /* 512 * Calculate lengths for fields that have variable length: 513 * 1) Resource Source string 514 * 2) Vendor Data buffer 515 * 3) PIN (interrupt) list 516 */ 517 ResSourceLength = RsGetStringDataLength (InitializerOp); 518 VendorLength = RsGetBufferDataLength (InitializerOp); 519 InterruptLength = RsGetInterruptDataLength (InitializerOp); 520 PinList = InterruptList; 521 522 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) + 523 ResSourceLength + VendorLength + InterruptLength; 524 525 /* Allocate the local resource node and initialize */ 526 527 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER)); 528 529 Descriptor = Rnode->Buffer; 530 Descriptor->Gpio.ResourceLength = DescriptorSize; 531 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO; 532 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION; 533 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO; 534 535 /* Build pointers to optional areas */ 536 537 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO)); 538 PinList = InterruptList; 539 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength); 540 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength); 541 542 /* Setup offsets within the descriptor */ 543 544 Descriptor->Gpio.PinTableOffset = (UINT16) 545 ACPI_PTR_DIFF (InterruptList, Descriptor); 546 547 Descriptor->Gpio.ResSourceOffset = (UINT16) 548 ACPI_PTR_DIFF (ResourceSource, Descriptor); 549 550 DbgPrint (ASL_DEBUG_OUTPUT, 551 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n", 552 "GpioIo", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO), 553 ResSourceLength, VendorLength, InterruptLength); 554 555 /* Process all child initialization nodes */ 556 557 for (i = 0; InitializerOp; i++) 558 { 559 switch (i) 560 { 561 case 0: /* Share Type [Flags] (_SHR) */ 562 563 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); 564 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 565 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3); 566 break; 567 568 case 1: /* Pin Config [BYTE] (_PPI) */ 569 570 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer; 571 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG, 572 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig)); 573 break; 574 575 case 2: /* Debounce Timeout [WORD] (_DBT) */ 576 577 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; 578 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, 579 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); 580 break; 581 582 case 3: /* Drive Strength [WORD] (_DRS) */ 583 584 Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer; 585 RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH, 586 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength)); 587 break; 588 589 case 4: /* I/O Restriction [Flag] (_IOR) */ 590 591 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); 592 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION, 593 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2); 594 break; 595 596 case 5: /* ResSource [Optional Field - STRING] */ 597 598 if (ResSourceLength) 599 { 600 /* Copy string to the descriptor */ 601 602 strcpy (ResourceSource, 603 InitializerOp->Asl.Value.String); 604 } 605 break; 606 607 case 6: /* Resource Index */ 608 609 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 610 { 611 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 612 } 613 break; 614 615 case 7: /* Resource Usage (consumer/producer) */ 616 617 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); 618 break; 619 620 case 8: /* Resource Tag (Descriptor Name) */ 621 622 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 623 break; 624 625 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 626 /* 627 * Always set the VendorOffset even if there is no Vendor Data. 628 * This field is required in order to calculate the length 629 * of the ResourceSource at runtime. 630 */ 631 Descriptor->Gpio.VendorOffset = (UINT16) 632 ACPI_PTR_DIFF (VendorData, Descriptor); 633 634 if (RsGetVendorData (InitializerOp, VendorData, 635 (CurrentByteOffset + Descriptor->Gpio.VendorOffset))) 636 { 637 Descriptor->Gpio.VendorLength = VendorLength; 638 } 639 break; 640 641 default: 642 /* 643 * PINs come through here, repeatedly. Each PIN must be a DWORD. 644 * NOTE: there is no "length" field for this, so from ACPI spec: 645 * The number of pins in the table can be calculated from: 646 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2 647 * (implies resource source must immediately follow the pin list.) 648 * Name: _PIN 649 */ 650 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer; 651 InterruptList++; 652 PinCount++; 653 654 /* Case 10: First interrupt number in list */ 655 656 if (i == 10) 657 { 658 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 659 { 660 /* Must be at least one interrupt */ 661 662 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN, 663 InitializerOp, NULL); 664 } 665 666 /* Check now for duplicates in list */ 667 668 RsCheckListForDuplicates (InitializerOp); 669 670 /* Create a named field at the start of the list */ 671 672 RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN, 673 CurrentByteOffset + Descriptor->Gpio.PinTableOffset); 674 } 675 break; 676 } 677 678 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 679 } 680 681 MpSaveGpioInfo (Info->MappingOp, Descriptor, PinCount, PinList, ResourceSource); 682 return (Rnode); 683 } 684 685 686 /******************************************************************************* 687 * 688 * FUNCTION: RsDoI2cSerialBusDescriptor 689 * 690 * PARAMETERS: Info - Parse Op and resource template offset 691 * 692 * RETURN: Completed resource node 693 * 694 * DESCRIPTION: Construct a long "I2cSerialBus" descriptor 695 * 696 ******************************************************************************/ 697 698 ASL_RESOURCE_NODE * 699 RsDoI2cSerialBusDescriptor ( 700 ASL_RESOURCE_INFO *Info) 701 { 702 AML_RESOURCE *Descriptor; 703 ACPI_PARSE_OBJECT *InitializerOp; 704 ASL_RESOURCE_NODE *Rnode; 705 char *ResourceSource = NULL; 706 UINT8 *VendorData = NULL; 707 UINT16 ResSourceLength; 708 UINT16 VendorLength; 709 UINT16 DescriptorSize; 710 UINT32 CurrentByteOffset; 711 UINT32 i; 712 713 714 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 715 CurrentByteOffset = Info->CurrentByteOffset; 716 717 /* 718 * Calculate lengths for fields that have variable length: 719 * 1) Resource Source string 720 * 2) Vendor Data buffer 721 */ 722 ResSourceLength = RsGetStringDataLength (InitializerOp); 723 VendorLength = RsGetBufferDataLength (InitializerOp); 724 725 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) + 726 ResSourceLength + VendorLength; 727 728 /* Allocate the local resource node and initialize */ 729 730 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER)); 731 732 Descriptor = Rnode->Buffer; 733 Descriptor->I2cSerialBus.ResourceLength = DescriptorSize; 734 Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 735 Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION; 736 Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION; 737 Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE; 738 Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength; 739 740 /* Build pointers to optional areas */ 741 742 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS)); 743 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 744 745 DbgPrint (ASL_DEBUG_OUTPUT, 746 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n", 747 "I2cSerialBus", Descriptor->I2cSerialBus.ResourceLength, 748 (UINT16) sizeof (AML_RESOURCE_I2C_SERIALBUS), ResSourceLength, 749 VendorLength, Descriptor->I2cSerialBus.TypeDataLength); 750 751 /* Process all child initialization nodes */ 752 753 for (i = 0; InitializerOp; i++) 754 { 755 switch (i) 756 { 757 case 0: /* Slave Address [WORD] (_ADR) */ 758 759 Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer; 760 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, 761 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress)); 762 break; 763 764 case 1: /* Slave Mode [Flag] (_SLV) */ 765 766 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0); 767 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 768 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0); 769 break; 770 771 case 2: /* Connection Speed [DWORD] (_SPE) */ 772 773 Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; 774 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 775 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed)); 776 break; 777 778 case 3: /* Addressing Mode [Flag] (_MOD) */ 779 780 RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 781 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 782 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0); 783 break; 784 785 case 4: /* ResSource [Optional Field - STRING] */ 786 787 if (ResSourceLength) 788 { 789 /* Copy string to the descriptor */ 790 791 strcpy (ResourceSource, 792 InitializerOp->Asl.Value.String); 793 } 794 break; 795 796 case 5: /* Resource Index */ 797 798 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 799 { 800 Descriptor->I2cSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 801 } 802 break; 803 804 case 6: /* Resource Usage (consumer/producer) */ 805 806 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1); 807 break; 808 809 case 7: /* Resource Tag (Descriptor Name) */ 810 811 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 812 break; 813 814 case 8: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 815 816 RsGetVendorData (InitializerOp, VendorData, 817 CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS)); 818 break; 819 820 default: /* Ignore any extra nodes */ 821 822 break; 823 } 824 825 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 826 } 827 828 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 829 return (Rnode); 830 } 831 832 833 /******************************************************************************* 834 * 835 * FUNCTION: RsDoSpiSerialBusDescriptor 836 * 837 * PARAMETERS: Info - Parse Op and resource template offset 838 * 839 * RETURN: Completed resource node 840 * 841 * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor 842 * 843 ******************************************************************************/ 844 845 ASL_RESOURCE_NODE * 846 RsDoSpiSerialBusDescriptor ( 847 ASL_RESOURCE_INFO *Info) 848 { 849 AML_RESOURCE *Descriptor; 850 ACPI_PARSE_OBJECT *InitializerOp; 851 ASL_RESOURCE_NODE *Rnode; 852 char *ResourceSource = NULL; 853 UINT8 *VendorData = NULL; 854 UINT16 ResSourceLength; 855 UINT16 VendorLength; 856 UINT16 DescriptorSize; 857 UINT32 CurrentByteOffset; 858 UINT32 i; 859 860 861 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 862 CurrentByteOffset = Info->CurrentByteOffset; 863 864 /* 865 * Calculate lengths for fields that have variable length: 866 * 1) Resource Source string 867 * 2) Vendor Data buffer 868 */ 869 ResSourceLength = RsGetStringDataLength (InitializerOp); 870 VendorLength = RsGetBufferDataLength (InitializerOp); 871 872 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) + 873 ResSourceLength + VendorLength; 874 875 /* Allocate the local resource node and initialize */ 876 877 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER)); 878 879 Descriptor = Rnode->Buffer; 880 Descriptor->SpiSerialBus.ResourceLength = DescriptorSize; 881 Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 882 Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION; 883 Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION; 884 Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE; 885 Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength; 886 887 /* Build pointers to optional areas */ 888 889 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_SPI_SERIALBUS)); 890 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 891 892 DbgPrint (ASL_DEBUG_OUTPUT, 893 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n", 894 "SpiSerialBus", Descriptor->SpiSerialBus.ResourceLength, 895 (UINT16) sizeof (AML_RESOURCE_SPI_SERIALBUS), ResSourceLength, 896 VendorLength, Descriptor->SpiSerialBus.TypeDataLength); 897 898 /* Process all child initialization nodes */ 899 900 for (i = 0; InitializerOp; i++) 901 { 902 switch (i) 903 { 904 case 0: /* Device Selection [WORD] (_ADR) */ 905 906 Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer; 907 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, 908 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection)); 909 break; 910 911 case 1: /* Device Polarity [Flag] (_DPL) */ 912 913 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0); 914 RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY, 915 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1); 916 break; 917 918 case 2: /* Wire Mode [Flag] (_MOD) */ 919 920 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 921 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 922 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0); 923 break; 924 925 case 3: /* Device Bit Length [BYTE] (_LEN) */ 926 927 Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer; 928 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 929 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength)); 930 break; 931 932 case 4: /* Slave Mode [Flag] (_SLV) */ 933 934 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0); 935 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 936 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0); 937 break; 938 939 case 5: /* Connection Speed [DWORD] (_SPE) */ 940 941 Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; 942 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 943 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed)); 944 break; 945 946 case 6: /* Clock Polarity [BYTE] (_POL) */ 947 948 Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer; 949 RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY, 950 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity)); 951 break; 952 953 case 7: /* Clock Phase [BYTE] (_PHA) */ 954 955 Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer; 956 RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE, 957 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase)); 958 break; 959 960 case 8: /* ResSource [Optional Field - STRING] */ 961 962 if (ResSourceLength) 963 { 964 /* Copy string to the descriptor */ 965 966 strcpy (ResourceSource, 967 InitializerOp->Asl.Value.String); 968 } 969 break; 970 971 case 9: /* Resource Index */ 972 973 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 974 { 975 Descriptor->SpiSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 976 } 977 break; 978 979 case 10: /* Resource Usage (consumer/producer) */ 980 981 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1); 982 break; 983 984 case 11: /* Resource Tag (Descriptor Name) */ 985 986 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 987 break; 988 989 case 12: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 990 991 RsGetVendorData (InitializerOp, VendorData, 992 CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS)); 993 break; 994 995 default: /* Ignore any extra nodes */ 996 997 break; 998 } 999 1000 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1001 } 1002 1003 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 1004 return (Rnode); 1005 } 1006 1007 1008 /******************************************************************************* 1009 * 1010 * FUNCTION: RsDoUartSerialBusDescriptor 1011 * 1012 * PARAMETERS: Info - Parse Op and resource template offset 1013 * 1014 * RETURN: Completed resource node 1015 * 1016 * DESCRIPTION: Construct a long "UART Serial Bus" descriptor 1017 * 1018 ******************************************************************************/ 1019 1020 ASL_RESOURCE_NODE * 1021 RsDoUartSerialBusDescriptor ( 1022 ASL_RESOURCE_INFO *Info) 1023 { 1024 AML_RESOURCE *Descriptor; 1025 ACPI_PARSE_OBJECT *InitializerOp; 1026 ASL_RESOURCE_NODE *Rnode; 1027 char *ResourceSource = NULL; 1028 UINT8 *VendorData = NULL; 1029 UINT16 ResSourceLength; 1030 UINT16 VendorLength; 1031 UINT16 DescriptorSize; 1032 UINT32 CurrentByteOffset; 1033 UINT32 i; 1034 1035 1036 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 1037 CurrentByteOffset = Info->CurrentByteOffset; 1038 1039 /* 1040 * Calculate lengths for fields that have variable length: 1041 * 1) Resource Source string 1042 * 2) Vendor Data buffer 1043 */ 1044 ResSourceLength = RsGetStringDataLength (InitializerOp); 1045 VendorLength = RsGetBufferDataLength (InitializerOp); 1046 1047 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) + 1048 ResSourceLength + VendorLength; 1049 1050 /* Allocate the local resource node and initialize */ 1051 1052 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER)); 1053 1054 Descriptor = Rnode->Buffer; 1055 Descriptor->UartSerialBus.ResourceLength = DescriptorSize; 1056 Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 1057 Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION; 1058 Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION; 1059 Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE; 1060 Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength; 1061 1062 /* Build pointers to optional areas */ 1063 1064 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS)); 1065 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 1066 1067 DbgPrint (ASL_DEBUG_OUTPUT, 1068 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n", 1069 "UartSerialBus", Descriptor->UartSerialBus.ResourceLength, 1070 (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength, 1071 VendorLength, Descriptor->UartSerialBus.TypeDataLength); 1072 1073 /* Process all child initialization nodes */ 1074 1075 for (i = 0; InitializerOp; i++) 1076 { 1077 switch (i) 1078 { 1079 case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */ 1080 1081 Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer; 1082 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 1083 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate)); 1084 break; 1085 1086 case 1: /* Bits Per Byte [Flags] (_LEN) */ 1087 1088 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3); 1089 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH, 1090 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3); 1091 break; 1092 1093 case 2: /* Stop Bits [Flags] (_STB) */ 1094 1095 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1); 1096 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS, 1097 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2); 1098 break; 1099 1100 case 3: /* Lines In Use [BYTE] (_LIN) */ 1101 1102 Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer; 1103 RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE, 1104 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled)); 1105 break; 1106 1107 case 4: /* Endianness [Flag] (_END) */ 1108 1109 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0); 1110 RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS, 1111 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7); 1112 break; 1113 1114 case 5: /* Parity [BYTE] (_PAR) */ 1115 1116 Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer; 1117 RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY, 1118 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity)); 1119 break; 1120 1121 case 6: /* Flow Control [Flags] (_FLC) */ 1122 1123 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 1124 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL, 1125 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2); 1126 break; 1127 1128 case 7: /* Rx Buffer Size [WORD] (_RXL) */ 1129 1130 Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; 1131 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX, 1132 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize)); 1133 break; 1134 1135 case 8: /* Tx Buffer Size [WORD] (_TXL) */ 1136 1137 Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; 1138 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX, 1139 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize)); 1140 break; 1141 1142 case 9: /* ResSource [Optional Field - STRING] */ 1143 1144 if (ResSourceLength) 1145 { 1146 /* Copy string to the descriptor */ 1147 1148 strcpy (ResourceSource, 1149 InitializerOp->Asl.Value.String); 1150 } 1151 break; 1152 1153 case 10: /* Resource Index */ 1154 1155 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1156 { 1157 Descriptor->UartSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 1158 } 1159 break; 1160 1161 case 11: /* Resource Usage (consumer/producer) */ 1162 1163 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1); 1164 1165 /* 1166 * Slave Mode [Flag] (_SLV) 1167 * 1168 * Note: There is no SlaveMode argument to the UartSerialBus macro, but 1169 * we add this name anyway to allow the flag to be set by ASL in the 1170 * rare case where there is a slave mode associated with the UART. 1171 */ 1172 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 1173 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0); 1174 break; 1175 1176 case 12: /* Resource Tag (Descriptor Name) */ 1177 1178 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 1179 break; 1180 1181 case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 1182 1183 RsGetVendorData (InitializerOp, VendorData, 1184 CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS)); 1185 break; 1186 1187 default: /* Ignore any extra nodes */ 1188 1189 break; 1190 } 1191 1192 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1193 } 1194 1195 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 1196 return (Rnode); 1197 } 1198