1 /****************************************************************************** 2 * 3 * Module Name: aslrestype2s - Serial Large 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 "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 + 317 sizeof (AML_RESOURCE_LARGE_HEADER)); 318 319 Descriptor = Rnode->Buffer; 320 Descriptor->Gpio.ResourceLength = DescriptorSize; 321 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO; 322 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION; 323 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT; 324 325 /* Build pointers to optional areas */ 326 327 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, 328 sizeof (AML_RESOURCE_GPIO)); 329 PinList = InterruptList; 330 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength); 331 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength); 332 333 /* Setup offsets within the descriptor */ 334 335 Descriptor->Gpio.PinTableOffset = (UINT16) 336 ACPI_PTR_DIFF (InterruptList, Descriptor); 337 338 Descriptor->Gpio.ResSourceOffset = (UINT16) 339 ACPI_PTR_DIFF (ResourceSource, Descriptor); 340 341 DbgPrint (ASL_DEBUG_OUTPUT, 342 "%16s - Actual: %.2X, Base: %.2X, ResLen: " 343 "%.2X, VendLen: %.2X, IntLen: %.2X\n", 344 "GpioInt", Descriptor->Gpio.ResourceLength, 345 (UINT16) sizeof (AML_RESOURCE_GPIO), 346 ResSourceLength, VendorLength, InterruptLength); 347 348 /* Process all child initialization nodes */ 349 350 for (i = 0; InitializerOp; i++) 351 { 352 switch (i) 353 { 354 case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */ 355 356 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); 357 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 358 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0); 359 break; 360 361 case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */ 362 363 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0); 364 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY, 365 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2); 366 break; 367 368 case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */ 369 370 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); 371 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 372 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2); 373 break; 374 375 case 3: /* Pin Config [BYTE] (_PPI) */ 376 377 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer; 378 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG, 379 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig)); 380 break; 381 382 case 4: /* Debounce Timeout [WORD] (_DBT) */ 383 384 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; 385 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, 386 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); 387 break; 388 389 case 5: /* ResSource [Optional Field - STRING] */ 390 391 if (ResSourceLength) 392 { 393 /* Copy string to the descriptor */ 394 395 strcpy (ResourceSource, 396 InitializerOp->Asl.Value.String); 397 } 398 break; 399 400 case 6: /* Resource Index */ 401 402 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 403 { 404 Descriptor->Gpio.ResSourceIndex = 405 (UINT8) InitializerOp->Asl.Value.Integer; 406 } 407 break; 408 409 case 7: /* Resource Usage (consumer/producer) */ 410 411 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); 412 break; 413 414 case 8: /* Resource Tag (Descriptor Name) */ 415 416 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 417 break; 418 419 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 420 421 /* 422 * Always set the VendorOffset even if there is no Vendor Data. 423 * This field is required in order to calculate the length 424 * of the ResourceSource at runtime. 425 */ 426 Descriptor->Gpio.VendorOffset = (UINT16) 427 ACPI_PTR_DIFF (VendorData, Descriptor); 428 429 if (RsGetVendorData (InitializerOp, VendorData, 430 (CurrentByteOffset + Descriptor->Gpio.VendorOffset))) 431 { 432 Descriptor->Gpio.VendorLength = VendorLength; 433 } 434 break; 435 436 default: 437 /* 438 * PINs come through here, repeatedly. Each PIN must be a WORD. 439 * NOTE: there is no "length" field for this, so from ACPI spec: 440 * The number of pins in the table can be calculated from: 441 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2 442 * (implies resource source must immediately follow the pin list.) 443 * Name: _PIN 444 */ 445 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer; 446 InterruptList++; 447 PinCount++; 448 449 /* Case 10: First interrupt number in list */ 450 451 if (i == 10) 452 { 453 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 454 { 455 /* Must be at least one interrupt */ 456 457 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN, 458 InitializerOp, NULL); 459 } 460 461 /* Check now for duplicates in list */ 462 463 RsCheckListForDuplicates (InitializerOp); 464 465 /* Create a named field at the start of the list */ 466 467 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN, 468 CurrentByteOffset + Descriptor->Gpio.PinTableOffset); 469 } 470 break; 471 } 472 473 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 474 } 475 476 MpSaveGpioInfo (Info->MappingOp, Descriptor, 477 PinCount, PinList, ResourceSource); 478 return (Rnode); 479 } 480 481 482 /******************************************************************************* 483 * 484 * FUNCTION: RsDoGpioIoDescriptor 485 * 486 * PARAMETERS: Info - Parse Op and resource template offset 487 * 488 * RETURN: Completed resource node 489 * 490 * DESCRIPTION: Construct a long "GpioIo" descriptor 491 * 492 ******************************************************************************/ 493 494 ASL_RESOURCE_NODE * 495 RsDoGpioIoDescriptor ( 496 ASL_RESOURCE_INFO *Info) 497 { 498 AML_RESOURCE *Descriptor; 499 ACPI_PARSE_OBJECT *InitializerOp; 500 ASL_RESOURCE_NODE *Rnode; 501 char *ResourceSource = NULL; 502 UINT8 *VendorData = NULL; 503 UINT16 *InterruptList = NULL; 504 UINT16 *PinList = NULL; 505 UINT16 ResSourceLength; 506 UINT16 VendorLength; 507 UINT16 InterruptLength; 508 UINT16 DescriptorSize; 509 UINT32 CurrentByteOffset; 510 UINT32 PinCount = 0; 511 UINT32 i; 512 513 514 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 515 CurrentByteOffset = Info->CurrentByteOffset; 516 517 /* 518 * Calculate lengths for fields that have variable length: 519 * 1) Resource Source string 520 * 2) Vendor Data buffer 521 * 3) PIN (interrupt) list 522 */ 523 ResSourceLength = RsGetStringDataLength (InitializerOp); 524 VendorLength = RsGetBufferDataLength (InitializerOp); 525 InterruptLength = RsGetInterruptDataLength (InitializerOp); 526 PinList = InterruptList; 527 528 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) + 529 ResSourceLength + VendorLength + InterruptLength; 530 531 /* Allocate the local resource node and initialize */ 532 533 Rnode = RsAllocateResourceNode (DescriptorSize + 534 sizeof (AML_RESOURCE_LARGE_HEADER)); 535 536 Descriptor = Rnode->Buffer; 537 Descriptor->Gpio.ResourceLength = DescriptorSize; 538 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO; 539 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION; 540 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO; 541 542 /* Build pointers to optional areas */ 543 544 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO)); 545 PinList = InterruptList; 546 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength); 547 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength); 548 549 /* Setup offsets within the descriptor */ 550 551 Descriptor->Gpio.PinTableOffset = (UINT16) 552 ACPI_PTR_DIFF (InterruptList, Descriptor); 553 554 Descriptor->Gpio.ResSourceOffset = (UINT16) 555 ACPI_PTR_DIFF (ResourceSource, Descriptor); 556 557 DbgPrint (ASL_DEBUG_OUTPUT, 558 "%16s - Actual: %.2X, Base: %.2X, ResLen: " 559 "%.2X, VendLen: %.2X, IntLen: %.2X\n", 560 "GpioIo", Descriptor->Gpio.ResourceLength, 561 (UINT16) sizeof (AML_RESOURCE_GPIO), 562 ResSourceLength, VendorLength, InterruptLength); 563 564 /* Process all child initialization nodes */ 565 566 for (i = 0; InitializerOp; i++) 567 { 568 switch (i) 569 { 570 case 0: /* Share Type [Flags] (_SHR) */ 571 572 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); 573 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 574 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3); 575 break; 576 577 case 1: /* Pin Config [BYTE] (_PPI) */ 578 579 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer; 580 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG, 581 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig)); 582 break; 583 584 case 2: /* Debounce Timeout [WORD] (_DBT) */ 585 586 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; 587 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, 588 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); 589 break; 590 591 case 3: /* Drive Strength [WORD] (_DRS) */ 592 593 Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer; 594 RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH, 595 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength)); 596 break; 597 598 case 4: /* I/O Restriction [Flag] (_IOR) */ 599 600 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); 601 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION, 602 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2); 603 break; 604 605 case 5: /* ResSource [Optional Field - STRING] */ 606 607 if (ResSourceLength) 608 { 609 /* Copy string to the descriptor */ 610 611 strcpy (ResourceSource, 612 InitializerOp->Asl.Value.String); 613 } 614 break; 615 616 case 6: /* Resource Index */ 617 618 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 619 { 620 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 621 } 622 break; 623 624 case 7: /* Resource Usage (consumer/producer) */ 625 626 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); 627 break; 628 629 case 8: /* Resource Tag (Descriptor Name) */ 630 631 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 632 break; 633 634 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 635 /* 636 * Always set the VendorOffset even if there is no Vendor Data. 637 * This field is required in order to calculate the length 638 * of the ResourceSource at runtime. 639 */ 640 Descriptor->Gpio.VendorOffset = (UINT16) 641 ACPI_PTR_DIFF (VendorData, Descriptor); 642 643 if (RsGetVendorData (InitializerOp, VendorData, 644 (CurrentByteOffset + Descriptor->Gpio.VendorOffset))) 645 { 646 Descriptor->Gpio.VendorLength = VendorLength; 647 } 648 break; 649 650 default: 651 /* 652 * PINs come through here, repeatedly. Each PIN must be a WORD. 653 * NOTE: there is no "length" field for this, so from ACPI spec: 654 * The number of pins in the table can be calculated from: 655 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2 656 * (implies resource source must immediately follow the pin list.) 657 * Name: _PIN 658 */ 659 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer; 660 InterruptList++; 661 PinCount++; 662 663 /* Case 10: First interrupt number in list */ 664 665 if (i == 10) 666 { 667 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 668 { 669 /* Must be at least one interrupt */ 670 671 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN, 672 InitializerOp, NULL); 673 } 674 675 /* Check now for duplicates in list */ 676 677 RsCheckListForDuplicates (InitializerOp); 678 679 /* Create a named field at the start of the list */ 680 681 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN, 682 CurrentByteOffset + Descriptor->Gpio.PinTableOffset); 683 } 684 break; 685 } 686 687 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 688 } 689 690 MpSaveGpioInfo (Info->MappingOp, Descriptor, 691 PinCount, PinList, ResourceSource); 692 return (Rnode); 693 } 694 695 696 /******************************************************************************* 697 * 698 * FUNCTION: RsDoI2cSerialBusDescriptor 699 * 700 * PARAMETERS: Info - Parse Op and resource template offset 701 * 702 * RETURN: Completed resource node 703 * 704 * DESCRIPTION: Construct a long "I2cSerialBus" descriptor 705 * 706 ******************************************************************************/ 707 708 ASL_RESOURCE_NODE * 709 RsDoI2cSerialBusDescriptor ( 710 ASL_RESOURCE_INFO *Info) 711 { 712 AML_RESOURCE *Descriptor; 713 ACPI_PARSE_OBJECT *InitializerOp; 714 ASL_RESOURCE_NODE *Rnode; 715 char *ResourceSource = NULL; 716 UINT8 *VendorData = NULL; 717 UINT16 ResSourceLength; 718 UINT16 VendorLength; 719 UINT16 DescriptorSize; 720 UINT32 CurrentByteOffset; 721 UINT32 i; 722 723 724 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 725 CurrentByteOffset = Info->CurrentByteOffset; 726 727 /* 728 * Calculate lengths for fields that have variable length: 729 * 1) Resource Source string 730 * 2) Vendor Data buffer 731 */ 732 ResSourceLength = RsGetStringDataLength (InitializerOp); 733 VendorLength = RsGetBufferDataLength (InitializerOp); 734 735 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) + 736 ResSourceLength + VendorLength; 737 738 /* Allocate the local resource node and initialize */ 739 740 Rnode = RsAllocateResourceNode (DescriptorSize + 741 sizeof (AML_RESOURCE_LARGE_HEADER)); 742 743 Descriptor = Rnode->Buffer; 744 Descriptor->I2cSerialBus.ResourceLength = DescriptorSize; 745 Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 746 Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION; 747 Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION; 748 Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE; 749 Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength; 750 751 /* Build pointers to optional areas */ 752 753 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS)); 754 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 755 756 DbgPrint (ASL_DEBUG_OUTPUT, 757 "%16s - Actual: %.2X, Base: %.2X, ResLen: " 758 "%.2X, VendLen: %.2X, TypLen: %.2X\n", 759 "I2cSerialBus", Descriptor->I2cSerialBus.ResourceLength, 760 (UINT16) sizeof (AML_RESOURCE_I2C_SERIALBUS), ResSourceLength, 761 VendorLength, Descriptor->I2cSerialBus.TypeDataLength); 762 763 /* Process all child initialization nodes */ 764 765 for (i = 0; InitializerOp; i++) 766 { 767 switch (i) 768 { 769 case 0: /* Slave Address [WORD] (_ADR) */ 770 771 Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer; 772 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, 773 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress)); 774 break; 775 776 case 1: /* Slave Mode [Flag] (_SLV) */ 777 778 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0); 779 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 780 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0); 781 break; 782 783 case 2: /* Connection Speed [DWORD] (_SPE) */ 784 785 Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; 786 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 787 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed)); 788 break; 789 790 case 3: /* Addressing Mode [Flag] (_MOD) */ 791 792 RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 793 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 794 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0); 795 break; 796 797 case 4: /* ResSource [Optional Field - STRING] */ 798 799 if (ResSourceLength) 800 { 801 /* Copy string to the descriptor */ 802 803 strcpy (ResourceSource, 804 InitializerOp->Asl.Value.String); 805 } 806 break; 807 808 case 5: /* Resource Index */ 809 810 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 811 { 812 Descriptor->I2cSerialBus.ResSourceIndex = 813 (UINT8) InitializerOp->Asl.Value.Integer; 814 } 815 break; 816 817 case 6: /* Resource Usage (consumer/producer) */ 818 819 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1); 820 break; 821 822 case 7: /* Resource Tag (Descriptor Name) */ 823 824 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 825 break; 826 827 case 8: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 828 829 RsGetVendorData (InitializerOp, VendorData, 830 CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS)); 831 break; 832 833 default: /* Ignore any extra nodes */ 834 835 break; 836 } 837 838 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 839 } 840 841 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 842 return (Rnode); 843 } 844 845 846 /******************************************************************************* 847 * 848 * FUNCTION: RsDoSpiSerialBusDescriptor 849 * 850 * PARAMETERS: Info - Parse Op and resource template offset 851 * 852 * RETURN: Completed resource node 853 * 854 * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor 855 * 856 ******************************************************************************/ 857 858 ASL_RESOURCE_NODE * 859 RsDoSpiSerialBusDescriptor ( 860 ASL_RESOURCE_INFO *Info) 861 { 862 AML_RESOURCE *Descriptor; 863 ACPI_PARSE_OBJECT *InitializerOp; 864 ASL_RESOURCE_NODE *Rnode; 865 char *ResourceSource = NULL; 866 UINT8 *VendorData = NULL; 867 UINT16 ResSourceLength; 868 UINT16 VendorLength; 869 UINT16 DescriptorSize; 870 UINT32 CurrentByteOffset; 871 UINT32 i; 872 873 874 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 875 CurrentByteOffset = Info->CurrentByteOffset; 876 877 /* 878 * Calculate lengths for fields that have variable length: 879 * 1) Resource Source string 880 * 2) Vendor Data buffer 881 */ 882 ResSourceLength = RsGetStringDataLength (InitializerOp); 883 VendorLength = RsGetBufferDataLength (InitializerOp); 884 885 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) + 886 ResSourceLength + VendorLength; 887 888 /* Allocate the local resource node and initialize */ 889 890 Rnode = RsAllocateResourceNode (DescriptorSize + 891 sizeof (AML_RESOURCE_LARGE_HEADER)); 892 893 Descriptor = Rnode->Buffer; 894 Descriptor->SpiSerialBus.ResourceLength = DescriptorSize; 895 Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 896 Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION; 897 Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION; 898 Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE; 899 Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength; 900 901 /* Build pointers to optional areas */ 902 903 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, 904 sizeof (AML_RESOURCE_SPI_SERIALBUS)); 905 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 906 907 DbgPrint (ASL_DEBUG_OUTPUT, 908 "%16s - Actual: %.2X, Base: %.2X, ResLen: " 909 "%.2X, VendLen: %.2X, TypLen: %.2X\n", 910 "SpiSerialBus", Descriptor->SpiSerialBus.ResourceLength, 911 (UINT16) sizeof (AML_RESOURCE_SPI_SERIALBUS), ResSourceLength, 912 VendorLength, Descriptor->SpiSerialBus.TypeDataLength); 913 914 /* Process all child initialization nodes */ 915 916 for (i = 0; InitializerOp; i++) 917 { 918 switch (i) 919 { 920 case 0: /* Device Selection [WORD] (_ADR) */ 921 922 Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer; 923 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, 924 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection)); 925 break; 926 927 case 1: /* Device Polarity [Flag] (_DPL) */ 928 929 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0); 930 RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY, 931 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1); 932 break; 933 934 case 2: /* Wire Mode [Flag] (_MOD) */ 935 936 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 937 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, 938 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0); 939 break; 940 941 case 3: /* Device Bit Length [BYTE] (_LEN) */ 942 943 Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer; 944 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 945 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength)); 946 break; 947 948 case 4: /* Slave Mode [Flag] (_SLV) */ 949 950 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0); 951 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 952 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0); 953 break; 954 955 case 5: /* Connection Speed [DWORD] (_SPE) */ 956 957 Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; 958 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 959 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed)); 960 break; 961 962 case 6: /* Clock Polarity [BYTE] (_POL) */ 963 964 Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer; 965 RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY, 966 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity)); 967 break; 968 969 case 7: /* Clock Phase [BYTE] (_PHA) */ 970 971 Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer; 972 RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE, 973 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase)); 974 break; 975 976 case 8: /* ResSource [Optional Field - STRING] */ 977 978 if (ResSourceLength) 979 { 980 /* Copy string to the descriptor */ 981 982 strcpy (ResourceSource, 983 InitializerOp->Asl.Value.String); 984 } 985 break; 986 987 case 9: /* Resource Index */ 988 989 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 990 { 991 Descriptor->SpiSerialBus.ResSourceIndex = 992 (UINT8) InitializerOp->Asl.Value.Integer; 993 } 994 break; 995 996 case 10: /* Resource Usage (consumer/producer) */ 997 998 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1); 999 break; 1000 1001 case 11: /* Resource Tag (Descriptor Name) */ 1002 1003 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 1004 break; 1005 1006 case 12: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 1007 1008 RsGetVendorData (InitializerOp, VendorData, 1009 CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS)); 1010 break; 1011 1012 default: /* Ignore any extra nodes */ 1013 1014 break; 1015 } 1016 1017 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1018 } 1019 1020 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 1021 return (Rnode); 1022 } 1023 1024 1025 /******************************************************************************* 1026 * 1027 * FUNCTION: RsDoUartSerialBusDescriptor 1028 * 1029 * PARAMETERS: Info - Parse Op and resource template offset 1030 * 1031 * RETURN: Completed resource node 1032 * 1033 * DESCRIPTION: Construct a long "UART Serial Bus" descriptor 1034 * 1035 ******************************************************************************/ 1036 1037 ASL_RESOURCE_NODE * 1038 RsDoUartSerialBusDescriptor ( 1039 ASL_RESOURCE_INFO *Info) 1040 { 1041 AML_RESOURCE *Descriptor; 1042 ACPI_PARSE_OBJECT *InitializerOp; 1043 ASL_RESOURCE_NODE *Rnode; 1044 char *ResourceSource = NULL; 1045 UINT8 *VendorData = NULL; 1046 UINT16 ResSourceLength; 1047 UINT16 VendorLength; 1048 UINT16 DescriptorSize; 1049 UINT32 CurrentByteOffset; 1050 UINT32 i; 1051 1052 1053 InitializerOp = Info->DescriptorTypeOp->Asl.Child; 1054 CurrentByteOffset = Info->CurrentByteOffset; 1055 1056 /* 1057 * Calculate lengths for fields that have variable length: 1058 * 1) Resource Source string 1059 * 2) Vendor Data buffer 1060 */ 1061 ResSourceLength = RsGetStringDataLength (InitializerOp); 1062 VendorLength = RsGetBufferDataLength (InitializerOp); 1063 1064 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) + 1065 ResSourceLength + VendorLength; 1066 1067 /* Allocate the local resource node and initialize */ 1068 1069 Rnode = RsAllocateResourceNode (DescriptorSize + 1070 sizeof (AML_RESOURCE_LARGE_HEADER)); 1071 1072 Descriptor = Rnode->Buffer; 1073 Descriptor->UartSerialBus.ResourceLength = DescriptorSize; 1074 Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS; 1075 Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION; 1076 Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION; 1077 Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE; 1078 Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength; 1079 1080 /* Build pointers to optional areas */ 1081 1082 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS)); 1083 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength); 1084 1085 DbgPrint (ASL_DEBUG_OUTPUT, 1086 "%16s - Actual: %.2X, Base: %.2X, ResLen: " 1087 "%.2X, VendLen: %.2X, TypLen: %.2X\n", 1088 "UartSerialBus", Descriptor->UartSerialBus.ResourceLength, 1089 (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength, 1090 VendorLength, Descriptor->UartSerialBus.TypeDataLength); 1091 1092 /* Process all child initialization nodes */ 1093 1094 for (i = 0; InitializerOp; i++) 1095 { 1096 switch (i) 1097 { 1098 case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */ 1099 1100 Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer; 1101 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, 1102 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate)); 1103 break; 1104 1105 case 1: /* Bits Per Byte [Flags] (_LEN) */ 1106 1107 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3); 1108 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH, 1109 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3); 1110 break; 1111 1112 case 2: /* Stop Bits [Flags] (_STB) */ 1113 1114 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1); 1115 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS, 1116 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2); 1117 break; 1118 1119 case 3: /* Lines In Use [BYTE] (_LIN) */ 1120 1121 Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer; 1122 RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE, 1123 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled)); 1124 break; 1125 1126 case 4: /* Endianness [Flag] (_END) */ 1127 1128 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0); 1129 RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS, 1130 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7); 1131 break; 1132 1133 case 5: /* Parity [BYTE] (_PAR) */ 1134 1135 Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer; 1136 RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY, 1137 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity)); 1138 break; 1139 1140 case 6: /* Flow Control [Flags] (_FLC) */ 1141 1142 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); 1143 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL, 1144 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2); 1145 break; 1146 1147 case 7: /* Rx Buffer Size [WORD] (_RXL) */ 1148 1149 Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; 1150 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX, 1151 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize)); 1152 break; 1153 1154 case 8: /* Tx Buffer Size [WORD] (_TXL) */ 1155 1156 Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; 1157 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX, 1158 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize)); 1159 break; 1160 1161 case 9: /* ResSource [Optional Field - STRING] */ 1162 1163 if (ResSourceLength) 1164 { 1165 /* Copy string to the descriptor */ 1166 1167 strcpy (ResourceSource, 1168 InitializerOp->Asl.Value.String); 1169 } 1170 break; 1171 1172 case 10: /* Resource Index */ 1173 1174 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1175 { 1176 Descriptor->UartSerialBus.ResSourceIndex = 1177 (UINT8) InitializerOp->Asl.Value.Integer; 1178 } 1179 break; 1180 1181 case 11: /* Resource Usage (consumer/producer) */ 1182 1183 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1); 1184 1185 /* 1186 * Slave Mode [Flag] (_SLV) 1187 * 1188 * Note: There is no SlaveMode argument to the UartSerialBus macro, but 1189 * we add this name anyway to allow the flag to be set by ASL in the 1190 * rare case where there is a slave mode associated with the UART. 1191 */ 1192 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE, 1193 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0); 1194 break; 1195 1196 case 12: /* Resource Tag (Descriptor Name) */ 1197 1198 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp); 1199 break; 1200 1201 case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */ 1202 1203 RsGetVendorData (InitializerOp, VendorData, 1204 CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS)); 1205 break; 1206 1207 default: /* Ignore any extra nodes */ 1208 1209 break; 1210 } 1211 1212 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1213 } 1214 1215 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource); 1216 return (Rnode); 1217 } 1218