sys/contrib/dev/acpica/source/components/namespace/nsobject.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: nsobject - Utilities for objects attached to namespace
   4  *                         table entries
   5  *
   6  ******************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2014, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45
  46 #define __NSOBJECT_C__
  47
  48 #include "acpi.h"
  49 #include "accommon.h"
  50 #include "acnamesp.h"
  51
  52
  53 #define _COMPONENT          ACPI_NAMESPACE
  54         ACPI_MODULE_NAME    ("nsobject")
  55
  56
  57 /*******************************************************************************
  58  *
  59  * FUNCTION:    AcpiNsAttachObject
  60  *
  61  * PARAMETERS:  Node                - Parent Node
  62  *              Object              - Object to be attached
  63  *              Type                - Type of object, or ACPI_TYPE_ANY if not
  64  *                                    known
  65  *
  66  * RETURN:      Status
  67  *
  68  * DESCRIPTION: Record the given object as the value associated with the
  69  *              name whose ACPI_HANDLE is passed. If Object is NULL
  70  *              and Type is ACPI_TYPE_ANY, set the name as having no value.
  71  *              Note: Future may require that the Node->Flags field be passed
  72  *              as a parameter.
  73  *
  74  * MUTEX:       Assumes namespace is locked
  75  *
  76  ******************************************************************************/
  77
  78 ACPI_STATUS
  79 AcpiNsAttachObject (
  80     ACPI_NAMESPACE_NODE     *Node,
  81     ACPI_OPERAND_OBJECT     *Object,
  82     ACPI_OBJECT_TYPE        Type)
  83 {
  84     ACPI_OPERAND_OBJECT     *ObjDesc;
  85     ACPI_OPERAND_OBJECT     *LastObjDesc;
  86     ACPI_OBJECT_TYPE        ObjectType = ACPI_TYPE_ANY;
  87
  88
  89     ACPI_FUNCTION_TRACE (NsAttachObject);
  90
  91
  92     /*
  93      * Parameter validation
  94      */
  95     if (!Node)
  96     {
  97         /* Invalid handle */
  98
  99         ACPI_ERROR ((AE_INFO, "Null NamedObj handle"));
 100         return_ACPI_STATUS (AE_BAD_PARAMETER);
 101     }
 102
 103     if (!Object && (ACPI_TYPE_ANY != Type))
 104     {
 105         /* Null object */
 106
 107         ACPI_ERROR ((AE_INFO,
 108             "Null object, but type not ACPI_TYPE_ANY"));
 109         return_ACPI_STATUS (AE_BAD_PARAMETER);
 110     }
 111
 112     if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
 113     {
 114         /* Not a name handle */
 115
 116         ACPI_ERROR ((AE_INFO, "Invalid handle %p [%s]",
 117             Node, AcpiUtGetDescriptorName (Node)));
 118         return_ACPI_STATUS (AE_BAD_PARAMETER);
 119     }
 120
 121     /* Check if this object is already attached */
 122
 123     if (Node->Object == Object)
 124     {
 125         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 126             "Obj %p already installed in NameObj %p\n",
 127             Object, Node));
 128
 129         return_ACPI_STATUS (AE_OK);
 130     }
 131
 132     /* If null object, we will just install it */
 133
 134     if (!Object)
 135     {
 136         ObjDesc    = NULL;
 137         ObjectType = ACPI_TYPE_ANY;
 138     }
 139
 140     /*
 141      * If the source object is a namespace Node with an attached object,
 142      * we will use that (attached) object
 143      */
 144     else if ((ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED) &&
 145             ((ACPI_NAMESPACE_NODE *) Object)->Object)
 146     {
 147         /*
 148          * Value passed is a name handle and that name has a
 149          * non-null value. Use that name's value and type.
 150          */
 151         ObjDesc    = ((ACPI_NAMESPACE_NODE *) Object)->Object;
 152         ObjectType = ((ACPI_NAMESPACE_NODE *) Object)->Type;
 153     }
 154
 155     /*
 156      * Otherwise, we will use the parameter object, but we must type
 157      * it first
 158      */
 159     else
 160     {
 161         ObjDesc = (ACPI_OPERAND_OBJECT  *) Object;
 162
 163         /* Use the given type */
 164
 165         ObjectType = Type;
 166     }
 167
 168     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n",
 169         ObjDesc, Node, AcpiUtGetNodeName (Node)));
 170
 171     /* Detach an existing attached object if present */
 172
 173     if (Node->Object)
 174     {
 175         AcpiNsDetachObject (Node);
 176     }
 177
 178     if (ObjDesc)
 179     {
 180         /*
 181          * Must increment the new value's reference count
 182          * (if it is an internal object)
 183          */
 184         AcpiUtAddReference (ObjDesc);
 185
 186         /*
 187          * Handle objects with multiple descriptors - walk
 188          * to the end of the descriptor list
 189          */
 190         LastObjDesc = ObjDesc;
 191         while (LastObjDesc->Common.NextObject)
 192         {
 193             LastObjDesc = LastObjDesc->Common.NextObject;
 194         }
 195
 196         /* Install the object at the front of the object list */
 197
 198         LastObjDesc->Common.NextObject = Node->Object;
 199     }
 200
 201     Node->Type     = (UINT8) ObjectType;
 202     Node->Object   = ObjDesc;
 203
 204     return_ACPI_STATUS (AE_OK);
 205 }
 206
 207
 208 /*******************************************************************************
 209  *
 210  * FUNCTION:    AcpiNsDetachObject
 211  *
 212  * PARAMETERS:  Node           - A Namespace node whose object will be detached
 213  *
 214  * RETURN:      None.
 215  *
 216  * DESCRIPTION: Detach/delete an object associated with a namespace node.
 217  *              if the object is an allocated object, it is freed.
 218  *              Otherwise, the field is simply cleared.
 219  *
 220  ******************************************************************************/
 221
 222 void
 223 AcpiNsDetachObject (
 224     ACPI_NAMESPACE_NODE     *Node)
 225 {
 226     ACPI_OPERAND_OBJECT     *ObjDesc;
 227
 228
 229     ACPI_FUNCTION_TRACE (NsDetachObject);
 230
 231
 232     ObjDesc = Node->Object;
 233
 234     if (!ObjDesc ||
 235         (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA))
 236     {
 237         return_VOID;
 238     }
 239
 240     if (Node->Flags & ANOBJ_ALLOCATED_BUFFER)
 241     {
 242         /* Free the dynamic aml buffer */
 243
 244         if (ObjDesc->Common.Type == ACPI_TYPE_METHOD)
 245         {
 246             ACPI_FREE (ObjDesc->Method.AmlStart);
 247         }
 248     }
 249
 250     /* Clear the Node entry in all cases */
 251
 252     Node->Object = NULL;
 253     if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND)
 254     {
 255         /* Unlink object from front of possible object list */
 256
 257         Node->Object = ObjDesc->Common.NextObject;
 258
 259         /* Handle possible 2-descriptor object */
 260
 261         if (Node->Object &&
 262            (Node->Object->Common.Type != ACPI_TYPE_LOCAL_DATA))
 263         {
 264             Node->Object = Node->Object->Common.NextObject;
 265         }
 266     }
 267
 268     /* Reset the node type to untyped */
 269
 270     Node->Type = ACPI_TYPE_ANY;
 271
 272     ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n",
 273         Node, AcpiUtGetNodeName (Node), ObjDesc));
 274
 275     /* Remove one reference on the object (and all subobjects) */
 276
 277     AcpiUtRemoveReference (ObjDesc);
 278     return_VOID;
 279 }
 280
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    AcpiNsGetAttachedObject
 285  *
 286  * PARAMETERS:  Node             - Namespace node
 287  *
 288  * RETURN:      Current value of the object field from the Node whose
 289  *              handle is passed
 290  *
 291  * DESCRIPTION: Obtain the object attached to a namespace node.
 292  *
 293  ******************************************************************************/
 294
 295 ACPI_OPERAND_OBJECT *
 296 AcpiNsGetAttachedObject (
 297     ACPI_NAMESPACE_NODE     *Node)
 298 {
 299     ACPI_FUNCTION_TRACE_PTR (NsGetAttachedObject, Node);
 300
 301
 302     if (!Node)
 303     {
 304         ACPI_WARNING ((AE_INFO, "Null Node ptr"));
 305         return_PTR (NULL);
 306     }
 307
 308     if (!Node->Object ||
 309             ((ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_OPERAND) &&
 310              (ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_NAMED))  ||
 311         ((Node->Object)->Common.Type == ACPI_TYPE_LOCAL_DATA))
 312     {
 313         return_PTR (NULL);
 314     }
 315
 316     return_PTR (Node->Object);
 317 }
 318
 319
 320 /*******************************************************************************
 321  *
 322  * FUNCTION:    AcpiNsGetSecondaryObject
 323  *
 324  * PARAMETERS:  Node             - Namespace node
 325  *
 326  * RETURN:      Current value of the object field from the Node whose
 327  *              handle is passed.
 328  *
 329  * DESCRIPTION: Obtain a secondary object associated with a namespace node.
 330  *
 331  ******************************************************************************/
 332
 333 ACPI_OPERAND_OBJECT *
 334 AcpiNsGetSecondaryObject (
 335     ACPI_OPERAND_OBJECT     *ObjDesc)
 336 {
 337     ACPI_FUNCTION_TRACE_PTR (NsGetSecondaryObject, ObjDesc);
 338
 339
 340     if ((!ObjDesc)                                     ||
 341         (ObjDesc->Common.Type== ACPI_TYPE_LOCAL_DATA)  ||
 342         (!ObjDesc->Common.NextObject)                  ||
 343         ((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))
 344     {
 345         return_PTR (NULL);
 346     }
 347
 348     return_PTR (ObjDesc->Common.NextObject);
 349 }
 350
 351
 352 /*******************************************************************************
 353  *
 354  * FUNCTION:    AcpiNsAttachData
 355  *
 356  * PARAMETERS:  Node            - Namespace node
 357  *              Handler         - Handler to be associated with the data
 358  *              Data            - Data to be attached
 359  *
 360  * RETURN:      Status
 361  *
 362  * DESCRIPTION: Low-level attach data. Create and attach a Data object.
 363  *
 364  ******************************************************************************/
 365
 366 ACPI_STATUS
 367 AcpiNsAttachData (
 368     ACPI_NAMESPACE_NODE     *Node,
 369     ACPI_OBJECT_HANDLER     Handler,
 370     void                    *Data)
 371 {
 372     ACPI_OPERAND_OBJECT     *PrevObjDesc;
 373     ACPI_OPERAND_OBJECT     *ObjDesc;
 374     ACPI_OPERAND_OBJECT     *DataDesc;
 375
 376
 377     /* We only allow one attachment per handler */
 378
 379     PrevObjDesc = NULL;
 380     ObjDesc = Node->Object;
 381     while (ObjDesc)
 382     {
 383         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 384             (ObjDesc->Data.Handler == Handler))
 385         {
 386             return (AE_ALREADY_EXISTS);
 387         }
 388
 389         PrevObjDesc = ObjDesc;
 390         ObjDesc = ObjDesc->Common.NextObject;
 391     }
 392
 393     /* Create an internal object for the data */
 394
 395     DataDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_DATA);
 396     if (!DataDesc)
 397     {
 398         return (AE_NO_MEMORY);
 399     }
 400
 401     DataDesc->Data.Handler = Handler;
 402     DataDesc->Data.Pointer = Data;
 403
 404     /* Install the data object */
 405
 406     if (PrevObjDesc)
 407     {
 408         PrevObjDesc->Common.NextObject = DataDesc;
 409     }
 410     else
 411     {
 412         Node->Object = DataDesc;
 413     }
 414
 415     return (AE_OK);
 416 }
 417
 418
 419 /*******************************************************************************
 420  *
 421  * FUNCTION:    AcpiNsDetachData
 422  *
 423  * PARAMETERS:  Node            - Namespace node
 424  *              Handler         - Handler associated with the data
 425  *
 426  * RETURN:      Status
 427  *
 428  * DESCRIPTION: Low-level detach data. Delete the data node, but the caller
 429  *              is responsible for the actual data.
 430  *
 431  ******************************************************************************/
 432
 433 ACPI_STATUS
 434 AcpiNsDetachData (
 435     ACPI_NAMESPACE_NODE     *Node,
 436     ACPI_OBJECT_HANDLER     Handler)
 437 {
 438     ACPI_OPERAND_OBJECT     *ObjDesc;
 439     ACPI_OPERAND_OBJECT     *PrevObjDesc;
 440
 441
 442     PrevObjDesc = NULL;
 443     ObjDesc = Node->Object;
 444     while (ObjDesc)
 445     {
 446         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 447             (ObjDesc->Data.Handler == Handler))
 448         {
 449             if (PrevObjDesc)
 450             {
 451                 PrevObjDesc->Common.NextObject = ObjDesc->Common.NextObject;
 452             }
 453             else
 454             {
 455                 Node->Object = ObjDesc->Common.NextObject;
 456             }
 457
 458             AcpiUtRemoveReference (ObjDesc);
 459             return (AE_OK);
 460         }
 461
 462         PrevObjDesc = ObjDesc;
 463         ObjDesc = ObjDesc->Common.NextObject;
 464     }
 465
 466     return (AE_NOT_FOUND);
 467 }
 468
 469
 470 /*******************************************************************************
 471  *
 472  * FUNCTION:    AcpiNsGetAttachedData
 473  *
 474  * PARAMETERS:  Node            - Namespace node
 475  *              Handler         - Handler associated with the data
 476  *              Data            - Where the data is returned
 477  *
 478  * RETURN:      Status
 479  *
 480  * DESCRIPTION: Low level interface to obtain data previously associated with
 481  *              a namespace node.
 482  *
 483  ******************************************************************************/
 484
 485 ACPI_STATUS
 486 AcpiNsGetAttachedData (
 487     ACPI_NAMESPACE_NODE     *Node,
 488     ACPI_OBJECT_HANDLER     Handler,
 489     void                    **Data)
 490 {
 491     ACPI_OPERAND_OBJECT     *ObjDesc;
 492
 493
 494     ObjDesc = Node->Object;
 495     while (ObjDesc)
 496     {
 497         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 498             (ObjDesc->Data.Handler == Handler))
 499         {
 500             *Data = ObjDesc->Data.Pointer;
 501             return (AE_OK);
 502         }
 503
 504         ObjDesc = ObjDesc->Common.NextObject;
 505     }
 506
 507     return (AE_NOT_FOUND);
 508 }