1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /******************************************************************************* 3 * 4 * Module Name: nsobject - Utilities for objects attached to namespace 5 * table entries 6 * 7 ******************************************************************************/ 8 9 #include <acpi/acpi.h> 10 #include "accommon.h" 11 #include "acnamesp.h" 12 13 #define _COMPONENT ACPI_NAMESPACE 14 ACPI_MODULE_NAME("nsobject") 15 16 /******************************************************************************* 17 * 18 * FUNCTION: acpi_ns_attach_object 19 * 20 * PARAMETERS: node - Parent Node 21 * object - Object to be attached 22 * type - Type of object, or ACPI_TYPE_ANY if not 23 * known 24 * 25 * RETURN: Status 26 * 27 * DESCRIPTION: Record the given object as the value associated with the 28 * name whose acpi_handle is passed. If Object is NULL 29 * and Type is ACPI_TYPE_ANY, set the name as having no value. 30 * Note: Future may require that the Node->Flags field be passed 31 * as a parameter. 32 * 33 * MUTEX: Assumes namespace is locked 34 * 35 ******************************************************************************/ 36 acpi_status acpi_ns_attach_object(struct acpi_namespace_node * node,union acpi_operand_object * object,acpi_object_type type)37 acpi_ns_attach_object(struct acpi_namespace_node *node, 38 union acpi_operand_object *object, acpi_object_type type) 39 { 40 union acpi_operand_object *obj_desc; 41 union acpi_operand_object *last_obj_desc; 42 acpi_object_type object_type = ACPI_TYPE_ANY; 43 44 ACPI_FUNCTION_TRACE(ns_attach_object); 45 46 /* 47 * Parameter validation 48 */ 49 if (!node) { 50 51 /* Invalid handle */ 52 53 ACPI_ERROR((AE_INFO, "Null NamedObj handle")); 54 return_ACPI_STATUS(AE_BAD_PARAMETER); 55 } 56 57 if (!object && (ACPI_TYPE_ANY != type)) { 58 59 /* Null object */ 60 61 ACPI_ERROR((AE_INFO, 62 "Null object, but type not ACPI_TYPE_ANY")); 63 return_ACPI_STATUS(AE_BAD_PARAMETER); 64 } 65 66 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) { 67 68 /* Not a name handle */ 69 70 ACPI_ERROR((AE_INFO, "Invalid handle %p [%s]", 71 node, acpi_ut_get_descriptor_name(node))); 72 return_ACPI_STATUS(AE_BAD_PARAMETER); 73 } 74 75 /* Check if this object is already attached */ 76 77 if (node->object == object) { 78 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 79 "Obj %p already installed in NameObj %p\n", 80 object, node)); 81 82 return_ACPI_STATUS(AE_OK); 83 } 84 85 /* If null object, we will just install it */ 86 87 if (!object) { 88 obj_desc = NULL; 89 object_type = ACPI_TYPE_ANY; 90 } 91 92 /* 93 * If the source object is a namespace Node with an attached object, 94 * we will use that (attached) object 95 */ 96 else if ((ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED) && 97 ((struct acpi_namespace_node *)object)->object) { 98 /* 99 * Value passed is a name handle and that name has a 100 * non-null value. Use that name's value and type. 101 */ 102 obj_desc = ((struct acpi_namespace_node *)object)->object; 103 object_type = ((struct acpi_namespace_node *)object)->type; 104 } 105 106 /* 107 * Otherwise, we will use the parameter object, but we must type 108 * it first 109 */ 110 else { 111 obj_desc = (union acpi_operand_object *)object; 112 113 /* Use the given type */ 114 115 object_type = type; 116 } 117 118 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n", 119 obj_desc, node, acpi_ut_get_node_name(node))); 120 121 /* Detach an existing attached object if present */ 122 123 if (node->object) { 124 acpi_ns_detach_object(node); 125 } 126 127 if (obj_desc) { 128 /* 129 * Must increment the new value's reference count 130 * (if it is an internal object) 131 */ 132 acpi_ut_add_reference(obj_desc); 133 134 /* 135 * Handle objects with multiple descriptors - walk 136 * to the end of the descriptor list 137 */ 138 last_obj_desc = obj_desc; 139 while (last_obj_desc->common.next_object) { 140 last_obj_desc = last_obj_desc->common.next_object; 141 } 142 143 /* Install the object at the front of the object list */ 144 145 last_obj_desc->common.next_object = node->object; 146 } 147 148 node->type = (u8) object_type; 149 node->object = obj_desc; 150 151 return_ACPI_STATUS(AE_OK); 152 } 153 154 /******************************************************************************* 155 * 156 * FUNCTION: acpi_ns_detach_object 157 * 158 * PARAMETERS: node - A Namespace node whose object will be detached 159 * 160 * RETURN: None. 161 * 162 * DESCRIPTION: Detach/delete an object associated with a namespace node. 163 * if the object is an allocated object, it is freed. 164 * Otherwise, the field is simply cleared. 165 * 166 ******************************************************************************/ 167 acpi_ns_detach_object(struct acpi_namespace_node * node)168 void acpi_ns_detach_object(struct acpi_namespace_node *node) 169 { 170 union acpi_operand_object *obj_desc; 171 172 ACPI_FUNCTION_TRACE(ns_detach_object); 173 174 obj_desc = node->object; 175 176 if (!obj_desc || (obj_desc->common.type == ACPI_TYPE_LOCAL_DATA)) { 177 return_VOID; 178 } 179 180 if (node->flags & ANOBJ_ALLOCATED_BUFFER) { 181 182 /* Free the dynamic aml buffer */ 183 184 if (obj_desc->common.type == ACPI_TYPE_METHOD) { 185 ACPI_FREE(obj_desc->method.aml_start); 186 } 187 } 188 189 if (obj_desc->common.type == ACPI_TYPE_REGION) { 190 acpi_ut_remove_address_range(obj_desc->region.space_id, node); 191 } 192 193 /* Clear the Node entry in all cases */ 194 195 node->object = NULL; 196 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) == ACPI_DESC_TYPE_OPERAND) { 197 198 /* Unlink object from front of possible object list */ 199 200 node->object = obj_desc->common.next_object; 201 202 /* Handle possible 2-descriptor object */ 203 204 if (node->object && 205 (node->object->common.type != ACPI_TYPE_LOCAL_DATA)) { 206 node->object = node->object->common.next_object; 207 } 208 209 /* 210 * Detach the object from any data objects (which are still held by 211 * the namespace node) 212 */ 213 if (obj_desc->common.next_object && 214 ((obj_desc->common.next_object)->common.type == 215 ACPI_TYPE_LOCAL_DATA)) { 216 obj_desc->common.next_object = NULL; 217 } 218 } 219 220 /* Reset the node type to untyped */ 221 222 node->type = ACPI_TYPE_ANY; 223 224 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n", 225 node, acpi_ut_get_node_name(node), obj_desc)); 226 227 /* Remove one reference on the object (and all subobjects) */ 228 229 acpi_ut_remove_reference(obj_desc); 230 return_VOID; 231 } 232 233 /******************************************************************************* 234 * 235 * FUNCTION: acpi_ns_get_attached_object 236 * 237 * PARAMETERS: node - Namespace node 238 * 239 * RETURN: Current value of the object field from the Node whose 240 * handle is passed 241 * 242 * DESCRIPTION: Obtain the object attached to a namespace node. 243 * 244 ******************************************************************************/ 245 acpi_ns_get_attached_object(struct acpi_namespace_node * node)246 union acpi_operand_object *acpi_ns_get_attached_object(struct 247 acpi_namespace_node 248 *node) 249 { 250 ACPI_FUNCTION_TRACE_PTR(ns_get_attached_object, node); 251 252 if (!node) { 253 ACPI_WARNING((AE_INFO, "Null Node ptr")); 254 return_PTR(NULL); 255 } 256 257 if (!node->object || 258 ((ACPI_GET_DESCRIPTOR_TYPE(node->object) != ACPI_DESC_TYPE_OPERAND) 259 && (ACPI_GET_DESCRIPTOR_TYPE(node->object) != 260 ACPI_DESC_TYPE_NAMED)) 261 || ((node->object)->common.type == ACPI_TYPE_LOCAL_DATA)) { 262 return_PTR(NULL); 263 } 264 265 return_PTR(node->object); 266 } 267 268 /******************************************************************************* 269 * 270 * FUNCTION: acpi_ns_get_secondary_object 271 * 272 * PARAMETERS: node - Namespace node 273 * 274 * RETURN: Current value of the object field from the Node whose 275 * handle is passed. 276 * 277 * DESCRIPTION: Obtain a secondary object associated with a namespace node. 278 * 279 ******************************************************************************/ 280 acpi_ns_get_secondary_object(union acpi_operand_object * obj_desc)281 union acpi_operand_object *acpi_ns_get_secondary_object(union 282 acpi_operand_object 283 *obj_desc) 284 { 285 ACPI_FUNCTION_TRACE_PTR(ns_get_secondary_object, obj_desc); 286 287 if ((!obj_desc) || 288 (obj_desc->common.type == ACPI_TYPE_LOCAL_DATA) || 289 (!obj_desc->common.next_object) || 290 ((obj_desc->common.next_object)->common.type == 291 ACPI_TYPE_LOCAL_DATA)) { 292 return_PTR(NULL); 293 } 294 295 return_PTR(obj_desc->common.next_object); 296 } 297 298 /******************************************************************************* 299 * 300 * FUNCTION: acpi_ns_attach_data 301 * 302 * PARAMETERS: node - Namespace node 303 * handler - Handler to be associated with the data 304 * data - Data to be attached 305 * 306 * RETURN: Status 307 * 308 * DESCRIPTION: Low-level attach data. Create and attach a Data object. 309 * 310 ******************************************************************************/ 311 312 acpi_status acpi_ns_attach_data(struct acpi_namespace_node * node,acpi_object_handler handler,void * data)313 acpi_ns_attach_data(struct acpi_namespace_node *node, 314 acpi_object_handler handler, void *data) 315 { 316 union acpi_operand_object *prev_obj_desc; 317 union acpi_operand_object *obj_desc; 318 union acpi_operand_object *data_desc; 319 320 /* We only allow one attachment per handler */ 321 322 prev_obj_desc = NULL; 323 obj_desc = node->object; 324 while (obj_desc) { 325 if ((obj_desc->common.type == ACPI_TYPE_LOCAL_DATA) && 326 (obj_desc->data.handler == handler)) { 327 return (AE_ALREADY_EXISTS); 328 } 329 330 prev_obj_desc = obj_desc; 331 obj_desc = obj_desc->common.next_object; 332 } 333 334 /* Create an internal object for the data */ 335 336 data_desc = acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_DATA); 337 if (!data_desc) { 338 return (AE_NO_MEMORY); 339 } 340 341 data_desc->data.handler = handler; 342 data_desc->data.pointer = data; 343 344 /* Install the data object */ 345 346 if (prev_obj_desc) { 347 prev_obj_desc->common.next_object = data_desc; 348 } else { 349 node->object = data_desc; 350 } 351 352 return (AE_OK); 353 } 354 355 /******************************************************************************* 356 * 357 * FUNCTION: acpi_ns_detach_data 358 * 359 * PARAMETERS: node - Namespace node 360 * handler - Handler associated with the data 361 * 362 * RETURN: Status 363 * 364 * DESCRIPTION: Low-level detach data. Delete the data node, but the caller 365 * is responsible for the actual data. 366 * 367 ******************************************************************************/ 368 369 acpi_status acpi_ns_detach_data(struct acpi_namespace_node * node,acpi_object_handler handler)370 acpi_ns_detach_data(struct acpi_namespace_node *node, 371 acpi_object_handler handler) 372 { 373 union acpi_operand_object *obj_desc; 374 union acpi_operand_object *prev_obj_desc; 375 376 prev_obj_desc = NULL; 377 obj_desc = node->object; 378 while (obj_desc) { 379 if ((obj_desc->common.type == ACPI_TYPE_LOCAL_DATA) && 380 (obj_desc->data.handler == handler)) { 381 if (prev_obj_desc) { 382 prev_obj_desc->common.next_object = 383 obj_desc->common.next_object; 384 } else { 385 node->object = obj_desc->common.next_object; 386 } 387 388 acpi_ut_remove_reference(obj_desc); 389 return (AE_OK); 390 } 391 392 prev_obj_desc = obj_desc; 393 obj_desc = obj_desc->common.next_object; 394 } 395 396 return (AE_NOT_FOUND); 397 } 398 399 /******************************************************************************* 400 * 401 * FUNCTION: acpi_ns_get_attached_data 402 * 403 * PARAMETERS: node - Namespace node 404 * handler - Handler associated with the data 405 * data - Where the data is returned 406 * 407 * RETURN: Status 408 * 409 * DESCRIPTION: Low level interface to obtain data previously associated with 410 * a namespace node. 411 * 412 ******************************************************************************/ 413 414 acpi_status acpi_ns_get_attached_data(struct acpi_namespace_node * node,acpi_object_handler handler,void ** data)415 acpi_ns_get_attached_data(struct acpi_namespace_node *node, 416 acpi_object_handler handler, void **data) 417 { 418 union acpi_operand_object *obj_desc; 419 420 obj_desc = node->object; 421 while (obj_desc) { 422 if ((obj_desc->common.type == ACPI_TYPE_LOCAL_DATA) && 423 (obj_desc->data.handler == handler)) { 424 *data = obj_desc->data.pointer; 425 return (AE_OK); 426 } 427 428 obj_desc = obj_desc->common.next_object; 429 } 430 431 return (AE_NOT_FOUND); 432 } 433