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 } 519