nsobject.c revision 99146
1/*******************************************************************************
2 *
3 * Module Name: nsobject - Utilities for objects attached to namespace
4 *                         table entries
5 *              $Revision: 80 $
6 *
7 ******************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights.  You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code.  No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision.  In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change.  Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee.  Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution.  In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government.  In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118
119#define __NSOBJECT_C__
120
121#include "acpi.h"
122#include "amlcode.h"
123#include "acnamesp.h"
124#include "acinterp.h"
125#include "actables.h"
126
127
128#define _COMPONENT          ACPI_NAMESPACE
129        ACPI_MODULE_NAME    ("nsobject")
130
131
132/*******************************************************************************
133 *
134 * FUNCTION:    AcpiNsAttachObject
135 *
136 * PARAMETERS:  Node                - Parent Node
137 *              Object              - Object to be attached
138 *              Type                - Type of object, or ACPI_TYPE_ANY if not
139 *                                    known
140 *
141 * DESCRIPTION: Record the given object as the value associated with the
142 *              name whose ACPI_HANDLE is passed.  If Object is NULL
143 *              and Type is ACPI_TYPE_ANY, set the name as having no value.
144 *              Note: Future may require that the Node->Flags field be passed
145 *              as a parameter.
146 *
147 * MUTEX:       Assumes namespace is locked
148 *
149 ******************************************************************************/
150
151ACPI_STATUS
152AcpiNsAttachObject (
153    ACPI_NAMESPACE_NODE     *Node,
154    ACPI_OPERAND_OBJECT     *Object,
155    ACPI_OBJECT_TYPE        Type)
156{
157    ACPI_OPERAND_OBJECT     *ObjDesc;
158    ACPI_OPERAND_OBJECT     *LastObjDesc;
159    ACPI_OBJECT_TYPE        ObjectType = ACPI_TYPE_ANY;
160
161
162    ACPI_FUNCTION_TRACE ("NsAttachObject");
163
164
165    /*
166     * Parameter validation
167     */
168    if (!Node)
169    {
170        /* Invalid handle */
171
172        ACPI_REPORT_ERROR (("NsAttachObject: Null NamedObj handle\n"));
173        return_ACPI_STATUS (AE_BAD_PARAMETER);
174    }
175
176    if (!Object && (ACPI_TYPE_ANY != Type))
177    {
178        /* Null object */
179
180        ACPI_REPORT_ERROR (("NsAttachObject: Null object, but type not ACPI_TYPE_ANY\n"));
181        return_ACPI_STATUS (AE_BAD_PARAMETER);
182    }
183
184    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
185    {
186        /* Not a name handle */
187
188        ACPI_REPORT_ERROR (("NsAttachObject: Invalid handle\n"));
189        return_ACPI_STATUS (AE_BAD_PARAMETER);
190    }
191
192    /* Check if this object is already attached */
193
194    if (Node->Object == Object)
195    {
196        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj %p already installed in NameObj %p\n",
197            Object, Node));
198
199        return_ACPI_STATUS (AE_OK);
200    }
201
202    /* If null object, we will just install it */
203
204    if (!Object)
205    {
206        ObjDesc    = NULL;
207        ObjectType = ACPI_TYPE_ANY;
208    }
209
210    /*
211     * If the source object is a namespace Node with an attached object,
212     * we will use that (attached) object
213     */
214    else if ((ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED) &&
215            ((ACPI_NAMESPACE_NODE *) Object)->Object)
216    {
217        /*
218         * Value passed is a name handle and that name has a
219         * non-null value.  Use that name's value and type.
220         */
221        ObjDesc    = ((ACPI_NAMESPACE_NODE *) Object)->Object;
222        ObjectType = ((ACPI_NAMESPACE_NODE *) Object)->Type;
223    }
224
225    /*
226     * Otherwise, we will use the parameter object, but we must type
227     * it first
228     */
229    else
230    {
231        ObjDesc = (ACPI_OPERAND_OBJECT  *) Object;
232
233        /* If a valid type (non-ANY) was given, just use it */
234
235        if (ACPI_TYPE_ANY != Type)
236        {
237            ObjectType = Type;
238        }
239        else
240        {
241            ObjectType = INTERNAL_TYPE_DEF_ANY;
242        }
243    }
244
245    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n",
246        ObjDesc, Node, (char *) &Node->Name));
247
248    /*
249     * Must increment the new value's reference count
250     * (if it is an internal object)
251     */
252    AcpiUtAddReference (ObjDesc);
253
254    /* Detach an existing attached object if present */
255
256    if (Node->Object)
257    {
258        AcpiNsDetachObject (Node);
259    }
260
261
262    /*
263     * Handle objects with multiple descriptors - walk
264     * to the end of the descriptor list
265     */
266    LastObjDesc = ObjDesc;
267    while (LastObjDesc->Common.NextObject)
268    {
269        LastObjDesc = LastObjDesc->Common.NextObject;
270    }
271
272    /* Install the object at the front of the object list */
273
274    LastObjDesc->Common.NextObject = Node->Object;
275
276    Node->Type     = (UINT8) ObjectType;
277    Node->Object   = ObjDesc;
278
279    return_ACPI_STATUS (AE_OK);
280}
281
282
283/*******************************************************************************
284 *
285 * FUNCTION:    AcpiNsDetachObject
286 *
287 * PARAMETERS:  Node           - An object whose Value will be deleted
288 *
289 * RETURN:      None.
290 *
291 * DESCRIPTION: Delete the Value associated with a namespace object.  If the
292 *              Value is an allocated object, it is freed.  Otherwise, the
293 *              field is simply cleared.
294 *
295 ******************************************************************************/
296
297void
298AcpiNsDetachObject (
299    ACPI_NAMESPACE_NODE     *Node)
300{
301    ACPI_OPERAND_OBJECT     *ObjDesc;
302
303
304    ACPI_FUNCTION_TRACE ("NsDetachObject");
305
306
307    ObjDesc = Node->Object;
308    if (!ObjDesc    ||
309        (ObjDesc->Common.Type == INTERNAL_TYPE_DATA))
310    {
311        return_VOID;
312    }
313
314    /* Clear the entry in all cases */
315
316    Node->Object = NULL;
317    if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_INTERNAL)
318    {
319        Node->Object = ObjDesc->Common.NextObject;
320        if (Node->Object &&
321           (Node->Object->Common.Type != INTERNAL_TYPE_DATA))
322        {
323            Node->Object = Node->Object->Common.NextObject;
324        }
325    }
326
327    /* Reset the node type to untyped */
328
329    Node->Type = ACPI_TYPE_ANY;
330
331    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n",
332        Node, (char *) &Node->Name, ObjDesc));
333
334    /* Remove one reference on the object (and all subobjects) */
335
336    AcpiUtRemoveReference (ObjDesc);
337    return_VOID;
338}
339
340
341/*******************************************************************************
342 *
343 * FUNCTION:    AcpiNsGetAttachedObject
344 *
345 * PARAMETERS:  Node             - Parent Node to be examined
346 *
347 * RETURN:      Current value of the object field from the Node whose
348 *              handle is passed
349 *
350 ******************************************************************************/
351
352ACPI_OPERAND_OBJECT *
353AcpiNsGetAttachedObject (
354    ACPI_NAMESPACE_NODE     *Node)
355{
356    ACPI_FUNCTION_TRACE_PTR ("NsGetAttachedObject", Node);
357
358
359    if (!Node)
360    {
361        ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Null Node ptr\n"));
362        return_PTR (NULL);
363    }
364
365    if (!Node->Object ||
366            ((ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_INTERNAL)  &&
367             (ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_NAMED))    ||
368        (Node->Object->Common.Type == INTERNAL_TYPE_DATA))
369    {
370        return_PTR (NULL);
371    }
372
373    return_PTR (Node->Object);
374}
375
376
377/*******************************************************************************
378 *
379 * FUNCTION:    AcpiNsGetSecondaryObject
380 *
381 * PARAMETERS:  Node             - Parent Node to be examined
382 *
383 * RETURN:      Current value of the object field from the Node whose
384 *              handle is passed
385 *
386 ******************************************************************************/
387
388ACPI_OPERAND_OBJECT *
389AcpiNsGetSecondaryObject (
390    ACPI_OPERAND_OBJECT     *ObjDesc)
391{
392    ACPI_FUNCTION_TRACE_PTR ("NsGetSecondaryObject", ObjDesc);
393
394
395    if ((!ObjDesc)                                   ||
396        (ObjDesc->Common.Type == INTERNAL_TYPE_DATA) ||
397        (!ObjDesc->Common.NextObject)                ||
398        (ObjDesc->Common.NextObject->Common.Type == INTERNAL_TYPE_DATA))
399    {
400        return_PTR (NULL);
401    }
402
403    return_PTR (ObjDesc->Common.NextObject);
404}
405
406
407/*******************************************************************************
408 *
409 * FUNCTION:    AcpiNsAttachData
410 *
411 * PARAMETERS:
412 *
413 * RETURN:      Status
414 *
415 * DESCRIPTION:
416 *
417 ******************************************************************************/
418
419ACPI_STATUS
420AcpiNsAttachData (
421    ACPI_NAMESPACE_NODE     *Node,
422    ACPI_OBJECT_HANDLER     Handler,
423    void                    *Data)
424{
425    ACPI_OPERAND_OBJECT     *PrevObjDesc;
426    ACPI_OPERAND_OBJECT     *ObjDesc;
427    ACPI_OPERAND_OBJECT     *DataDesc;
428
429
430    /* */
431    PrevObjDesc = NULL;
432    ObjDesc = Node->Object;
433    while (ObjDesc)
434    {
435        if ((ObjDesc->Common.Type == INTERNAL_TYPE_DATA) &&
436            (ObjDesc->Data.Handler == Handler))
437        {
438            return (AE_ALREADY_EXISTS);
439        }
440
441        PrevObjDesc = ObjDesc;
442        ObjDesc = ObjDesc->Common.NextObject;
443    }
444
445
446    /* Create an internal object for the data */
447
448    DataDesc = AcpiUtCreateInternalObject (INTERNAL_TYPE_DATA);
449    if (!DataDesc)
450    {
451        return (AE_NO_MEMORY);
452    }
453
454    DataDesc->Data.Handler = Handler;
455    DataDesc->Data.Pointer = Data;
456
457
458    /* Install the data object */
459
460    if (PrevObjDesc)
461    {
462        PrevObjDesc->Common.NextObject = DataDesc;
463    }
464    else
465    {
466        Node->Object = DataDesc;
467    }
468
469    return (AE_OK);
470}
471
472
473/*******************************************************************************
474 *
475 * FUNCTION:    AcpiNsDetachData
476 *
477 * PARAMETERS:
478 *
479 * RETURN:      Status
480 *
481 * DESCRIPTION:
482 *
483 ******************************************************************************/
484
485ACPI_STATUS
486AcpiNsDetachData (
487    ACPI_NAMESPACE_NODE     *Node,
488    ACPI_OBJECT_HANDLER     Handler)
489{
490    ACPI_OPERAND_OBJECT     *ObjDesc;
491    ACPI_OPERAND_OBJECT     *PrevObjDesc;
492
493
494    PrevObjDesc = NULL;
495    ObjDesc = Node->Object;
496    while (ObjDesc)
497    {
498        if ((ObjDesc->Common.Type == INTERNAL_TYPE_DATA) &&
499            (ObjDesc->Data.Handler == Handler))
500        {
501            if (PrevObjDesc)
502            {
503                PrevObjDesc->Common.NextObject = ObjDesc->Common.NextObject;
504            }
505            else
506            {
507                Node->Object = ObjDesc->Common.NextObject;
508            }
509
510            AcpiUtRemoveReference (ObjDesc);
511            return (AE_OK);
512        }
513
514        PrevObjDesc = ObjDesc;
515        ObjDesc = ObjDesc->Common.NextObject;
516    }
517
518    return (AE_NOT_FOUND);
519}
520
521
522/*******************************************************************************
523 *
524 * FUNCTION:    AcpiNsGetAttachedData
525 *
526 * PARAMETERS:
527 *
528 * RETURN:      Status
529 *
530 * DESCRIPTION:
531 *
532 ******************************************************************************/
533
534ACPI_STATUS
535AcpiNsGetAttachedData (
536    ACPI_NAMESPACE_NODE     *Node,
537    ACPI_OBJECT_HANDLER     Handler,
538    void                    **Data)
539{
540    ACPI_OPERAND_OBJECT     *ObjDesc;
541
542
543    ObjDesc = Node->Object;
544    while (ObjDesc)
545    {
546        if ((ObjDesc->Common.Type == INTERNAL_TYPE_DATA) &&
547            (ObjDesc->Data.Handler == Handler))
548        {
549            *Data = ObjDesc->Data.Pointer;
550            return (AE_OK);
551        }
552
553        ObjDesc = ObjDesc->Common.NextObject;
554    }
555
556    return (AE_NOT_FOUND);
557}
558
559
560