LXR linux/drivers/acpi/acpica/evrgnini.c

   1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2/******************************************************************************
   3 *
   4 * Module Name: evrgnini- ACPI address_space (op_region) init
   5 *
   6 * Copyright (C) 2000 - 2020, Intel Corp.
   7 *
   8 *****************************************************************************/
   9
  10#include <acpi/acpi.h>
  11#include "accommon.h"
  12#include "acevents.h"
  13#include "acnamesp.h"
  14#include "acinterp.h"
  15
  16#define _COMPONENT          ACPI_EVENTS
  17ACPI_MODULE_NAME("evrgnini")
  18
  19/*******************************************************************************
  20 *
  21 * FUNCTION:    acpi_ev_system_memory_region_setup
  22 *
  23 * PARAMETERS:  handle              - Region we are interested in
  24 *              function            - Start or stop
  25 *              handler_context     - Address space handler context
  26 *              region_context      - Region specific context
  27 *
  28 * RETURN:      Status
  29 *
  30 * DESCRIPTION: Setup a system_memory operation region
  31 *
  32 ******************************************************************************/
  33acpi_status
  34acpi_ev_system_memory_region_setup(acpi_handle handle,
  35                                   u32 function,
  36                                   void *handler_context, void **region_context)
  37{
  38        union acpi_operand_object *region_desc =
  39            (union acpi_operand_object *)handle;
  40        struct acpi_mem_space_context *local_region_context;
  41        struct acpi_mem_mapping *mm;
  42
  43        ACPI_FUNCTION_TRACE(ev_system_memory_region_setup);
  44
  45        if (function == ACPI_REGION_DEACTIVATE) {
  46                if (*region_context) {
  47                        local_region_context =
  48                            (struct acpi_mem_space_context *)*region_context;
  49
  50                        /* Delete memory mappings if present */
  51
  52                        while (local_region_context->first_mm) {
  53                                mm = local_region_context->first_mm;
  54                                local_region_context->first_mm = mm->next_mm;
  55                                acpi_os_unmap_memory(mm->logical_address,
  56                                                     mm->length);
  57                                ACPI_FREE(mm);
  58                        }
  59                        ACPI_FREE(local_region_context);
  60                        *region_context = NULL;
  61                }
  62                return_ACPI_STATUS(AE_OK);
  63        }
  64
  65        /* Create a new context */
  66
  67        local_region_context =
  68            ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
  69        if (!(local_region_context)) {
  70                return_ACPI_STATUS(AE_NO_MEMORY);
  71        }
  72
  73        /* Save the region length and address for use in the handler */
  74
  75        local_region_context->length = region_desc->region.length;
  76        local_region_context->address = region_desc->region.address;
  77
  78        *region_context = local_region_context;
  79        return_ACPI_STATUS(AE_OK);
  80}
  81
  82/*******************************************************************************
  83 *
  84 * FUNCTION:    acpi_ev_io_space_region_setup
  85 *
  86 * PARAMETERS:  handle              - Region we are interested in
  87 *              function            - Start or stop
  88 *              handler_context     - Address space handler context
  89 *              region_context      - Region specific context
  90 *
  91 * RETURN:      Status
  92 *
  93 * DESCRIPTION: Setup a IO operation region
  94 *
  95 ******************************************************************************/
  96
  97acpi_status
  98acpi_ev_io_space_region_setup(acpi_handle handle,
  99                              u32 function,
 100                              void *handler_context, void **region_context)
 101{
 102        ACPI_FUNCTION_TRACE(ev_io_space_region_setup);
 103
 104        if (function == ACPI_REGION_DEACTIVATE) {
 105                *region_context = NULL;
 106        } else {
 107                *region_context = handler_context;
 108        }
 109
 110        return_ACPI_STATUS(AE_OK);
 111}
 112
 113/*******************************************************************************
 114 *
 115 * FUNCTION:    acpi_ev_pci_config_region_setup
 116 *
 117 * PARAMETERS:  handle              - Region we are interested in
 118 *              function            - Start or stop
 119 *              handler_context     - Address space handler context
 120 *              region_context      - Region specific context
 121 *
 122 * RETURN:      Status
 123 *
 124 * DESCRIPTION: Setup a PCI_Config operation region
 125 *
 126 * MUTEX:       Assumes namespace is not locked
 127 *
 128 ******************************************************************************/
 129
 130acpi_status
 131acpi_ev_pci_config_region_setup(acpi_handle handle,
 132                                u32 function,
 133                                void *handler_context, void **region_context)
 134{
 135        acpi_status status = AE_OK;
 136        u64 pci_value;
 137        struct acpi_pci_id *pci_id = *region_context;
 138        union acpi_operand_object *handler_obj;
 139        struct acpi_namespace_node *parent_node;
 140        struct acpi_namespace_node *pci_root_node;
 141        struct acpi_namespace_node *pci_device_node;
 142        union acpi_operand_object *region_obj =
 143            (union acpi_operand_object *)handle;
 144
 145        ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
 146
 147        handler_obj = region_obj->region.handler;
 148        if (!handler_obj) {
 149                /*
 150                 * No installed handler. This shouldn't happen because the dispatch
 151                 * routine checks before we get here, but we check again just in case.
 152                 */
 153                ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
 154                                  "Attempting to init a region %p, with no handler\n",
 155                                  region_obj));
 156                return_ACPI_STATUS(AE_NOT_EXIST);
 157        }
 158
 159        *region_context = NULL;
 160        if (function == ACPI_REGION_DEACTIVATE) {
 161                if (pci_id) {
 162                        ACPI_FREE(pci_id);
 163                }
 164                return_ACPI_STATUS(status);
 165        }
 166
 167        parent_node = region_obj->region.node->parent;
 168
 169        /*
 170         * Get the _SEG and _BBN values from the device upon which the handler
 171         * is installed.
 172         *
 173         * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
 174         * This is the device the handler has been registered to handle.
 175         */
 176
 177        /*
 178         * If the address_space.Node is still pointing to the root, we need
 179         * to scan upward for a PCI Root bridge and re-associate the op_region
 180         * handlers with that device.
 181         */
 182        if (handler_obj->address_space.node == acpi_gbl_root_node) {
 183
 184                /* Start search from the parent object */
 185
 186                pci_root_node = parent_node;
 187                while (pci_root_node != acpi_gbl_root_node) {
 188
 189                        /* Get the _HID/_CID in order to detect a root_bridge */
 190
 191                        if (acpi_ev_is_pci_root_bridge(pci_root_node)) {
 192
 193                                /* Install a handler for this PCI root bridge */
 194
 195                                status = acpi_install_address_space_handler((acpi_handle)pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
 196                                if (ACPI_FAILURE(status)) {
 197                                        if (status == AE_SAME_HANDLER) {
 198                                                /*
 199                                                 * It is OK if the handler is already installed on the
 200                                                 * root bridge. Still need to return a context object
 201                                                 * for the new PCI_Config operation region, however.
 202                                                 */
 203                                        } else {
 204                                                ACPI_EXCEPTION((AE_INFO, status,
 205                                                                "Could not install PciConfig handler "
 206                                                                "for Root Bridge %4.4s",
 207                                                                acpi_ut_get_node_name
 208                                                                (pci_root_node)));
 209                                        }
 210                                }
 211                                break;
 212                        }
 213
 214                        pci_root_node = pci_root_node->parent;
 215                }
 216
 217                /* PCI root bridge not found, use namespace root node */
 218        } else {
 219                pci_root_node = handler_obj->address_space.node;
 220        }
 221
 222        /*
 223         * If this region is now initialized, we are done.
 224         * (install_address_space_handler could have initialized it)
 225         */
 226        if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
 227                return_ACPI_STATUS(AE_OK);
 228        }
 229
 230        /* Region is still not initialized. Create a new context */
 231
 232        pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
 233        if (!pci_id) {
 234                return_ACPI_STATUS(AE_NO_MEMORY);
 235        }
 236
 237        /*
 238         * For PCI_Config space access, we need the segment, bus, device and
 239         * function numbers. Acquire them here.
 240         *
 241         * Find the parent device object. (This allows the operation region to be
 242         * within a subscope under the device, such as a control method.)
 243         */
 244        pci_device_node = region_obj->region.node;
 245        while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) {
 246                pci_device_node = pci_device_node->parent;
 247        }
 248
 249        if (!pci_device_node) {
 250                ACPI_FREE(pci_id);
 251                return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
 252        }
 253
 254        /*
 255         * Get the PCI device and function numbers from the _ADR object
 256         * contained in the parent's scope.
 257         */
 258        status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR,
 259                                                 pci_device_node, &pci_value);
 260
 261        /*
 262         * The default is zero, and since the allocation above zeroed the data,
 263         * just do nothing on failure.
 264         */
 265        if (ACPI_SUCCESS(status)) {
 266                pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
 267                pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
 268        }
 269
 270        /* The PCI segment number comes from the _SEG method */
 271
 272        status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG,
 273                                                 pci_root_node, &pci_value);
 274        if (ACPI_SUCCESS(status)) {
 275                pci_id->segment = ACPI_LOWORD(pci_value);
 276        }
 277
 278        /* The PCI bus number comes from the _BBN method */
 279
 280        status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN,
 281                                                 pci_root_node, &pci_value);
 282        if (ACPI_SUCCESS(status)) {
 283                pci_id->bus = ACPI_LOWORD(pci_value);
 284        }
 285
 286        /* Complete/update the PCI ID for this device */
 287
 288        status =
 289            acpi_hw_derive_pci_id(pci_id, pci_root_node,
 290                                  region_obj->region.node);
 291        if (ACPI_FAILURE(status)) {
 292                ACPI_FREE(pci_id);
 293                return_ACPI_STATUS(status);
 294        }
 295
 296        *region_context = pci_id;
 297        return_ACPI_STATUS(AE_OK);
 298}
 299
 300/*******************************************************************************
 301 *
 302 * FUNCTION:    acpi_ev_is_pci_root_bridge
 303 *
 304 * PARAMETERS:  node            - Device node being examined
 305 *
 306 * RETURN:      TRUE if device is a PCI/PCI-Express Root Bridge
 307 *
 308 * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by
 309 *              examining the _HID and _CID for the device.
 310 *
 311 ******************************************************************************/
 312
 313u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
 314{
 315        acpi_status status;
 316        struct acpi_pnp_device_id *hid;
 317        struct acpi_pnp_device_id_list *cid;
 318        u32 i;
 319        u8 match;
 320
 321        /* Get the _HID and check for a PCI Root Bridge */
 322
 323        status = acpi_ut_execute_HID(node, &hid);
 324        if (ACPI_FAILURE(status)) {
 325                return (FALSE);
 326        }
 327
 328        match = acpi_ut_is_pci_root_bridge(hid->string);
 329        ACPI_FREE(hid);
 330
 331        if (match) {
 332                return (TRUE);
 333        }
 334
 335        /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */
 336
 337        status = acpi_ut_execute_CID(node, &cid);
 338        if (ACPI_FAILURE(status)) {
 339                return (FALSE);
 340        }
 341
 342        /* Check all _CIDs in the returned list */
 343
 344        for (i = 0; i < cid->count; i++) {
 345                if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) {
 346                        ACPI_FREE(cid);
 347                        return (TRUE);
 348                }
 349        }
 350
 351        ACPI_FREE(cid);
 352        return (FALSE);
 353}
 354
 355/*******************************************************************************
 356 *
 357 * FUNCTION:    acpi_ev_pci_bar_region_setup
 358 *
 359 * PARAMETERS:  handle              - Region we are interested in
 360 *              function            - Start or stop
 361 *              handler_context     - Address space handler context
 362 *              region_context      - Region specific context
 363 *
 364 * RETURN:      Status
 365 *
 366 * DESCRIPTION: Setup a pci_BAR operation region
 367 *
 368 * MUTEX:       Assumes namespace is not locked
 369 *
 370 ******************************************************************************/
 371
 372acpi_status
 373acpi_ev_pci_bar_region_setup(acpi_handle handle,
 374                             u32 function,
 375                             void *handler_context, void **region_context)
 376{
 377        ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup);
 378
 379        return_ACPI_STATUS(AE_OK);
 380}
 381
 382/*******************************************************************************
 383 *
 384 * FUNCTION:    acpi_ev_cmos_region_setup
 385 *
 386 * PARAMETERS:  handle              - Region we are interested in
 387 *              function            - Start or stop
 388 *              handler_context     - Address space handler context
 389 *              region_context      - Region specific context
 390 *
 391 * RETURN:      Status
 392 *
 393 * DESCRIPTION: Setup a CMOS operation region
 394 *
 395 * MUTEX:       Assumes namespace is not locked
 396 *
 397 ******************************************************************************/
 398
 399acpi_status
 400acpi_ev_cmos_region_setup(acpi_handle handle,
 401                          u32 function,
 402                          void *handler_context, void **region_context)
 403{
 404        ACPI_FUNCTION_TRACE(ev_cmos_region_setup);
 405
 406        return_ACPI_STATUS(AE_OK);
 407}
 408
 409/*******************************************************************************
 410 *
 411 * FUNCTION:    acpi_ev_default_region_setup
 412 *
 413 * PARAMETERS:  handle              - Region we are interested in
 414 *              function            - Start or stop
 415 *              handler_context     - Address space handler context
 416 *              region_context      - Region specific context
 417 *
 418 * RETURN:      Status
 419 *
 420 * DESCRIPTION: Default region initialization
 421 *
 422 ******************************************************************************/
 423
 424acpi_status
 425acpi_ev_default_region_setup(acpi_handle handle,
 426                             u32 function,
 427                             void *handler_context, void **region_context)
 428{
 429        ACPI_FUNCTION_TRACE(ev_default_region_setup);
 430
 431        if (function == ACPI_REGION_DEACTIVATE) {
 432                *region_context = NULL;
 433        } else {
 434                *region_context = handler_context;
 435        }
 436
 437        return_ACPI_STATUS(AE_OK);
 438}
 439
 440/*******************************************************************************
 441 *
 442 * FUNCTION:    acpi_ev_initialize_region
 443 *
 444 * PARAMETERS:  region_obj      - Region we are initializing
 445 *
 446 * RETURN:      Status
 447 *
 448 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
 449 *              for execution at a later time
 450 *
 451 *              Get the appropriate address space handler for a newly
 452 *              created region.
 453 *
 454 *              This also performs address space specific initialization. For
 455 *              example, PCI regions must have an _ADR object that contains
 456 *              a PCI address in the scope of the definition. This address is
 457 *              required to perform an access to PCI config space.
 458 *
 459 * MUTEX:       Interpreter should be unlocked, because we may run the _REG
 460 *              method for this region.
 461 *
 462 * NOTE:        Possible incompliance:
 463 *              There is a behavior conflict in automatic _REG execution:
 464 *              1. When the interpreter is evaluating a method, we can only
 465 *                 automatically run _REG for the following case:
 466 *                   operation_region (OPR1, 0x80, 0x1000010, 0x4)
 467 *              2. When the interpreter is loading a table, we can also
 468 *                 automatically run _REG for the following case:
 469 *                   operation_region (OPR1, 0x80, 0x1000010, 0x4)
 470 *              Though this may not be compliant to the de-facto standard, the
 471 *              logic is kept in order not to trigger regressions. And keeping
 472 *              this logic should be taken care by the caller of this function.
 473 *
 474 ******************************************************************************/
 475
 476acpi_status acpi_ev_initialize_region(union acpi_operand_object *region_obj)
 477{
 478        union acpi_operand_object *handler_obj;
 479        union acpi_operand_object *obj_desc;
 480        acpi_adr_space_type space_id;
 481        struct acpi_namespace_node *node;
 482
 483        ACPI_FUNCTION_TRACE(ev_initialize_region);
 484
 485        if (!region_obj) {
 486                return_ACPI_STATUS(AE_BAD_PARAMETER);
 487        }
 488
 489        if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
 490                return_ACPI_STATUS(AE_OK);
 491        }
 492
 493        region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
 494
 495        node = region_obj->region.node->parent;
 496        space_id = region_obj->region.space_id;
 497
 498        /*
 499         * The following loop depends upon the root Node having no parent
 500         * ie: acpi_gbl_root_node->Parent being set to NULL
 501         */
 502        while (node) {
 503
 504                /* Check to see if a handler exists */
 505
 506                handler_obj = NULL;
 507                obj_desc = acpi_ns_get_attached_object(node);
 508                if (obj_desc) {
 509
 510                        /* Can only be a handler if the object exists */
 511
 512                        switch (node->type) {
 513                        case ACPI_TYPE_DEVICE:
 514                        case ACPI_TYPE_PROCESSOR:
 515                        case ACPI_TYPE_THERMAL:
 516
 517                                handler_obj = obj_desc->common_notify.handler;
 518                                break;
 519
 520                        default:
 521
 522                                /* Ignore other objects */
 523
 524                                break;
 525                        }
 526
 527                        handler_obj =
 528                            acpi_ev_find_region_handler(space_id, handler_obj);
 529                        if (handler_obj) {
 530
 531                                /* Found correct handler */
 532
 533                                ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
 534                                                  "Found handler %p for region %p in obj %p\n",
 535                                                  handler_obj, region_obj,
 536                                                  obj_desc));
 537
 538                                (void)acpi_ev_attach_region(handler_obj,
 539                                                            region_obj, FALSE);
 540
 541                                /*
 542                                 * Tell all users that this region is usable by
 543                                 * running the _REG method
 544                                 */
 545                                acpi_ex_exit_interpreter();
 546                                (void)acpi_ev_execute_reg_method(region_obj,
 547                                                                 ACPI_REG_CONNECT);
 548                                acpi_ex_enter_interpreter();
 549                                return_ACPI_STATUS(AE_OK);
 550                        }
 551                }
 552
 553                /* This node does not have the handler we need; Pop up one level */
 554
 555                node = node->parent;
 556        }
 557
 558        /*
 559         * If we get here, there is no handler for this region. This is not
 560         * fatal because many regions get created before a handler is installed
 561         * for said region.
 562         */
 563        ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
 564                          "No handler for RegionType %s(%X) (RegionObj %p)\n",
 565                          acpi_ut_get_region_name(space_id), space_id,
 566                          region_obj));
 567
 568        return_ACPI_STATUS(AE_OK);
 569}
 570