nsobject.c revision 151600
1/*******************************************************************************
2 *
3 * Module Name: nsobject - Utilities for objects attached to namespace
4 *                         table entries
5 *              $Revision: 90 $
6 *
7 ******************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2004, 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 <contrib/dev/acpica/acpi.h>
122#include <contrib/dev/acpica/acnamesp.h>
123
124
125#define _COMPONENT          ACPI_NAMESPACE
126        ACPI_MODULE_NAME    ("nsobject")
127
128
129/*******************************************************************************
130 *
131 * FUNCTION:    AcpiNsAttachObject
132 *
133 * PARAMETERS:  Node                - Parent Node
134 *              Object              - Object to be attached
135 *              Type                - Type of object, or ACPI_TYPE_ANY if not
136 *                                    known
137 *
138 * DESCRIPTION: Record the given object as the value associated with the
139 *              name whose ACPI_HANDLE is passed.  If Object is NULL
140 *              and Type is ACPI_TYPE_ANY, set the name as having no value.
141 *              Note: Future may require that the Node->Flags field be passed
142 *              as a parameter.
143 *
144 * MUTEX:       Assumes namespace is locked
145 *
146 ******************************************************************************/
147
148ACPI_STATUS
149AcpiNsAttachObject (
150    ACPI_NAMESPACE_NODE     *Node,
151    ACPI_OPERAND_OBJECT     *Object,
152    ACPI_OBJECT_TYPE        Type)
153{
154    ACPI_OPERAND_OBJECT     *ObjDesc;
155    ACPI_OPERAND_OBJECT     *LastObjDesc;
156    ACPI_OBJECT_TYPE        ObjectType = ACPI_TYPE_ANY;
157
158
159    ACPI_FUNCTION_TRACE ("NsAttachObject");
160
161
162    /*
163     * Parameter validation
164     */
165    if (!Node)
166    {
167        /* Invalid handle */
168
169        ACPI_REPORT_ERROR (("NsAttachObject: Null NamedObj handle\n"));
170        return_ACPI_STATUS (AE_BAD_PARAMETER);
171    }
172
173    if (!Object && (ACPI_TYPE_ANY != Type))
174    {
175        /* Null object */
176
177        ACPI_REPORT_ERROR (("NsAttachObject: Null object, but type not ACPI_TYPE_ANY\n"));
178        return_ACPI_STATUS (AE_BAD_PARAMETER);
179    }
180
181    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
182    {
183        /* Not a name handle */
184
185        ACPI_REPORT_ERROR (("NsAttachObject: Invalid handle %p [%s]\n",
186                Node, AcpiUtGetDescriptorName (Node)));
187        return_ACPI_STATUS (AE_BAD_PARAMETER);
188    }
189
190    /* Check if this object is already attached */
191
192    if (Node->Object == Object)
193    {
194        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj %p already installed in NameObj %p\n",
195            Object, Node));
196
197        return_ACPI_STATUS (AE_OK);
198    }
199
200    /* If null object, we will just install it */
201
202    if (!Object)
203    {
204        ObjDesc    = NULL;
205        ObjectType = ACPI_TYPE_ANY;
206    }
207
208    /*
209     * If the source object is a namespace Node with an attached object,
210     * we will use that (attached) object
211     */
212    else if ((ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED) &&
213            ((ACPI_NAMESPACE_NODE *) Object)->Object)
214    {
215        /*
216         * Value passed is a name handle and that name has a
217         * non-null value.  Use that name's value and type.
218         */
219        ObjDesc    = ((ACPI_NAMESPACE_NODE *) Object)->Object;
220        ObjectType = ((ACPI_NAMESPACE_NODE *) Object)->Type;
221    }
222
223    /*
224     * Otherwise, we will use the parameter object, but we must type
225     * it first
226     */
227    else
228    {
229        ObjDesc = (ACPI_OPERAND_OBJECT  *) Object;
230
231        /* Use the given type */
232
233        ObjectType = Type;
234    }
235
236    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n",
237        ObjDesc, Node, AcpiUtGetNodeName (Node)));
238
239    /* Detach an existing attached object if present */
240
241    if (Node->Object)
242    {
243        AcpiNsDetachObject (Node);
244    }
245
246    if (ObjDesc)
247    {
248        /*
249         * Must increment the new value's reference count
250         * (if it is an internal object)
251         */
252        AcpiUtAddReference (ObjDesc);
253
254        /*
255         * Handle objects with multiple descriptors - walk
256         * to the end of the descriptor list
257         */
258        LastObjDesc = ObjDesc;
259        while (LastObjDesc->Common.NextObject)
260        {
261            LastObjDesc = LastObjDesc->Common.NextObject;
262        }
263
264        /* Install the object at the front of the object list */
265
266        LastObjDesc->Common.NextObject = Node->Object;
267    }
268
269    Node->Type     = (UINT8) ObjectType;
270    Node->Object   = ObjDesc;
271
272    return_ACPI_STATUS (AE_OK);
273}
274
275
276/*******************************************************************************
277 *
278 * FUNCTION:    AcpiNsDetachObject
279 *
280 * PARAMETERS:  Node           - An node whose object will be detached
281 *
282 * RETURN:      None.
283 *
284 * DESCRIPTION: Detach/delete an object associated with a namespace node.
285 *              if the object is an allocated object, it is freed.
286 *              Otherwise, the field is simply cleared.
287 *
288 ******************************************************************************/
289
290void
291AcpiNsDetachObject (
292    ACPI_NAMESPACE_NODE     *Node)
293{
294    ACPI_OPERAND_OBJECT     *ObjDesc;
295
296
297    ACPI_FUNCTION_TRACE ("NsDetachObject");
298
299
300    ObjDesc = Node->Object;
301
302    if (!ObjDesc ||
303        (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_LOCAL_DATA))
304    {
305        return_VOID;
306    }
307
308    /* Clear the entry in all cases */
309
310    Node->Object = NULL;
311    if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND)
312    {
313        Node->Object = ObjDesc->Common.NextObject;
314        if (Node->Object &&
315           (ACPI_GET_OBJECT_TYPE (Node->Object) != ACPI_TYPE_LOCAL_DATA))
316        {
317            Node->Object = Node->Object->Common.NextObject;
318        }
319    }
320
321    /* Reset the node type to untyped */
322
323    Node->Type = ACPI_TYPE_ANY;
324
325    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n",
326        Node, AcpiUtGetNodeName (Node), ObjDesc));
327
328    /* Remove one reference on the object (and all subobjects) */
329
330    AcpiUtRemoveReference (ObjDesc);
331    return_VOID;
332}
333
334
335/*******************************************************************************
336 *
337 * FUNCTION:    AcpiNsGetAttachedObject
338 *
339 * PARAMETERS:  Node             - Parent Node to be examined
340 *
341 * RETURN:      Current value of the object field from the Node whose
342 *              handle is passed
343 *
344 * DESCRIPTION: Obtain the object attached to a namespace node.
345 *
346 ******************************************************************************/
347
348ACPI_OPERAND_OBJECT *
349AcpiNsGetAttachedObject (
350    ACPI_NAMESPACE_NODE     *Node)
351{
352    ACPI_FUNCTION_TRACE_PTR ("NsGetAttachedObject", Node);
353
354
355    if (!Node)
356    {
357        ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Null Node ptr\n"));
358        return_PTR (NULL);
359    }
360
361    if (!Node->Object ||
362            ((ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_OPERAND) &&
363             (ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_NAMED))  ||
364        (ACPI_GET_OBJECT_TYPE (Node->Object) == ACPI_TYPE_LOCAL_DATA))
365    {
366        return_PTR (NULL);
367    }
368
369    return_PTR (Node->Object);
370}
371
372
373/*******************************************************************************
374 *
375 * FUNCTION:    AcpiNsGetSecondaryObject
376 *
377 * PARAMETERS:  Node             - Parent Node to be examined
378 *
379 * RETURN:      Current value of the object field from the Node whose
380 *              handle is passed.
381 *
382 * DESCRIPTION: Obtain a secondary object associated with a namespace node.
383 *
384 ******************************************************************************/
385
386ACPI_OPERAND_OBJECT *
387AcpiNsGetSecondaryObject (
388    ACPI_OPERAND_OBJECT     *ObjDesc)
389{
390    ACPI_FUNCTION_TRACE_PTR ("NsGetSecondaryObject", ObjDesc);
391
392
393    if ((!ObjDesc)                                                ||
394        (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_LOCAL_DATA)  ||
395        (!ObjDesc->Common.NextObject)                             ||
396        (ACPI_GET_OBJECT_TYPE (ObjDesc->Common.NextObject) == ACPI_TYPE_LOCAL_DATA))
397    {
398        return_PTR (NULL);
399    }
400
401    return_PTR (ObjDesc->Common.NextObject);
402}
403
404
405/*******************************************************************************
406 *
407 * FUNCTION:    AcpiNsAttachData
408 *
409 * PARAMETERS:  Node            - Namespace node
410 *              Handler         - Handler to be associated with the data
411 *              Data            - Data to be attached
412 *
413 * RETURN:      Status
414 *
415 * DESCRIPTION: Low-level attach data.  Create and attach a Data object.
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    /* We only allow one attachment per handler */
431
432    PrevObjDesc = NULL;
433    ObjDesc = Node->Object;
434    while (ObjDesc)
435    {
436        if ((ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_LOCAL_DATA) &&
437            (ObjDesc->Data.Handler == Handler))
438        {
439            return (AE_ALREADY_EXISTS);
440        }
441
442        PrevObjDesc = ObjDesc;
443        ObjDesc = ObjDesc->Common.NextObject;
444    }
445
446    /* Create an internal object for the data */
447
448    DataDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_DATA);
449    if (!DataDesc)
450    {
451        return (AE_NO_MEMORY);
452    }
453
454    DataDesc->Data.Handler = Handler;
455    DataDesc->Data.Pointer = Data;
456
457    /* Install the data object */
458
459    if (PrevObjDesc)
460    {
461        PrevObjDesc->Common.NextObject = DataDesc;
462    }
463    else
464    {
465        Node->Object = DataDesc;
466    }
467
468    return (AE_OK);
469}
470
471
472/*******************************************************************************
473 *
474 * FUNCTION:    AcpiNsDetachData
475 *
476 * PARAMETERS:  Node            - Namespace node
477 *              Handler         - Handler associated with the data
478 *
479 * RETURN:      Status
480 *
481 * DESCRIPTION: Low-level detach data.  Delete the data node, but the caller
482 *              is responsible for the actual data.
483 *
484 ******************************************************************************/
485
486ACPI_STATUS
487AcpiNsDetachData (
488    ACPI_NAMESPACE_NODE     *Node,
489    ACPI_OBJECT_HANDLER     Handler)
490{
491    ACPI_OPERAND_OBJECT     *ObjDesc;
492    ACPI_OPERAND_OBJECT     *PrevObjDesc;
493
494
495    PrevObjDesc = NULL;
496    ObjDesc = Node->Object;
497    while (ObjDesc)
498    {
499        if ((ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_LOCAL_DATA) &&
500            (ObjDesc->Data.Handler == Handler))
501        {
502            if (PrevObjDesc)
503            {
504                PrevObjDesc->Common.NextObject = ObjDesc->Common.NextObject;
505            }
506            else
507            {
508                Node->Object = ObjDesc->Common.NextObject;
509            }
510
511            AcpiUtRemoveReference (ObjDesc);
512            return (AE_OK);
513        }
514
515        PrevObjDesc = ObjDesc;
516        ObjDesc = ObjDesc->Common.NextObject;
517    }
518
519    return (AE_NOT_FOUND);
520}
521
522
523/*******************************************************************************
524 *
525 * FUNCTION:    AcpiNsGetAttachedData
526 *
527 * PARAMETERS:  Node            - Namespace node
528 *              Handler         - Handler associated with the data
529 *              Data            - Where the data is returned
530 *
531 * RETURN:      Status
532 *
533 * DESCRIPTION: Low level interface to obtain data previously associated with
534 *              a namespace node.
535 *
536 ******************************************************************************/
537
538ACPI_STATUS
539AcpiNsGetAttachedData (
540    ACPI_NAMESPACE_NODE     *Node,
541    ACPI_OBJECT_HANDLER     Handler,
542    void                    **Data)
543{
544    ACPI_OPERAND_OBJECT     *ObjDesc;
545
546
547    ObjDesc = Node->Object;
548    while (ObjDesc)
549    {
550        if ((ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_LOCAL_DATA) &&
551            (ObjDesc->Data.Handler == Handler))
552        {
553            *Data = ObjDesc->Data.Pointer;
554            return (AE_OK);
555        }
556
557        ObjDesc = ObjDesc->Common.NextObject;
558    }
559
560    return (AE_NOT_FOUND);
561}
562
563
564