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