drivers/acpi/acpica/evgpeblk.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: evgpeblk - GPE block creation and initialization.
   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
  15 #define _COMPONENT          ACPI_EVENTS
  16 ACPI_MODULE_NAME("evgpeblk")
  17 #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  18 /* Local prototypes */
  19 static acpi_status
  20 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
  21                           u32 interrupt_number);
  22
  23 static acpi_status
  24 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block);
  25
  26 /*******************************************************************************
  27  *
  28  * FUNCTION:    acpi_ev_install_gpe_block
  29  *
  30  * PARAMETERS:  gpe_block               - New GPE block
  31  *              interrupt_number        - Xrupt to be associated with this
  32  *                                        GPE block
  33  *
  34  * RETURN:      Status
  35  *
  36  * DESCRIPTION: Install new GPE block with mutex support
  37  *
  38  ******************************************************************************/
  39
  40 static acpi_status
  41 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
  42                           u32 interrupt_number)
  43 {
  44         struct acpi_gpe_block_info *next_gpe_block;
  45         struct acpi_gpe_xrupt_info *gpe_xrupt_block;
  46         acpi_status status;
  47         acpi_cpu_flags flags;
  48
  49         ACPI_FUNCTION_TRACE(ev_install_gpe_block);
  50
  51         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
  52         if (ACPI_FAILURE(status)) {
  53                 return_ACPI_STATUS(status);
  54         }
  55
  56         status =
  57             acpi_ev_get_gpe_xrupt_block(interrupt_number, &gpe_xrupt_block);
  58         if (ACPI_FAILURE(status)) {
  59                 goto unlock_and_exit;
  60         }
  61
  62         /* Install the new block at the end of the list with lock */
  63
  64         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
  65         if (gpe_xrupt_block->gpe_block_list_head) {
  66                 next_gpe_block = gpe_xrupt_block->gpe_block_list_head;
  67                 while (next_gpe_block->next) {
  68                         next_gpe_block = next_gpe_block->next;
  69                 }
  70
  71                 next_gpe_block->next = gpe_block;
  72                 gpe_block->previous = next_gpe_block;
  73         } else {
  74                 gpe_xrupt_block->gpe_block_list_head = gpe_block;
  75         }
  76
  77         gpe_block->xrupt_block = gpe_xrupt_block;
  78         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
  79
  80 unlock_and_exit:
  81         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
  82         return_ACPI_STATUS(status);
  83 }
  84
  85 /*******************************************************************************
  86  *
  87  * FUNCTION:    acpi_ev_delete_gpe_block
  88  *
  89  * PARAMETERS:  gpe_block           - Existing GPE block
  90  *
  91  * RETURN:      Status
  92  *
  93  * DESCRIPTION: Remove a GPE block
  94  *
  95  ******************************************************************************/
  96
  97 acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
  98 {
  99         acpi_status status;
 100         acpi_cpu_flags flags;
 101
 102         ACPI_FUNCTION_TRACE(ev_install_gpe_block);
 103
 104         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 105         if (ACPI_FAILURE(status)) {
 106                 return_ACPI_STATUS(status);
 107         }
 108
 109         /* Disable all GPEs in this block */
 110
 111         status =
 112             acpi_hw_disable_gpe_block(gpe_block->xrupt_block, gpe_block, NULL);
 113         if (ACPI_FAILURE(status)) {
 114                 return_ACPI_STATUS(status);
 115         }
 116
 117         if (!gpe_block->previous && !gpe_block->next) {
 118
 119                 /* This is the last gpe_block on this interrupt */
 120
 121                 status = acpi_ev_delete_gpe_xrupt(gpe_block->xrupt_block);
 122                 if (ACPI_FAILURE(status)) {
 123                         goto unlock_and_exit;
 124                 }
 125         } else {
 126                 /* Remove the block on this interrupt with lock */
 127
 128                 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 129                 if (gpe_block->previous) {
 130                         gpe_block->previous->next = gpe_block->next;
 131                 } else {
 132                         gpe_block->xrupt_block->gpe_block_list_head =
 133                             gpe_block->next;
 134                 }
 135
 136                 if (gpe_block->next) {
 137                         gpe_block->next->previous = gpe_block->previous;
 138                 }
 139
 140                 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 141         }
 142
 143         acpi_current_gpe_count -= gpe_block->gpe_count;
 144
 145         /* Free the gpe_block */
 146
 147         ACPI_FREE(gpe_block->register_info);
 148         ACPI_FREE(gpe_block->event_info);
 149         ACPI_FREE(gpe_block);
 150
 151 unlock_and_exit:
 152         status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 153         return_ACPI_STATUS(status);
 154 }
 155
 156 /*******************************************************************************
 157  *
 158  * FUNCTION:    acpi_ev_create_gpe_info_blocks
 159  *
 160  * PARAMETERS:  gpe_block   - New GPE block
 161  *
 162  * RETURN:      Status
 163  *
 164  * DESCRIPTION: Create the register_info and event_info blocks for this GPE block
 165  *
 166  ******************************************************************************/
 167
 168 static acpi_status
 169 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
 170 {
 171         struct acpi_gpe_register_info *gpe_register_info = NULL;
 172         struct acpi_gpe_event_info *gpe_event_info = NULL;
 173         struct acpi_gpe_event_info *this_event;
 174         struct acpi_gpe_register_info *this_register;
 175         u32 i;
 176         u32 j;
 177         acpi_status status;
 178
 179         ACPI_FUNCTION_TRACE(ev_create_gpe_info_blocks);
 180
 181         /* Allocate the GPE register information block */
 182
 183         gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size)gpe_block->
 184                                                  register_count *
 185                                                  sizeof(struct
 186                                                         acpi_gpe_register_info));
 187         if (!gpe_register_info) {
 188                 ACPI_ERROR((AE_INFO,
 189                             "Could not allocate the GpeRegisterInfo table"));
 190                 return_ACPI_STATUS(AE_NO_MEMORY);
 191         }
 192
 193         /*
 194          * Allocate the GPE event_info block. There are eight distinct GPEs
 195          * per register. Initialization to zeros is sufficient.
 196          */
 197         gpe_event_info = ACPI_ALLOCATE_ZEROED((acpi_size)gpe_block->gpe_count *
 198                                               sizeof(struct
 199                                                      acpi_gpe_event_info));
 200         if (!gpe_event_info) {
 201                 ACPI_ERROR((AE_INFO,
 202                             "Could not allocate the GpeEventInfo table"));
 203                 status = AE_NO_MEMORY;
 204                 goto error_exit;
 205         }
 206
 207         /* Save the new Info arrays in the GPE block */
 208
 209         gpe_block->register_info = gpe_register_info;
 210         gpe_block->event_info = gpe_event_info;
 211
 212         /*
 213          * Initialize the GPE Register and Event structures. A goal of these
 214          * tables is to hide the fact that there are two separate GPE register
 215          * sets in a given GPE hardware block, the status registers occupy the
 216          * first half, and the enable registers occupy the second half.
 217          */
 218         this_register = gpe_register_info;
 219         this_event = gpe_event_info;
 220
 221         for (i = 0; i < gpe_block->register_count; i++) {
 222
 223                 /* Init the register_info for this GPE register (8 GPEs) */
 224
 225                 this_register->base_gpe_number = (u16)
 226                     (gpe_block->block_base_number +
 227                      (i * ACPI_GPE_REGISTER_WIDTH));
 228
 229                 this_register->status_address.address = gpe_block->address + i;
 230
 231                 this_register->enable_address.address =
 232                     gpe_block->address + i + gpe_block->register_count;
 233
 234                 this_register->status_address.space_id = gpe_block->space_id;
 235                 this_register->enable_address.space_id = gpe_block->space_id;
 236
 237                 /* Init the event_info for each GPE within this register */
 238
 239                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 240                         this_event->gpe_number =
 241                             (u8) (this_register->base_gpe_number + j);
 242                         this_event->register_info = this_register;
 243                         this_event++;
 244                 }
 245
 246                 /* Disable all GPEs within this register */
 247
 248                 status = acpi_hw_gpe_write(0x00, &this_register->enable_address);
 249                 if (ACPI_FAILURE(status)) {
 250                         goto error_exit;
 251                 }
 252
 253                 /* Clear any pending GPE events within this register */
 254
 255                 status = acpi_hw_gpe_write(0xFF, &this_register->status_address);
 256                 if (ACPI_FAILURE(status)) {
 257                         goto error_exit;
 258                 }
 259
 260                 this_register++;
 261         }
 262
 263         return_ACPI_STATUS(AE_OK);
 264
 265 error_exit:
 266         if (gpe_register_info) {
 267                 ACPI_FREE(gpe_register_info);
 268         }
 269         if (gpe_event_info) {
 270                 ACPI_FREE(gpe_event_info);
 271         }
 272
 273         return_ACPI_STATUS(status);
 274 }
 275
 276 /*******************************************************************************
 277  *
 278  * FUNCTION:    acpi_ev_create_gpe_block
 279  *
 280  * PARAMETERS:  gpe_device          - Handle to the parent GPE block
 281  *              gpe_block_address   - Address and space_ID
 282  *              register_count      - Number of GPE register pairs in the block
 283  *              gpe_block_base_number - Starting GPE number for the block
 284  *              interrupt_number    - H/W interrupt for the block
 285  *              return_gpe_block    - Where the new block descriptor is returned
 286  *
 287  * RETURN:      Status
 288  *
 289  * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
 290  *              the block are disabled at exit.
 291  *              Note: Assumes namespace is locked.
 292  *
 293  ******************************************************************************/
 294
 295 acpi_status
 296 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
 297                          u64 address,
 298                          u8 space_id,
 299                          u32 register_count,
 300                          u16 gpe_block_base_number,
 301                          u32 interrupt_number,
 302                          struct acpi_gpe_block_info **return_gpe_block)
 303 {
 304         acpi_status status;
 305         struct acpi_gpe_block_info *gpe_block;
 306         struct acpi_gpe_walk_info walk_info;
 307
 308         ACPI_FUNCTION_TRACE(ev_create_gpe_block);
 309
 310         if (!register_count) {
 311                 return_ACPI_STATUS(AE_OK);
 312         }
 313
 314         /* Validate the space_ID */
 315
 316         if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
 317             (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
 318                 ACPI_ERROR((AE_INFO,
 319                             "Unsupported address space: 0x%X", space_id));
 320                 return_ACPI_STATUS(AE_SUPPORT);
 321         }
 322
 323         if (space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
 324                 status = acpi_hw_validate_io_block(address,
 325                                                    ACPI_GPE_REGISTER_WIDTH,
 326                                                    register_count);
 327                 if (ACPI_FAILURE(status))
 328                         return_ACPI_STATUS(status);
 329         }
 330
 331         /* Allocate a new GPE block */
 332
 333         gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
 334         if (!gpe_block) {
 335                 return_ACPI_STATUS(AE_NO_MEMORY);
 336         }
 337
 338         /* Initialize the new GPE block */
 339
 340         gpe_block->address = address;
 341         gpe_block->space_id = space_id;
 342         gpe_block->node = gpe_device;
 343         gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
 344         gpe_block->initialized = FALSE;
 345         gpe_block->register_count = register_count;
 346         gpe_block->block_base_number = gpe_block_base_number;
 347
 348         /*
 349          * Create the register_info and event_info sub-structures
 350          * Note: disables and clears all GPEs in the block
 351          */
 352         status = acpi_ev_create_gpe_info_blocks(gpe_block);
 353         if (ACPI_FAILURE(status)) {
 354                 ACPI_FREE(gpe_block);
 355                 return_ACPI_STATUS(status);
 356         }
 357
 358         /* Install the new block in the global lists */
 359
 360         status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
 361         if (ACPI_FAILURE(status)) {
 362                 ACPI_FREE(gpe_block->register_info);
 363                 ACPI_FREE(gpe_block->event_info);
 364                 ACPI_FREE(gpe_block);
 365                 return_ACPI_STATUS(status);
 366         }
 367
 368         acpi_gbl_all_gpes_initialized = FALSE;
 369
 370         /* Find all GPE methods (_Lxx or_Exx) for this block */
 371
 372         walk_info.gpe_block = gpe_block;
 373         walk_info.gpe_device = gpe_device;
 374         walk_info.execute_by_owner_id = FALSE;
 375
 376         (void)acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
 377                                      ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
 378                                      acpi_ev_match_gpe_method, NULL, &walk_info,
 379                                      NULL);
 380
 381         /* Return the new block */
 382
 383         if (return_gpe_block) {
 384                 (*return_gpe_block) = gpe_block;
 385         }
 386
 387         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
 388                               "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
 389                               (u32)gpe_block->block_base_number,
 390                               (u32)(gpe_block->block_base_number +
 391                                     (gpe_block->gpe_count - 1)),
 392                               gpe_device->name.ascii, gpe_block->register_count,
 393                               interrupt_number,
 394                               interrupt_number ==
 395                               acpi_gbl_FADT.sci_interrupt ? " (SCI)" : ""));
 396
 397         /* Update global count of currently available GPEs */
 398
 399         acpi_current_gpe_count += gpe_block->gpe_count;
 400         return_ACPI_STATUS(AE_OK);
 401 }
 402
 403 /*******************************************************************************
 404  *
 405  * FUNCTION:    acpi_ev_initialize_gpe_block
 406  *
 407  * PARAMETERS:  acpi_gpe_callback
 408  *
 409  * RETURN:      Status
 410  *
 411  * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
 412  *              associated methods.
 413  *              Note: Assumes namespace is locked.
 414  *
 415  ******************************************************************************/
 416
 417 acpi_status
 418 acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 419                              struct acpi_gpe_block_info *gpe_block,
 420                              void *context)
 421 {
 422         acpi_status status;
 423         struct acpi_gpe_event_info *gpe_event_info;
 424         u32 gpe_enabled_count;
 425         u32 gpe_index;
 426         u32 i;
 427         u32 j;
 428         u8 *is_polling_needed = context;
 429         ACPI_ERROR_ONLY(u32 gpe_number);
 430
 431         ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
 432
 433         /*
 434          * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
 435          * any GPE blocks that have been initialized already.
 436          */
 437         if (!gpe_block || gpe_block->initialized) {
 438                 return_ACPI_STATUS(AE_OK);
 439         }
 440
 441         /*
 442          * Enable all GPEs that have a corresponding method and have the
 443          * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
 444          * must be enabled via the acpi_enable_gpe() interface.
 445          */
 446         gpe_enabled_count = 0;
 447
 448         for (i = 0; i < gpe_block->register_count; i++) {
 449                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 450
 451                         /* Get the info block for this particular GPE */
 452
 453                         gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 454                         gpe_event_info = &gpe_block->event_info[gpe_index];
 455                         ACPI_ERROR_ONLY(gpe_number =
 456                                         gpe_block->block_base_number +
 457                                         gpe_index);
 458                         gpe_event_info->flags |= ACPI_GPE_INITIALIZED;
 459
 460                         /*
 461                          * Ignore GPEs that have no corresponding _Lxx/_Exx method
 462                          * and GPEs that are used for wakeup
 463                          */
 464                         if ((ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
 465                              ACPI_GPE_DISPATCH_METHOD)
 466                             || (gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
 467                                 continue;
 468                         }
 469
 470                         status = acpi_ev_add_gpe_reference(gpe_event_info, FALSE);
 471                         if (ACPI_FAILURE(status)) {
 472                                 ACPI_EXCEPTION((AE_INFO, status,
 473                                         "Could not enable GPE 0x%02X",
 474                                         gpe_number));
 475                                 continue;
 476                         }
 477
 478                         gpe_event_info->flags |= ACPI_GPE_AUTO_ENABLED;
 479
 480                         if (is_polling_needed &&
 481                             ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
 482                                 *is_polling_needed = TRUE;
 483                         }
 484
 485                         gpe_enabled_count++;
 486                 }
 487         }
 488
 489         if (gpe_enabled_count) {
 490                 ACPI_INFO(("Enabled %u GPEs in block %02X to %02X",
 491                            gpe_enabled_count, (u32)gpe_block->block_base_number,
 492                            (u32)(gpe_block->block_base_number +
 493                                  (gpe_block->gpe_count - 1))));
 494         }
 495
 496         gpe_block->initialized = TRUE;
 497
 498         return_ACPI_STATUS(AE_OK);
 499 }
 500
 501 #endif                          /* !ACPI_REDUCED_HARDWARE */