exprep.c revision 306536 
1/******************************************************************************
2 *
3 * Module Name: exprep - ACPI AML field prep utilities
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <contrib/dev/acpica/include/acpi.h>
45#include <contrib/dev/acpica/include/accommon.h>
46#include <contrib/dev/acpica/include/acinterp.h>
47#include <contrib/dev/acpica/include/amlcode.h>
48#include <contrib/dev/acpica/include/acnamesp.h>
49#include <contrib/dev/acpica/include/acdispat.h>
50
51
52#define _COMPONENT          ACPI_EXECUTER
53        ACPI_MODULE_NAME    ("exprep")
54
55/* Local prototypes */
56
57static UINT32
58AcpiExDecodeFieldAccess (
59    ACPI_OPERAND_OBJECT     *ObjDesc,
60    UINT8                   FieldFlags,
61    UINT32                  *ReturnByteAlignment);
62
63
64#ifdef ACPI_UNDER_DEVELOPMENT
65
66static UINT32
67AcpiExGenerateAccess (
68    UINT32                  FieldBitOffset,
69    UINT32                  FieldBitLength,
70    UINT32                  RegionLength);
71
72
73/*******************************************************************************
74 *
75 * FUNCTION:    AcpiExGenerateAccess
76 *
77 * PARAMETERS:  FieldBitOffset      - Start of field within parent region/buffer
78 *              FieldBitLength      - Length of field in bits
79 *              RegionLength        - Length of parent in bytes
80 *
81 * RETURN:      Field granularity (8, 16, 32 or 64) and
82 *              ByteAlignment (1, 2, 3, or 4)
83 *
84 * DESCRIPTION: Generate an optimal access width for fields defined with the
85 *              AnyAcc keyword.
86 *
87 * NOTE: Need to have the RegionLength in order to check for boundary
88 *       conditions (end-of-region). However, the RegionLength is a deferred
89 *       operation. Therefore, to complete this implementation, the generation
90 *       of this access width must be deferred until the region length has
91 *       been evaluated.
92 *
93 ******************************************************************************/
94
95static UINT32
96AcpiExGenerateAccess (
97    UINT32                  FieldBitOffset,
98    UINT32                  FieldBitLength,
99    UINT32                  RegionLength)
100{
101    UINT32                  FieldByteLength;
102    UINT32                  FieldByteOffset;
103    UINT32                  FieldByteEndOffset;
104    UINT32                  AccessByteWidth;
105    UINT32                  FieldStartOffset;
106    UINT32                  FieldEndOffset;
107    UINT32                  MinimumAccessWidth = 0xFFFFFFFF;
108    UINT32                  MinimumAccesses = 0xFFFFFFFF;
109    UINT32                  Accesses;
110
111
112    ACPI_FUNCTION_TRACE (ExGenerateAccess);
113
114
115    /* Round Field start offset and length to "minimal" byte boundaries */
116
117    FieldByteOffset = ACPI_DIV_8 (
118        ACPI_ROUND_DOWN (FieldBitOffset, 8));
119
120    FieldByteEndOffset = ACPI_DIV_8 (
121        ACPI_ROUND_UP (FieldBitLength + FieldBitOffset, 8));
122
123    FieldByteLength = FieldByteEndOffset - FieldByteOffset;
124
125    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
126        "Bit length %u, Bit offset %u\n",
127        FieldBitLength, FieldBitOffset));
128
129    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
130        "Byte Length %u, Byte Offset %u, End Offset %u\n",
131        FieldByteLength, FieldByteOffset, FieldByteEndOffset));
132
133    /*
134     * Iterative search for the maximum access width that is both aligned
135     * and does not go beyond the end of the region
136     *
137     * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
138     */
139    for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
140    {
141        /*
142         * 1) Round end offset up to next access boundary and make sure that
143         *    this does not go beyond the end of the parent region.
144         * 2) When the Access width is greater than the FieldByteLength, we
145         *    are done. (This does not optimize for the perfectly aligned
146         *    case yet).
147         */
148        if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <=
149            RegionLength)
150        {
151            FieldStartOffset =
152                ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
153                AccessByteWidth;
154
155            FieldEndOffset =
156                ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
157                    AccessByteWidth) / AccessByteWidth;
158
159            Accesses = FieldEndOffset - FieldStartOffset;
160
161            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
162                "AccessWidth %u end is within region\n", AccessByteWidth));
163
164            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
165                "Field Start %u, Field End %u -- requires %u accesses\n",
166                FieldStartOffset, FieldEndOffset, Accesses));
167
168            /* Single access is optimal */
169
170            if (Accesses <= 1)
171            {
172                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
173                    "Entire field can be accessed "
174                    "with one operation of size %u\n",
175                    AccessByteWidth));
176                return_VALUE (AccessByteWidth);
177            }
178
179            /*
180             * Fits in the region, but requires more than one read/write.
181             * try the next wider access on next iteration
182             */
183            if (Accesses < MinimumAccesses)
184            {
185                MinimumAccesses = Accesses;
186                MinimumAccessWidth = AccessByteWidth;
187            }
188        }
189        else
190        {
191            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
192                "AccessWidth %u end is NOT within region\n",
193                AccessByteWidth));
194            if (AccessByteWidth == 1)
195            {
196                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
197                    "Field goes beyond end-of-region!\n"));
198
199                /* Field does not fit in the region at all */
200
201                return_VALUE (0);
202            }
203
204            /*
205             * This width goes beyond the end-of-region, back off to
206             * previous access
207             */
208            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
209                "Backing off to previous optimal access width of %u\n",
210                MinimumAccessWidth));
211            return_VALUE (MinimumAccessWidth);
212        }
213    }
214
215    /*
216     * Could not read/write field with one operation,
217     * just use max access width
218     */
219    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
220        "Cannot access field in one operation, using width 8\n"));
221
222    return_VALUE (8);
223}
224#endif /* ACPI_UNDER_DEVELOPMENT */
225
226
227/*******************************************************************************
228 *
229 * FUNCTION:    AcpiExDecodeFieldAccess
230 *
231 * PARAMETERS:  ObjDesc             - Field object
232 *              FieldFlags          - Encoded fieldflags (contains access bits)
233 *              ReturnByteAlignment - Where the byte alignment is returned
234 *
235 * RETURN:      Field granularity (8, 16, 32 or 64) and
236 *              ByteAlignment (1, 2, 3, or 4)
237 *
238 * DESCRIPTION: Decode the AccessType bits of a field definition.
239 *
240 ******************************************************************************/
241
242static UINT32
243AcpiExDecodeFieldAccess (
244    ACPI_OPERAND_OBJECT     *ObjDesc,
245    UINT8                   FieldFlags,
246    UINT32                  *ReturnByteAlignment)
247{
248    UINT32                  Access;
249    UINT32                  ByteAlignment;
250    UINT32                  BitLength;
251
252
253    ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
254
255
256    Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
257
258    switch (Access)
259    {
260    case AML_FIELD_ACCESS_ANY:
261
262#ifdef ACPI_UNDER_DEVELOPMENT
263        ByteAlignment =
264            AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
265                ObjDesc->CommonField.BitLength,
266                0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
267        BitLength = ByteAlignment * 8;
268#endif
269
270        ByteAlignment = 1;
271        BitLength = 8;
272        break;
273
274    case AML_FIELD_ACCESS_BYTE:
275    case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
276
277        ByteAlignment = 1;
278        BitLength     = 8;
279        break;
280
281    case AML_FIELD_ACCESS_WORD:
282
283        ByteAlignment = 2;
284        BitLength     = 16;
285        break;
286
287    case AML_FIELD_ACCESS_DWORD:
288
289        ByteAlignment = 4;
290        BitLength     = 32;
291        break;
292
293    case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
294
295        ByteAlignment = 8;
296        BitLength     = 64;
297        break;
298
299    default:
300
301        /* Invalid field access type */
302
303        ACPI_ERROR ((AE_INFO,
304            "Unknown field access type 0x%X",
305            Access));
306
307        return_UINT32 (0);
308    }
309
310    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
311    {
312        /*
313         * BufferField access can be on any byte boundary, so the
314         * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
315         * implied by the field access type.
316         */
317        ByteAlignment = 1;
318    }
319
320    *ReturnByteAlignment = ByteAlignment;
321    return_UINT32 (BitLength);
322}
323
324
325/*******************************************************************************
326 *
327 * FUNCTION:    AcpiExPrepCommonFieldObject
328 *
329 * PARAMETERS:  ObjDesc             - The field object
330 *              FieldFlags          - Access, LockRule, and UpdateRule.
331 *                                    The format of a FieldFlag is described
332 *                                    in the ACPI specification
333 *              FieldAttribute      - Special attributes (not used)
334 *              FieldBitPosition    - Field start position
335 *              FieldBitLength      - Field length in number of bits
336 *
337 * RETURN:      Status
338 *
339 * DESCRIPTION: Initialize the areas of the field object that are common
340 *              to the various types of fields. Note: This is very "sensitive"
341 *              code because we are solving the general case for field
342 *              alignment.
343 *
344 ******************************************************************************/
345
346ACPI_STATUS
347AcpiExPrepCommonFieldObject (
348    ACPI_OPERAND_OBJECT     *ObjDesc,
349    UINT8                   FieldFlags,
350    UINT8                   FieldAttribute,
351    UINT32                  FieldBitPosition,
352    UINT32                  FieldBitLength)
353{
354    UINT32                  AccessBitWidth;
355    UINT32                  ByteAlignment;
356    UINT32                  NearestByteAddress;
357
358
359    ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
360
361
362    /*
363     * Note: the structure being initialized is the
364     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
365     * area are initialized by this procedure.
366     */
367    ObjDesc->CommonField.FieldFlags = FieldFlags;
368    ObjDesc->CommonField.Attribute  = FieldAttribute;
369    ObjDesc->CommonField.BitLength  = FieldBitLength;
370
371    /*
372     * Decode the access type so we can compute offsets. The access type gives
373     * two pieces of information - the width of each field access and the
374     * necessary ByteAlignment (address granularity) of the access.
375     *
376     * For AnyAcc, the AccessBitWidth is the largest width that is both
377     * necessary and possible in an attempt to access the whole field in one
378     * I/O operation. However, for AnyAcc, the ByteAlignment is always one
379     * byte.
380     *
381     * For all Buffer Fields, the ByteAlignment is always one byte.
382     *
383     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
384     * the same (equivalent) as the ByteAlignment.
385     */
386    AccessBitWidth = AcpiExDecodeFieldAccess (
387        ObjDesc, FieldFlags, &ByteAlignment);
388    if (!AccessBitWidth)
389    {
390        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
391    }
392
393    /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
394
395    ObjDesc->CommonField.AccessByteWidth = (UINT8)
396        ACPI_DIV_8 (AccessBitWidth);
397
398    /*
399     * BaseByteOffset is the address of the start of the field within the
400     * region. It is the byte address of the first *datum* (field-width data
401     * unit) of the field. (i.e., the first datum that contains at least the
402     * first *bit* of the field.)
403     *
404     * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
405     * (Byte access), and it defines the addressing granularity of the parent
406     * region or buffer.
407     */
408    NearestByteAddress =
409        ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
410    ObjDesc->CommonField.BaseByteOffset = (UINT32)
411        ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
412
413    /*
414     * StartFieldBitOffset is the offset of the first bit of the field within
415     * a field datum.
416     */
417    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
418        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
419
420    return_ACPI_STATUS (AE_OK);
421}
422
423
424/*******************************************************************************
425 *
426 * FUNCTION:    AcpiExPrepFieldValue
427 *
428 * PARAMETERS:  Info    - Contains all field creation info
429 *
430 * RETURN:      Status
431 *
432 * DESCRIPTION: Construct an object of type ACPI_OPERAND_OBJECT with a
433 *              subtype of DefField and connect it to the parent Node.
434 *
435 ******************************************************************************/
436
437ACPI_STATUS
438AcpiExPrepFieldValue (
439    ACPI_CREATE_FIELD_INFO  *Info)
440{
441    ACPI_OPERAND_OBJECT     *ObjDesc;
442    ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
443    ACPI_STATUS             Status;
444    UINT32                  AccessByteWidth;
445    UINT32                  Type;
446
447
448    ACPI_FUNCTION_TRACE (ExPrepFieldValue);
449
450
451    /* Parameter validation */
452
453    if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
454    {
455        if (!Info->RegionNode)
456        {
457            ACPI_ERROR ((AE_INFO, "Null RegionNode"));
458            return_ACPI_STATUS (AE_AML_NO_OPERAND);
459        }
460
461        Type = AcpiNsGetType (Info->RegionNode);
462        if (Type != ACPI_TYPE_REGION)
463        {
464            ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
465                Type, AcpiUtGetTypeName (Type)));
466
467            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
468        }
469    }
470
471    /* Allocate a new field object */
472
473    ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
474    if (!ObjDesc)
475    {
476        return_ACPI_STATUS (AE_NO_MEMORY);
477    }
478
479    /* Initialize areas of the object that are common to all fields */
480
481    ObjDesc->CommonField.Node = Info->FieldNode;
482    Status = AcpiExPrepCommonFieldObject (ObjDesc,
483        Info->FieldFlags, Info->Attribute,
484        Info->FieldBitPosition, Info->FieldBitLength);
485    if (ACPI_FAILURE (Status))
486    {
487        AcpiUtDeleteObjectDesc (ObjDesc);
488        return_ACPI_STATUS (Status);
489    }
490
491    /* Initialize areas of the object that are specific to the field type */
492
493    switch (Info->FieldType)
494    {
495    case ACPI_TYPE_LOCAL_REGION_FIELD:
496
497        ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
498
499        /* Fields specific to GenericSerialBus fields */
500
501        ObjDesc->Field.AccessLength = Info->AccessLength;
502
503        if (Info->ConnectionNode)
504        {
505            SecondDesc = Info->ConnectionNode->Object;
506            if (!(SecondDesc->Common.Flags & AOPOBJ_DATA_VALID))
507            {
508                Status = AcpiDsGetBufferArguments (SecondDesc);
509                if (ACPI_FAILURE (Status))
510                {
511                    AcpiUtDeleteObjectDesc (ObjDesc);
512                    return_ACPI_STATUS (Status);
513                }
514            }
515
516            ObjDesc->Field.ResourceBuffer =
517                SecondDesc->Buffer.Pointer;
518            ObjDesc->Field.ResourceLength =
519                (UINT16) SecondDesc->Buffer.Length;
520        }
521        else if (Info->ResourceBuffer)
522        {
523            ObjDesc->Field.ResourceBuffer = Info->ResourceBuffer;
524            ObjDesc->Field.ResourceLength = Info->ResourceLength;
525        }
526
527        ObjDesc->Field.PinNumberIndex = Info->PinNumberIndex;
528
529        /* Allow full data read from EC address space */
530
531        if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
532            (ObjDesc->CommonField.BitLength > 8))
533        {
534            AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
535                ObjDesc->CommonField.BitLength);
536
537            /* Maximum byte width supported is 255 */
538
539            if (AccessByteWidth < 256)
540            {
541                ObjDesc->CommonField.AccessByteWidth =
542                    (UINT8) AccessByteWidth;
543            }
544        }
545
546        /* An additional reference for the container */
547
548        AcpiUtAddReference (ObjDesc->Field.RegionObj);
549
550        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
551            "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
552            ObjDesc->Field.StartFieldBitOffset,
553            ObjDesc->Field.BaseByteOffset,
554            ObjDesc->Field.AccessByteWidth,
555            ObjDesc->Field.RegionObj));
556        break;
557
558    case ACPI_TYPE_LOCAL_BANK_FIELD:
559
560        ObjDesc->BankField.Value = Info->BankValue;
561        ObjDesc->BankField.RegionObj =
562            AcpiNsGetAttachedObject (Info->RegionNode);
563        ObjDesc->BankField.BankObj =
564            AcpiNsGetAttachedObject (Info->RegisterNode);
565
566        /* An additional reference for the attached objects */
567
568        AcpiUtAddReference (ObjDesc->BankField.RegionObj);
569        AcpiUtAddReference (ObjDesc->BankField.BankObj);
570
571        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
572            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
573            ObjDesc->BankField.StartFieldBitOffset,
574            ObjDesc->BankField.BaseByteOffset,
575            ObjDesc->Field.AccessByteWidth,
576            ObjDesc->BankField.RegionObj,
577            ObjDesc->BankField.BankObj));
578
579        /*
580         * Remember location in AML stream of the field unit
581         * opcode and operands -- since the BankValue
582         * operands must be evaluated.
583         */
584        SecondDesc = ObjDesc->Common.NextObject;
585        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
586            Info->DataRegisterNode)->Named.Data;
587        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
588            Info->DataRegisterNode)->Named.Length;
589
590        break;
591
592    case ACPI_TYPE_LOCAL_INDEX_FIELD:
593
594        /* Get the Index and Data registers */
595
596        ObjDesc->IndexField.IndexObj =
597            AcpiNsGetAttachedObject (Info->RegisterNode);
598        ObjDesc->IndexField.DataObj =
599            AcpiNsGetAttachedObject (Info->DataRegisterNode);
600
601        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
602        {
603            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
604            AcpiUtDeleteObjectDesc (ObjDesc);
605            return_ACPI_STATUS (AE_AML_INTERNAL);
606        }
607
608        /* An additional reference for the attached objects */
609
610        AcpiUtAddReference (ObjDesc->IndexField.DataObj);
611        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
612
613        /*
614         * April 2006: Changed to match MS behavior
615         *
616         * The value written to the Index register is the byte offset of the
617         * target field in units of the granularity of the IndexField
618         *
619         * Previously, the value was calculated as an index in terms of the
620         * width of the Data register, as below:
621         *
622         *      ObjDesc->IndexField.Value = (UINT32)
623         *          (Info->FieldBitPosition / ACPI_MUL_8 (
624         *              ObjDesc->Field.AccessByteWidth));
625         *
626         * February 2006: Tried value as a byte offset:
627         *      ObjDesc->IndexField.Value = (UINT32)
628         *          ACPI_DIV_8 (Info->FieldBitPosition);
629         */
630        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
631            ACPI_DIV_8 (Info->FieldBitPosition),
632            ObjDesc->IndexField.AccessByteWidth);
633
634        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
635            "IndexField: BitOff %X, Off %X, Value %X, "
636            "Gran %X, Index %p, Data %p\n",
637            ObjDesc->IndexField.StartFieldBitOffset,
638            ObjDesc->IndexField.BaseByteOffset,
639            ObjDesc->IndexField.Value,
640            ObjDesc->Field.AccessByteWidth,
641            ObjDesc->IndexField.IndexObj,
642            ObjDesc->IndexField.DataObj));
643        break;
644
645    default:
646
647        /* No other types should get here */
648
649        break;
650    }
651
652    /*
653     * Store the constructed descriptor (ObjDesc) into the parent Node,
654     * preserving the current type of that NamedObj.
655     */
656    Status = AcpiNsAttachObject (
657        Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));
658
659    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
660        "Set NamedObj %p [%4.4s], ObjDesc %p\n",
661        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
662
663    /* Remove local reference to the object */
664
665    AcpiUtRemoveReference (ObjDesc);
666    return_ACPI_STATUS (Status);
667}
668