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