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