1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: excreate - Named object creation 5 * 6 * Copyright (C) 2000 - 2020, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "acinterp.h" 13 #include "amlcode.h" 14 #include "acnamesp.h" 15 16 #define _COMPONENT ACPI_EXECUTER 17 ACPI_MODULE_NAME("excreate") 18 /******************************************************************************* 19 * 20 * FUNCTION: acpi_ex_create_alias 21 * 22 * PARAMETERS: walk_state - Current state, contains operands 23 * 24 * RETURN: Status 25 * 26 * DESCRIPTION: Create a new named alias 27 * 28 ******************************************************************************/ 29 acpi_status acpi_ex_create_alias(struct acpi_walk_state *walk_state) 30 { 31 struct acpi_namespace_node *target_node; 32 struct acpi_namespace_node *alias_node; 33 acpi_status status = AE_OK; 34 35 ACPI_FUNCTION_TRACE(ex_create_alias); 36 37 /* Get the source/alias operands (both namespace nodes) */ 38 39 alias_node = (struct acpi_namespace_node *)walk_state->operands[0]; 40 target_node = (struct acpi_namespace_node *)walk_state->operands[1]; 41 42 if ((target_node->type == ACPI_TYPE_LOCAL_ALIAS) || 43 (target_node->type == ACPI_TYPE_LOCAL_METHOD_ALIAS)) { 44 /* 45 * Dereference an existing alias so that we don't create a chain 46 * of aliases. With this code, we guarantee that an alias is 47 * always exactly one level of indirection away from the 48 * actual aliased name. 49 */ 50 target_node = 51 ACPI_CAST_PTR(struct acpi_namespace_node, 52 target_node->object); 53 } 54 55 /* Ensure that the target node is valid */ 56 57 if (!target_node) { 58 return_ACPI_STATUS(AE_NULL_OBJECT); 59 } 60 61 /* Construct the alias object (a namespace node) */ 62 63 switch (target_node->type) { 64 case ACPI_TYPE_METHOD: 65 /* 66 * Control method aliases need to be differentiated with 67 * a special type 68 */ 69 alias_node->type = ACPI_TYPE_LOCAL_METHOD_ALIAS; 70 break; 71 72 default: 73 /* 74 * All other object types. 75 * 76 * The new alias has the type ALIAS and points to the original 77 * NS node, not the object itself. 78 */ 79 alias_node->type = ACPI_TYPE_LOCAL_ALIAS; 80 alias_node->object = 81 ACPI_CAST_PTR(union acpi_operand_object, target_node); 82 break; 83 } 84 85 /* Since both operands are Nodes, we don't need to delete them */ 86 87 alias_node->object = 88 ACPI_CAST_PTR(union acpi_operand_object, target_node); 89 return_ACPI_STATUS(status); 90 } 91 92 /******************************************************************************* 93 * 94 * FUNCTION: acpi_ex_create_event 95 * 96 * PARAMETERS: walk_state - Current state 97 * 98 * RETURN: Status 99 * 100 * DESCRIPTION: Create a new event object 101 * 102 ******************************************************************************/ 103 104 acpi_status acpi_ex_create_event(struct acpi_walk_state *walk_state) 105 { 106 acpi_status status; 107 union acpi_operand_object *obj_desc; 108 109 ACPI_FUNCTION_TRACE(ex_create_event); 110 111 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_EVENT); 112 if (!obj_desc) { 113 status = AE_NO_MEMORY; 114 goto cleanup; 115 } 116 117 /* 118 * Create the actual OS semaphore, with zero initial units -- meaning 119 * that the event is created in an unsignalled state 120 */ 121 status = acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, 122 &obj_desc->event.os_semaphore); 123 if (ACPI_FAILURE(status)) { 124 goto cleanup; 125 } 126 127 /* Attach object to the Node */ 128 129 status = acpi_ns_attach_object((struct acpi_namespace_node *) 130 walk_state->operands[0], obj_desc, 131 ACPI_TYPE_EVENT); 132 133 cleanup: 134 /* 135 * Remove local reference to the object (on error, will cause deletion 136 * of both object and semaphore if present.) 137 */ 138 acpi_ut_remove_reference(obj_desc); 139 return_ACPI_STATUS(status); 140 } 141 142 /******************************************************************************* 143 * 144 * FUNCTION: acpi_ex_create_mutex 145 * 146 * PARAMETERS: walk_state - Current state 147 * 148 * RETURN: Status 149 * 150 * DESCRIPTION: Create a new mutex object 151 * 152 * Mutex (Name[0], sync_level[1]) 153 * 154 ******************************************************************************/ 155 156 acpi_status acpi_ex_create_mutex(struct acpi_walk_state *walk_state) 157 { 158 acpi_status status = AE_OK; 159 union acpi_operand_object *obj_desc; 160 161 ACPI_FUNCTION_TRACE_PTR(ex_create_mutex, ACPI_WALK_OPERANDS); 162 163 /* Create the new mutex object */ 164 165 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX); 166 if (!obj_desc) { 167 status = AE_NO_MEMORY; 168 goto cleanup; 169 } 170 171 /* Create the actual OS Mutex */ 172 173 status = acpi_os_create_mutex(&obj_desc->mutex.os_mutex); 174 if (ACPI_FAILURE(status)) { 175 goto cleanup; 176 } 177 178 /* Init object and attach to NS node */ 179 180 obj_desc->mutex.sync_level = (u8)walk_state->operands[1]->integer.value; 181 obj_desc->mutex.node = 182 (struct acpi_namespace_node *)walk_state->operands[0]; 183 184 status = 185 acpi_ns_attach_object(obj_desc->mutex.node, obj_desc, 186 ACPI_TYPE_MUTEX); 187 188 cleanup: 189 /* 190 * Remove local reference to the object (on error, will cause deletion 191 * of both object and semaphore if present.) 192 */ 193 acpi_ut_remove_reference(obj_desc); 194 return_ACPI_STATUS(status); 195 } 196 197 /******************************************************************************* 198 * 199 * FUNCTION: acpi_ex_create_region 200 * 201 * PARAMETERS: aml_start - Pointer to the region declaration AML 202 * aml_length - Max length of the declaration AML 203 * space_id - Address space ID for the region 204 * walk_state - Current state 205 * 206 * RETURN: Status 207 * 208 * DESCRIPTION: Create a new operation region object 209 * 210 ******************************************************************************/ 211 212 acpi_status 213 acpi_ex_create_region(u8 * aml_start, 214 u32 aml_length, 215 u8 space_id, struct acpi_walk_state *walk_state) 216 { 217 acpi_status status; 218 union acpi_operand_object *obj_desc; 219 struct acpi_namespace_node *node; 220 union acpi_operand_object *region_obj2; 221 222 ACPI_FUNCTION_TRACE(ex_create_region); 223 224 /* Get the Namespace Node */ 225 226 node = walk_state->op->common.node; 227 228 /* 229 * If the region object is already attached to this node, 230 * just return 231 */ 232 if (acpi_ns_get_attached_object(node)) { 233 return_ACPI_STATUS(AE_OK); 234 } 235 236 /* 237 * Space ID must be one of the predefined IDs, or in the user-defined 238 * range 239 */ 240 if (!acpi_is_valid_space_id(space_id)) { 241 /* 242 * Print an error message, but continue. We don't want to abort 243 * a table load for this exception. Instead, if the region is 244 * actually used at runtime, abort the executing method. 245 */ 246 ACPI_ERROR((AE_INFO, 247 "Invalid/unknown Address Space ID: 0x%2.2X", 248 space_id)); 249 } 250 251 ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "Region Type - %s (0x%X)\n", 252 acpi_ut_get_region_name(space_id), space_id)); 253 254 /* Create the region descriptor */ 255 256 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_REGION); 257 if (!obj_desc) { 258 status = AE_NO_MEMORY; 259 goto cleanup; 260 } 261 262 /* 263 * Remember location in AML stream of address & length 264 * operands since they need to be evaluated at run time. 265 */ 266 region_obj2 = acpi_ns_get_secondary_object(obj_desc); 267 region_obj2->extra.aml_start = aml_start; 268 region_obj2->extra.aml_length = aml_length; 269 region_obj2->extra.method_REG = NULL; 270 if (walk_state->scope_info) { 271 region_obj2->extra.scope_node = 272 walk_state->scope_info->scope.node; 273 } else { 274 region_obj2->extra.scope_node = node; 275 } 276 277 /* Init the region from the operands */ 278 279 obj_desc->region.space_id = space_id; 280 obj_desc->region.address = 0; 281 obj_desc->region.length = 0; 282 obj_desc->region.node = node; 283 obj_desc->region.handler = NULL; 284 obj_desc->common.flags &= 285 ~(AOPOBJ_SETUP_COMPLETE | AOPOBJ_REG_CONNECTED | 286 AOPOBJ_OBJECT_INITIALIZED); 287 288 /* Install the new region object in the parent Node */ 289 290 status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_REGION); 291 292 cleanup: 293 294 /* Remove local reference to the object */ 295 296 acpi_ut_remove_reference(obj_desc); 297 return_ACPI_STATUS(status); 298 } 299 300 /******************************************************************************* 301 * 302 * FUNCTION: acpi_ex_create_processor 303 * 304 * PARAMETERS: walk_state - Current state 305 * 306 * RETURN: Status 307 * 308 * DESCRIPTION: Create a new processor object and populate the fields 309 * 310 * Processor (Name[0], cpu_ID[1], pblock_addr[2], pblock_length[3]) 311 * 312 ******************************************************************************/ 313 314 acpi_status acpi_ex_create_processor(struct acpi_walk_state *walk_state) 315 { 316 union acpi_operand_object **operand = &walk_state->operands[0]; 317 union acpi_operand_object *obj_desc; 318 acpi_status status; 319 320 ACPI_FUNCTION_TRACE_PTR(ex_create_processor, walk_state); 321 322 /* Create the processor object */ 323 324 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_PROCESSOR); 325 if (!obj_desc) { 326 return_ACPI_STATUS(AE_NO_MEMORY); 327 } 328 329 /* Initialize the processor object from the operands */ 330 331 obj_desc->processor.proc_id = (u8) operand[1]->integer.value; 332 obj_desc->processor.length = (u8) operand[3]->integer.value; 333 obj_desc->processor.address = 334 (acpi_io_address)operand[2]->integer.value; 335 336 /* Install the processor object in the parent Node */ 337 338 status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0], 339 obj_desc, ACPI_TYPE_PROCESSOR); 340 341 /* Remove local reference to the object */ 342 343 acpi_ut_remove_reference(obj_desc); 344 return_ACPI_STATUS(status); 345 } 346 347 /******************************************************************************* 348 * 349 * FUNCTION: acpi_ex_create_power_resource 350 * 351 * PARAMETERS: walk_state - Current state 352 * 353 * RETURN: Status 354 * 355 * DESCRIPTION: Create a new power_resource object and populate the fields 356 * 357 * power_resource (Name[0], system_level[1], resource_order[2]) 358 * 359 ******************************************************************************/ 360 361 acpi_status acpi_ex_create_power_resource(struct acpi_walk_state *walk_state) 362 { 363 union acpi_operand_object **operand = &walk_state->operands[0]; 364 acpi_status status; 365 union acpi_operand_object *obj_desc; 366 367 ACPI_FUNCTION_TRACE_PTR(ex_create_power_resource, walk_state); 368 369 /* Create the power resource object */ 370 371 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_POWER); 372 if (!obj_desc) { 373 return_ACPI_STATUS(AE_NO_MEMORY); 374 } 375 376 /* Initialize the power object from the operands */ 377 378 obj_desc->power_resource.system_level = (u8) operand[1]->integer.value; 379 obj_desc->power_resource.resource_order = 380 (u16) operand[2]->integer.value; 381 382 /* Install the power resource object in the parent Node */ 383 384 status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0], 385 obj_desc, ACPI_TYPE_POWER); 386 387 /* Remove local reference to the object */ 388 389 acpi_ut_remove_reference(obj_desc); 390 return_ACPI_STATUS(status); 391 } 392 393 /******************************************************************************* 394 * 395 * FUNCTION: acpi_ex_create_method 396 * 397 * PARAMETERS: aml_start - First byte of the method's AML 398 * aml_length - AML byte count for this method 399 * walk_state - Current state 400 * 401 * RETURN: Status 402 * 403 * DESCRIPTION: Create a new method object 404 * 405 ******************************************************************************/ 406 407 acpi_status 408 acpi_ex_create_method(u8 * aml_start, 409 u32 aml_length, struct acpi_walk_state *walk_state) 410 { 411 union acpi_operand_object **operand = &walk_state->operands[0]; 412 union acpi_operand_object *obj_desc; 413 acpi_status status; 414 u8 method_flags; 415 416 ACPI_FUNCTION_TRACE_PTR(ex_create_method, walk_state); 417 418 /* Create a new method object */ 419 420 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_METHOD); 421 if (!obj_desc) { 422 status = AE_NO_MEMORY; 423 goto exit; 424 } 425 426 /* Save the method's AML pointer and length */ 427 428 obj_desc->method.aml_start = aml_start; 429 obj_desc->method.aml_length = aml_length; 430 obj_desc->method.node = operand[0]; 431 432 /* 433 * Disassemble the method flags. Split off the arg_count, Serialized 434 * flag, and sync_level for efficiency. 435 */ 436 method_flags = (u8)operand[1]->integer.value; 437 obj_desc->method.param_count = (u8) 438 (method_flags & AML_METHOD_ARG_COUNT); 439 440 /* 441 * Get the sync_level. If method is serialized, a mutex will be 442 * created for this method when it is parsed. 443 */ 444 if (method_flags & AML_METHOD_SERIALIZED) { 445 obj_desc->method.info_flags = ACPI_METHOD_SERIALIZED; 446 447 /* 448 * ACPI 1.0: sync_level = 0 449 * ACPI 2.0: sync_level = sync_level in method declaration 450 */ 451 obj_desc->method.sync_level = (u8) 452 ((method_flags & AML_METHOD_SYNC_LEVEL) >> 4); 453 } 454 455 /* Attach the new object to the method Node */ 456 457 status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0], 458 obj_desc, ACPI_TYPE_METHOD); 459 460 /* Remove local reference to the object */ 461 462 acpi_ut_remove_reference(obj_desc); 463 464 exit: 465 /* Remove a reference to the operand */ 466 467 acpi_ut_remove_reference(operand[1]); 468 return_ACPI_STATUS(status); 469 } 470