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