aslrestype2s.c revision 281075 
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
52static UINT16
53RsGetBufferDataLength (
54    ACPI_PARSE_OBJECT       *InitializerOp);
55
56static UINT16
57RsGetInterruptDataLength (
58    ACPI_PARSE_OBJECT       *InitializerOp);
59
60static BOOLEAN
61RsGetVendorData (
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
90static UINT16
91RsGetBufferDataLength (
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
141static UINT16
142RsGetInterruptDataLength (
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
183static BOOLEAN
184RsGetVendorData (
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
278ASL_RESOURCE_NODE *
279RsDoGpioIntDescriptor (
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
488ASL_RESOURCE_NODE *
489RsDoGpioIoDescriptor (
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
698ASL_RESOURCE_NODE *
699RsDoI2cSerialBusDescriptor (
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
845ASL_RESOURCE_NODE *
846RsDoSpiSerialBusDescriptor (
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
1020ASL_RESOURCE_NODE *
1021RsDoUartSerialBusDescriptor (
1022    ASL_RESOURCE_INFO       *Info)
1023{
1024    AML_RESOURCE            *Descriptor;
1025    ACPI_PARSE_OBJECT       *InitializerOp;
1026    ASL_RESOURCE_NODE       *Rnode;
1027    char                    *ResourceSource = NULL;
1028    UINT8                   *VendorData = NULL;
1029    UINT16                  ResSourceLength;
1030    UINT16                  VendorLength;
1031    UINT16                  DescriptorSize;
1032    UINT32                  CurrentByteOffset;
1033    UINT32                  i;
1034
1035
1036    InitializerOp = Info->DescriptorTypeOp->Asl.Child;
1037    CurrentByteOffset = Info->CurrentByteOffset;
1038
1039    /*
1040     * Calculate lengths for fields that have variable length:
1041     * 1) Resource Source string
1042     * 2) Vendor Data buffer
1043     */
1044    ResSourceLength = RsGetStringDataLength (InitializerOp);
1045    VendorLength = RsGetBufferDataLength (InitializerOp);
1046
1047    DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
1048        ResSourceLength + VendorLength;
1049
1050    /* Allocate the local resource node and initialize */
1051
1052    Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
1053
1054    Descriptor = Rnode->Buffer;
1055    Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
1056    Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
1057    Descriptor->UartSerialBus.RevisionId     = AML_RESOURCE_UART_REVISION;
1058    Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
1059    Descriptor->UartSerialBus.Type           = AML_RESOURCE_UART_SERIALBUSTYPE;
1060    Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
1061
1062    /* Build pointers to optional areas */
1063
1064    VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
1065    ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
1066
1067    DbgPrint (ASL_DEBUG_OUTPUT,
1068        "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
1069        "UartSerialBus", Descriptor->UartSerialBus.ResourceLength,
1070        (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength,
1071        VendorLength, Descriptor->UartSerialBus.TypeDataLength);
1072
1073    /* Process all child initialization nodes */
1074
1075    for (i = 0; InitializerOp; i++)
1076    {
1077        switch (i)
1078        {
1079        case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */
1080
1081            Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
1082            RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
1083                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
1084            break;
1085
1086        case 1: /* Bits Per Byte [Flags] (_LEN) */
1087
1088            RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
1089            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
1090                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
1091            break;
1092
1093        case 2: /* Stop Bits [Flags] (_STB) */
1094
1095            RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
1096            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
1097                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
1098            break;
1099
1100        case 3: /* Lines In Use [BYTE] (_LIN) */
1101
1102            Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
1103            RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
1104                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
1105            break;
1106
1107        case 4: /* Endianness [Flag] (_END) */
1108
1109            RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
1110            RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
1111                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
1112            break;
1113
1114        case 5: /* Parity [BYTE] (_PAR) */
1115
1116            Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
1117            RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
1118                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
1119            break;
1120
1121        case 6: /* Flow Control [Flags] (_FLC) */
1122
1123            RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
1124            RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
1125                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
1126            break;
1127
1128        case 7: /* Rx Buffer Size [WORD] (_RXL) */
1129
1130            Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1131            RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
1132                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
1133            break;
1134
1135        case 8: /* Tx Buffer Size [WORD] (_TXL) */
1136
1137            Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1138            RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
1139                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
1140            break;
1141
1142        case 9: /* ResSource [Optional Field - STRING] */
1143
1144            if (ResSourceLength)
1145            {
1146                /* Copy string to the descriptor */
1147
1148                strcpy (ResourceSource,
1149                    InitializerOp->Asl.Value.String);
1150            }
1151            break;
1152
1153        case 10: /* Resource Index */
1154
1155            if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1156            {
1157                Descriptor->UartSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
1158            }
1159            break;
1160
1161        case 11: /* Resource Usage (consumer/producer) */
1162
1163            RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
1164
1165            /*
1166             * Slave Mode [Flag] (_SLV)
1167             *
1168             * Note: There is no SlaveMode argument to the UartSerialBus macro, but
1169             * we add this name anyway to allow the flag to be set by ASL in the
1170             * rare case where there is a slave mode associated with the UART.
1171             */
1172            RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
1173                CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
1174            break;
1175
1176        case 12: /* Resource Tag (Descriptor Name) */
1177
1178            UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1179            break;
1180
1181        case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1182
1183            RsGetVendorData (InitializerOp, VendorData,
1184                CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
1185            break;
1186
1187        default:    /* Ignore any extra nodes */
1188
1189            break;
1190        }
1191
1192        InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1193    }
1194
1195    MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1196    return (Rnode);
1197}
1198