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
  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         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
  97 acpi_status
  98 acpi_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
 130 acpi_status
 131 acpi_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
 313 u8 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
 372 acpi_status
 373 acpi_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
 399 acpi_status
 400 acpi_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
 424 acpi_status
 425 acpi_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
 476 acpi_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 }