drivers/acpi/acpica/excreate.c

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