drivers/acpi/acpica/nsinit.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: nsinit - namespace initialization
   5  *
   6  * Copyright (C) 2000 - 2018, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #include <acpi/acpi.h>
  11 #include "accommon.h"
  12 #include "acnamesp.h"
  13 #include "acdispat.h"
  14 #include "acinterp.h"
  15 #include "acevents.h"
  16
  17 #define _COMPONENT          ACPI_NAMESPACE
  18 ACPI_MODULE_NAME("nsinit")
  19
  20 /* Local prototypes */
  21 static acpi_status
  22 acpi_ns_init_one_object(acpi_handle obj_handle,
  23                         u32 level, void *context, void **return_value);
  24
  25 static acpi_status
  26 acpi_ns_init_one_device(acpi_handle obj_handle,
  27                         u32 nesting_level, void *context, void **return_value);
  28
  29 static acpi_status
  30 acpi_ns_find_ini_methods(acpi_handle obj_handle,
  31                          u32 nesting_level, void *context, void **return_value);
  32
  33 /*******************************************************************************
  34  *
  35  * FUNCTION:    acpi_ns_initialize_objects
  36  *
  37  * PARAMETERS:  None
  38  *
  39  * RETURN:      Status
  40  *
  41  * DESCRIPTION: Walk the entire namespace and perform any necessary
  42  *              initialization on the objects found therein
  43  *
  44  ******************************************************************************/
  45
  46 acpi_status acpi_ns_initialize_objects(void)
  47 {
  48         acpi_status status;
  49         struct acpi_init_walk_info info;
  50
  51         ACPI_FUNCTION_TRACE(ns_initialize_objects);
  52
  53         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
  54                           "[Init] Completing Initialization of ACPI Objects\n"));
  55         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
  56                           "**** Starting initialization of namespace objects ****\n"));
  57         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
  58                               "Completing Region/Field/Buffer/Package initialization:\n"));
  59
  60         /* Set all init info to zero */
  61
  62         memset(&info, 0, sizeof(struct acpi_init_walk_info));
  63
  64         /* Walk entire namespace from the supplied root */
  65
  66         status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
  67                                      ACPI_UINT32_MAX, acpi_ns_init_one_object,
  68                                      NULL, &info, NULL);
  69         if (ACPI_FAILURE(status)) {
  70                 ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
  71         }
  72
  73         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
  74                               "    Initialized %u/%u Regions %u/%u Fields %u/%u "
  75                               "Buffers %u/%u Packages (%u nodes)\n",
  76                               info.op_region_init, info.op_region_count,
  77                               info.field_init, info.field_count,
  78                               info.buffer_init, info.buffer_count,
  79                               info.package_init, info.package_count,
  80                               info.object_count));
  81
  82         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
  83                           "%u Control Methods found\n%u Op Regions found\n",
  84                           info.method_count, info.op_region_count));
  85
  86         return_ACPI_STATUS(AE_OK);
  87 }
  88
  89 /*******************************************************************************
  90  *
  91  * FUNCTION:    acpi_ns_initialize_devices
  92  *
  93  * PARAMETERS:  None
  94  *
  95  * RETURN:      acpi_status
  96  *
  97  * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices.
  98  *              This means running _INI on all present devices.
  99  *
 100  *              Note: We install PCI config space handler on region access,
 101  *              not here.
 102  *
 103  ******************************************************************************/
 104
 105 acpi_status acpi_ns_initialize_devices(u32 flags)
 106 {
 107         acpi_status status = AE_OK;
 108         struct acpi_device_walk_info info;
 109         acpi_handle handle;
 110
 111         ACPI_FUNCTION_TRACE(ns_initialize_devices);
 112
 113         if (!(flags & ACPI_NO_DEVICE_INIT)) {
 114                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 115                                   "[Init] Initializing ACPI Devices\n"));
 116
 117                 /* Init counters */
 118
 119                 info.device_count = 0;
 120                 info.num_STA = 0;
 121                 info.num_INI = 0;
 122
 123                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
 124                                       "Initializing Device/Processor/Thermal objects "
 125                                       "and executing _INI/_STA methods:\n"));
 126
 127                 /* Tree analysis: find all subtrees that contain _INI methods */
 128
 129                 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 130                                                 ACPI_UINT32_MAX, FALSE,
 131                                                 acpi_ns_find_ini_methods, NULL,
 132                                                 &info, NULL);
 133                 if (ACPI_FAILURE(status)) {
 134                         goto error_exit;
 135                 }
 136
 137                 /* Allocate the evaluation information block */
 138
 139                 info.evaluate_info =
 140                     ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
 141                 if (!info.evaluate_info) {
 142                         status = AE_NO_MEMORY;
 143                         goto error_exit;
 144                 }
 145
 146                 /*
 147                  * Execute the "global" _INI method that may appear at the root.
 148                  * This support is provided for Windows compatibility (Vista+) and
 149                  * is not part of the ACPI specification.
 150                  */
 151                 info.evaluate_info->prefix_node = acpi_gbl_root_node;
 152                 info.evaluate_info->relative_pathname = METHOD_NAME__INI;
 153                 info.evaluate_info->parameters = NULL;
 154                 info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;
 155
 156                 status = acpi_ns_evaluate(info.evaluate_info);
 157                 if (ACPI_SUCCESS(status)) {
 158                         info.num_INI++;
 159                 }
 160
 161                 /*
 162                  * Execute \_SB._INI.
 163                  * There appears to be a strict order requirement for \_SB._INI,
 164                  * which should be evaluated before any _REG evaluations.
 165                  */
 166                 status = acpi_get_handle(NULL, "\\_SB", &handle);
 167                 if (ACPI_SUCCESS(status)) {
 168                         memset(info.evaluate_info, 0,
 169                                sizeof(struct acpi_evaluate_info));
 170                         info.evaluate_info->prefix_node = handle;
 171                         info.evaluate_info->relative_pathname =
 172                             METHOD_NAME__INI;
 173                         info.evaluate_info->parameters = NULL;
 174                         info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;
 175
 176                         status = acpi_ns_evaluate(info.evaluate_info);
 177                         if (ACPI_SUCCESS(status)) {
 178                                 info.num_INI++;
 179                         }
 180                 }
 181         }
 182
 183         /*
 184          * Run all _REG methods
 185          *
 186          * Note: Any objects accessed by the _REG methods will be automatically
 187          * initialized, even if they contain executable AML (see the call to
 188          * acpi_ns_initialize_objects below).
 189          *
 190          * Note: According to the ACPI specification, we actually needn't execute
 191          * _REG for system_memory/system_io operation regions, but for PCI_Config
 192          * operation regions, it is required to evaluate _REG for those on a PCI
 193          * root bus that doesn't contain _BBN object. So this code is kept here
 194          * in order not to break things.
 195          */
 196         if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
 197                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 198                                   "[Init] Executing _REG OpRegion methods\n"));
 199
 200                 status = acpi_ev_initialize_op_regions();
 201                 if (ACPI_FAILURE(status)) {
 202                         goto error_exit;
 203                 }
 204         }
 205
 206         if (!(flags & ACPI_NO_DEVICE_INIT)) {
 207
 208                 /* Walk namespace to execute all _INIs on present devices */
 209
 210                 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 211                                                 ACPI_UINT32_MAX, FALSE,
 212                                                 acpi_ns_init_one_device, NULL,
 213                                                 &info, NULL);
 214
 215                 /*
 216                  * Any _OSI requests should be completed by now. If the BIOS has
 217                  * requested any Windows OSI strings, we will always truncate
 218                  * I/O addresses to 16 bits -- for Windows compatibility.
 219                  */
 220                 if (acpi_gbl_osi_data >= ACPI_OSI_WIN_2000) {
 221                         acpi_gbl_truncate_io_addresses = TRUE;
 222                 }
 223
 224                 ACPI_FREE(info.evaluate_info);
 225                 if (ACPI_FAILURE(status)) {
 226                         goto error_exit;
 227                 }
 228
 229                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
 230                                       "    Executed %u _INI methods requiring %u _STA executions "
 231                                       "(examined %u objects)\n",
 232                                       info.num_INI, info.num_STA,
 233                                       info.device_count));
 234         }
 235
 236         return_ACPI_STATUS(status);
 237
 238 error_exit:
 239         ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));
 240         return_ACPI_STATUS(status);
 241 }
 242
 243 /*******************************************************************************
 244  *
 245  * FUNCTION:    acpi_ns_init_one_object
 246  *
 247  * PARAMETERS:  obj_handle      - Node
 248  *              level           - Current nesting level
 249  *              context         - Points to a init info struct
 250  *              return_value    - Not used
 251  *
 252  * RETURN:      Status
 253  *
 254  * DESCRIPTION: Callback from acpi_walk_namespace. Invoked for every object
 255  *              within the namespace.
 256  *
 257  *              Currently, the only objects that require initialization are:
 258  *              1) Methods
 259  *              2) Op Regions
 260  *
 261  ******************************************************************************/
 262
 263 static acpi_status
 264 acpi_ns_init_one_object(acpi_handle obj_handle,
 265                         u32 level, void *context, void **return_value)
 266 {
 267         acpi_object_type type;
 268         acpi_status status = AE_OK;
 269         struct acpi_init_walk_info *info =
 270             (struct acpi_init_walk_info *)context;
 271         struct acpi_namespace_node *node =
 272             (struct acpi_namespace_node *)obj_handle;
 273         union acpi_operand_object *obj_desc;
 274
 275         ACPI_FUNCTION_NAME(ns_init_one_object);
 276
 277         info->object_count++;
 278
 279         /* And even then, we are only interested in a few object types */
 280
 281         type = acpi_ns_get_type(obj_handle);
 282         obj_desc = acpi_ns_get_attached_object(node);
 283         if (!obj_desc) {
 284                 return (AE_OK);
 285         }
 286
 287         /* Increment counters for object types we are looking for */
 288
 289         switch (type) {
 290         case ACPI_TYPE_REGION:
 291
 292                 info->op_region_count++;
 293                 break;
 294
 295         case ACPI_TYPE_BUFFER_FIELD:
 296
 297                 info->field_count++;
 298                 break;
 299
 300         case ACPI_TYPE_LOCAL_BANK_FIELD:
 301
 302                 info->field_count++;
 303                 break;
 304
 305         case ACPI_TYPE_BUFFER:
 306
 307                 info->buffer_count++;
 308                 break;
 309
 310         case ACPI_TYPE_PACKAGE:
 311
 312                 info->package_count++;
 313                 break;
 314
 315         default:
 316
 317                 /* No init required, just exit now */
 318
 319                 return (AE_OK);
 320         }
 321
 322         /* If the object is already initialized, nothing else to do */
 323
 324         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
 325                 return (AE_OK);
 326         }
 327
 328         /* Must lock the interpreter before executing AML code */
 329
 330         acpi_ex_enter_interpreter();
 331
 332         /*
 333          * Each of these types can contain executable AML code within the
 334          * declaration.
 335          */
 336         switch (type) {
 337         case ACPI_TYPE_REGION:
 338
 339                 info->op_region_init++;
 340                 status = acpi_ds_get_region_arguments(obj_desc);
 341                 break;
 342
 343         case ACPI_TYPE_BUFFER_FIELD:
 344
 345                 info->field_init++;
 346                 status = acpi_ds_get_buffer_field_arguments(obj_desc);
 347                 break;
 348
 349         case ACPI_TYPE_LOCAL_BANK_FIELD:
 350
 351                 info->field_init++;
 352                 status = acpi_ds_get_bank_field_arguments(obj_desc);
 353                 break;
 354
 355         case ACPI_TYPE_BUFFER:
 356
 357                 info->buffer_init++;
 358                 status = acpi_ds_get_buffer_arguments(obj_desc);
 359                 break;
 360
 361         case ACPI_TYPE_PACKAGE:
 362
 363                 info->package_init++;
 364                 status = acpi_ds_get_package_arguments(obj_desc);
 365                 if (ACPI_FAILURE(status)) {
 366                         break;
 367                 }
 368
 369                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_PARSE,
 370                                       "%s: Completing resolution of Package elements\n",
 371                                       ACPI_GET_FUNCTION_NAME));
 372
 373                 /*
 374                  * Resolve all named references in package objects (and all
 375                  * sub-packages). This action has been deferred until the entire
 376                  * namespace has been loaded, in order to support external and
 377                  * forward references from individual package elements (05/2017).
 378                  */
 379                 status = acpi_ut_walk_package_tree(obj_desc, NULL,
 380                                                    acpi_ds_init_package_element,
 381                                                    NULL);
 382
 383                 obj_desc->package.flags |= AOPOBJ_DATA_VALID;
 384                 break;
 385
 386         default:
 387
 388                 /* No other types can get here */
 389
 390                 break;
 391         }
 392
 393         if (ACPI_FAILURE(status)) {
 394                 ACPI_EXCEPTION((AE_INFO, status,
 395                                 "Could not execute arguments for [%4.4s] (%s)",
 396                                 acpi_ut_get_node_name(node),
 397                                 acpi_ut_get_type_name(type)));
 398         }
 399
 400         /*
 401          * We ignore errors from above, and always return OK, since we don't want
 402          * to abort the walk on any single error.
 403          */
 404         acpi_ex_exit_interpreter();
 405         return (AE_OK);
 406 }
 407
 408 /*******************************************************************************
 409  *
 410  * FUNCTION:    acpi_ns_find_ini_methods
 411  *
 412  * PARAMETERS:  acpi_walk_callback
 413  *
 414  * RETURN:      acpi_status
 415  *
 416  * DESCRIPTION: Called during namespace walk. Finds objects named _INI under
 417  *              device/processor/thermal objects, and marks the entire subtree
 418  *              with a SUBTREE_HAS_INI flag. This flag is used during the
 419  *              subsequent device initialization walk to avoid entire subtrees
 420  *              that do not contain an _INI.
 421  *
 422  ******************************************************************************/
 423
 424 static acpi_status
 425 acpi_ns_find_ini_methods(acpi_handle obj_handle,
 426                          u32 nesting_level, void *context, void **return_value)
 427 {
 428         struct acpi_device_walk_info *info =
 429             ACPI_CAST_PTR(struct acpi_device_walk_info, context);
 430         struct acpi_namespace_node *node;
 431         struct acpi_namespace_node *parent_node;
 432
 433         /* Keep count of device/processor/thermal objects */
 434
 435         node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
 436         if ((node->type == ACPI_TYPE_DEVICE) ||
 437             (node->type == ACPI_TYPE_PROCESSOR) ||
 438             (node->type == ACPI_TYPE_THERMAL)) {
 439                 info->device_count++;
 440                 return (AE_OK);
 441         }
 442
 443         /* We are only looking for methods named _INI */
 444
 445         if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
 446                 return (AE_OK);
 447         }
 448
 449         /*
 450          * The only _INI methods that we care about are those that are
 451          * present under Device, Processor, and Thermal objects.
 452          */
 453         parent_node = node->parent;
 454         switch (parent_node->type) {
 455         case ACPI_TYPE_DEVICE:
 456         case ACPI_TYPE_PROCESSOR:
 457         case ACPI_TYPE_THERMAL:
 458
 459                 /* Mark parent and bubble up the INI present flag to the root */
 460
 461                 while (parent_node) {
 462                         parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
 463                         parent_node = parent_node->parent;
 464                 }
 465                 break;
 466
 467         default:
 468
 469                 break;
 470         }
 471
 472         return (AE_OK);
 473 }
 474
 475 /*******************************************************************************
 476  *
 477  * FUNCTION:    acpi_ns_init_one_device
 478  *
 479  * PARAMETERS:  acpi_walk_callback
 480  *
 481  * RETURN:      acpi_status
 482  *
 483  * DESCRIPTION: This is called once per device soon after ACPI is enabled
 484  *              to initialize each device. It determines if the device is
 485  *              present, and if so, calls _INI.
 486  *
 487  ******************************************************************************/
 488
 489 static acpi_status
 490 acpi_ns_init_one_device(acpi_handle obj_handle,
 491                         u32 nesting_level, void *context, void **return_value)
 492 {
 493         struct acpi_device_walk_info *walk_info =
 494             ACPI_CAST_PTR(struct acpi_device_walk_info, context);
 495         struct acpi_evaluate_info *info = walk_info->evaluate_info;
 496         u32 flags;
 497         acpi_status status;
 498         struct acpi_namespace_node *device_node;
 499
 500         ACPI_FUNCTION_TRACE(ns_init_one_device);
 501
 502         /* We are interested in Devices, Processors and thermal_zones only */
 503
 504         device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
 505         if ((device_node->type != ACPI_TYPE_DEVICE) &&
 506             (device_node->type != ACPI_TYPE_PROCESSOR) &&
 507             (device_node->type != ACPI_TYPE_THERMAL)) {
 508                 return_ACPI_STATUS(AE_OK);
 509         }
 510
 511         /*
 512          * Because of an earlier namespace analysis, all subtrees that contain an
 513          * _INI method are tagged.
 514          *
 515          * If this device subtree does not contain any _INI methods, we
 516          * can exit now and stop traversing this entire subtree.
 517          */
 518         if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
 519                 return_ACPI_STATUS(AE_CTRL_DEPTH);
 520         }
 521
 522         /*
 523          * Run _STA to determine if this device is present and functioning. We
 524          * must know this information for two important reasons (from ACPI spec):
 525          *
 526          * 1) We can only run _INI if the device is present.
 527          * 2) We must abort the device tree walk on this subtree if the device is
 528          *    not present and is not functional (we will not examine the children)
 529          *
 530          * The _STA method is not required to be present under the device, we
 531          * assume the device is present if _STA does not exist.
 532          */
 533         ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
 534                         (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
 535
 536         status = acpi_ut_execute_STA(device_node, &flags);
 537         if (ACPI_FAILURE(status)) {
 538
 539                 /* Ignore error and move on to next device */
 540
 541                 return_ACPI_STATUS(AE_OK);
 542         }
 543
 544         /*
 545          * Flags == -1 means that _STA was not found. In this case, we assume that
 546          * the device is both present and functional.
 547          *
 548          * From the ACPI spec, description of _STA:
 549          *
 550          * "If a device object (including the processor object) does not have an
 551          * _STA object, then OSPM assumes that all of the above bits are set (in
 552          * other words, the device is present, ..., and functioning)"
 553          */
 554         if (flags != ACPI_UINT32_MAX) {
 555                 walk_info->num_STA++;
 556         }
 557
 558         /*
 559          * Examine the PRESENT and FUNCTIONING status bits
 560          *
 561          * Note: ACPI spec does not seem to specify behavior for the present but
 562          * not functioning case, so we assume functioning if present.
 563          */
 564         if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
 565
 566                 /* Device is not present, we must examine the Functioning bit */
 567
 568                 if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
 569                         /*
 570                          * Device is not present but is "functioning". In this case,
 571                          * we will not run _INI, but we continue to examine the children
 572                          * of this device.
 573                          *
 574                          * From the ACPI spec, description of _STA: (note - no mention
 575                          * of whether to run _INI or not on the device in question)
 576                          *
 577                          * "_STA may return bit 0 clear (not present) with bit 3 set
 578                          * (device is functional). This case is used to indicate a valid
 579                          * device for which no device driver should be loaded (for example,
 580                          * a bridge device.) Children of this device may be present and
 581                          * valid. OSPM should continue enumeration below a device whose
 582                          * _STA returns this bit combination"
 583                          */
 584                         return_ACPI_STATUS(AE_OK);
 585                 } else {
 586                         /*
 587                          * Device is not present and is not functioning. We must abort the
 588                          * walk of this subtree immediately -- don't look at the children
 589                          * of such a device.
 590                          *
 591                          * From the ACPI spec, description of _INI:
 592                          *
 593                          * "If the _STA method indicates that the device is not present,
 594                          * OSPM will not run the _INI and will not examine the children
 595                          * of the device for _INI methods"
 596                          */
 597                         return_ACPI_STATUS(AE_CTRL_DEPTH);
 598                 }
 599         }
 600
 601         /*
 602          * The device is present or is assumed present if no _STA exists.
 603          * Run the _INI if it exists (not required to exist)
 604          *
 605          * Note: We know there is an _INI within this subtree, but it may not be
 606          * under this particular device, it may be lower in the branch.
 607          */
 608         if (!ACPI_COMPARE_NAME(device_node->name.ascii, "_SB_") ||
 609             device_node->parent != acpi_gbl_root_node) {
 610                 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
 611                                 (ACPI_TYPE_METHOD, device_node,
 612                                  METHOD_NAME__INI));
 613
 614                 memset(info, 0, sizeof(struct acpi_evaluate_info));
 615                 info->prefix_node = device_node;
 616                 info->relative_pathname = METHOD_NAME__INI;
 617                 info->parameters = NULL;
 618                 info->flags = ACPI_IGNORE_RETURN_VALUE;
 619
 620                 status = acpi_ns_evaluate(info);
 621                 if (ACPI_SUCCESS(status)) {
 622                         walk_info->num_INI++;
 623                 }
 624 #ifdef ACPI_DEBUG_OUTPUT
 625                 else if (status != AE_NOT_FOUND) {
 626
 627                         /* Ignore error and move on to next device */
 628
 629                         char *scope_name =
 630                             acpi_ns_get_normalized_pathname(device_node, TRUE);
 631
 632                         ACPI_EXCEPTION((AE_INFO, status,
 633                                         "during %s._INI execution",
 634                                         scope_name));
 635                         ACPI_FREE(scope_name);
 636                 }
 637 #endif
 638         }
 639
 640         /* Ignore errors from above */
 641
 642         status = AE_OK;
 643
 644         /*
 645          * The _INI method has been run if present; call the Global Initialization
 646          * Handler for this device.
 647          */
 648         if (acpi_gbl_init_handler) {
 649                 status =
 650                     acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI);
 651         }
 652
 653         return_ACPI_STATUS(status);
 654 }