sys/contrib/dev/acpica/source/compiler/aslrestype2s.c

   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 +
 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 DWORD.
 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                 RsCreateDwordField (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 DWORD.
 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                 RsCreateDwordField (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 }