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          * Detach the object from any data objects (which are still held by
 269          * the namespace node)
 270          */
 271         if (ObjDesc->Common.NextObject &&
 272            ((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))
 273         {
 274            ObjDesc->Common.NextObject = NULL;
 275         }
 276     }
 277
 278     /* Reset the node type to untyped */
 279
 280     Node->Type = ACPI_TYPE_ANY;
 281
 282     ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n",
 283         Node, AcpiUtGetNodeName (Node), ObjDesc));
 284
 285     /* Remove one reference on the object (and all subobjects) */
 286
 287     AcpiUtRemoveReference (ObjDesc);
 288     return_VOID;
 289 }
 290
 291
 292 /*******************************************************************************
 293  *
 294  * FUNCTION:    AcpiNsGetAttachedObject
 295  *
 296  * PARAMETERS:  Node             - Namespace node
 297  *
 298  * RETURN:      Current value of the object field from the Node whose
 299  *              handle is passed
 300  *
 301  * DESCRIPTION: Obtain the object attached to a namespace node.
 302  *
 303  ******************************************************************************/
 304
 305 ACPI_OPERAND_OBJECT *
 306 AcpiNsGetAttachedObject (
 307     ACPI_NAMESPACE_NODE     *Node)
 308 {
 309     ACPI_FUNCTION_TRACE_PTR (NsGetAttachedObject, Node);
 310
 311
 312     if (!Node)
 313     {
 314         ACPI_WARNING ((AE_INFO, "Null Node ptr"));
 315         return_PTR (NULL);
 316     }
 317
 318     if (!Node->Object ||
 319             ((ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_OPERAND) &&
 320              (ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_NAMED))  ||
 321         ((Node->Object)->Common.Type == ACPI_TYPE_LOCAL_DATA))
 322     {
 323         return_PTR (NULL);
 324     }
 325
 326     return_PTR (Node->Object);
 327 }
 328
 329
 330 /*******************************************************************************
 331  *
 332  * FUNCTION:    AcpiNsGetSecondaryObject
 333  *
 334  * PARAMETERS:  Node             - Namespace node
 335  *
 336  * RETURN:      Current value of the object field from the Node whose
 337  *              handle is passed.
 338  *
 339  * DESCRIPTION: Obtain a secondary object associated with a namespace node.
 340  *
 341  ******************************************************************************/
 342
 343 ACPI_OPERAND_OBJECT *
 344 AcpiNsGetSecondaryObject (
 345     ACPI_OPERAND_OBJECT     *ObjDesc)
 346 {
 347     ACPI_FUNCTION_TRACE_PTR (NsGetSecondaryObject, ObjDesc);
 348
 349
 350     if ((!ObjDesc)                                     ||
 351         (ObjDesc->Common.Type== ACPI_TYPE_LOCAL_DATA)  ||
 352         (!ObjDesc->Common.NextObject)                  ||
 353         ((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))
 354     {
 355         return_PTR (NULL);
 356     }
 357
 358     return_PTR (ObjDesc->Common.NextObject);
 359 }
 360
 361
 362 /*******************************************************************************
 363  *
 364  * FUNCTION:    AcpiNsAttachData
 365  *
 366  * PARAMETERS:  Node            - Namespace node
 367  *              Handler         - Handler to be associated with the data
 368  *              Data            - Data to be attached
 369  *
 370  * RETURN:      Status
 371  *
 372  * DESCRIPTION: Low-level attach data. Create and attach a Data object.
 373  *
 374  ******************************************************************************/
 375
 376 ACPI_STATUS
 377 AcpiNsAttachData (
 378     ACPI_NAMESPACE_NODE     *Node,
 379     ACPI_OBJECT_HANDLER     Handler,
 380     void                    *Data)
 381 {
 382     ACPI_OPERAND_OBJECT     *PrevObjDesc;
 383     ACPI_OPERAND_OBJECT     *ObjDesc;
 384     ACPI_OPERAND_OBJECT     *DataDesc;
 385
 386
 387     /* We only allow one attachment per handler */
 388
 389     PrevObjDesc = NULL;
 390     ObjDesc = Node->Object;
 391     while (ObjDesc)
 392     {
 393         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 394             (ObjDesc->Data.Handler == Handler))
 395         {
 396             return (AE_ALREADY_EXISTS);
 397         }
 398
 399         PrevObjDesc = ObjDesc;
 400         ObjDesc = ObjDesc->Common.NextObject;
 401     }
 402
 403     /* Create an internal object for the data */
 404
 405     DataDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_DATA);
 406     if (!DataDesc)
 407     {
 408         return (AE_NO_MEMORY);
 409     }
 410
 411     DataDesc->Data.Handler = Handler;
 412     DataDesc->Data.Pointer = Data;
 413
 414     /* Install the data object */
 415
 416     if (PrevObjDesc)
 417     {
 418         PrevObjDesc->Common.NextObject = DataDesc;
 419     }
 420     else
 421     {
 422         Node->Object = DataDesc;
 423     }
 424
 425     return (AE_OK);
 426 }
 427
 428
 429 /*******************************************************************************
 430  *
 431  * FUNCTION:    AcpiNsDetachData
 432  *
 433  * PARAMETERS:  Node            - Namespace node
 434  *              Handler         - Handler associated with the data
 435  *
 436  * RETURN:      Status
 437  *
 438  * DESCRIPTION: Low-level detach data. Delete the data node, but the caller
 439  *              is responsible for the actual data.
 440  *
 441  ******************************************************************************/
 442
 443 ACPI_STATUS
 444 AcpiNsDetachData (
 445     ACPI_NAMESPACE_NODE     *Node,
 446     ACPI_OBJECT_HANDLER     Handler)
 447 {
 448     ACPI_OPERAND_OBJECT     *ObjDesc;
 449     ACPI_OPERAND_OBJECT     *PrevObjDesc;
 450
 451
 452     PrevObjDesc = NULL;
 453     ObjDesc = Node->Object;
 454     while (ObjDesc)
 455     {
 456         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 457             (ObjDesc->Data.Handler == Handler))
 458         {
 459             if (PrevObjDesc)
 460             {
 461                 PrevObjDesc->Common.NextObject = ObjDesc->Common.NextObject;
 462             }
 463             else
 464             {
 465                 Node->Object = ObjDesc->Common.NextObject;
 466             }
 467
 468             AcpiUtRemoveReference (ObjDesc);
 469             return (AE_OK);
 470         }
 471
 472         PrevObjDesc = ObjDesc;
 473         ObjDesc = ObjDesc->Common.NextObject;
 474     }
 475
 476     return (AE_NOT_FOUND);
 477 }
 478
 479
 480 /*******************************************************************************
 481  *
 482  * FUNCTION:    AcpiNsGetAttachedData
 483  *
 484  * PARAMETERS:  Node            - Namespace node
 485  *              Handler         - Handler associated with the data
 486  *              Data            - Where the data is returned
 487  *
 488  * RETURN:      Status
 489  *
 490  * DESCRIPTION: Low level interface to obtain data previously associated with
 491  *              a namespace node.
 492  *
 493  ******************************************************************************/
 494
 495 ACPI_STATUS
 496 AcpiNsGetAttachedData (
 497     ACPI_NAMESPACE_NODE     *Node,
 498     ACPI_OBJECT_HANDLER     Handler,
 499     void                    **Data)
 500 {
 501     ACPI_OPERAND_OBJECT     *ObjDesc;
 502
 503
 504     ObjDesc = Node->Object;
 505     while (ObjDesc)
 506     {
 507         if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
 508             (ObjDesc->Data.Handler == Handler))
 509         {
 510             *Data = ObjDesc->Data.Pointer;
 511             return (AE_OK);
 512         }
 513
 514         ObjDesc = ObjDesc->Common.NextObject;
 515     }
 516
 517     return (AE_NOT_FOUND);
 518 }