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                 this_register->status_address.bit_width =
 237                     ACPI_GPE_REGISTER_WIDTH;
 238                 this_register->enable_address.bit_width =
 239                     ACPI_GPE_REGISTER_WIDTH;
 240                 this_register->status_address.bit_offset = 0;
 241                 this_register->enable_address.bit_offset = 0;
 242
 243                 /* Init the event_info for each GPE within this register */
 244
 245                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 246                         this_event->gpe_number =
 247                             (u8) (this_register->base_gpe_number + j);
 248                         this_event->register_info = this_register;
 249                         this_event++;
 250                 }
 251
 252                 /* Disable all GPEs within this register */
 253
 254                 status = acpi_hw_write(0x00, &this_register->enable_address);
 255                 if (ACPI_FAILURE(status)) {
 256                         goto error_exit;
 257                 }
 258
 259                 /* Clear any pending GPE events within this register */
 260
 261                 status = acpi_hw_write(0xFF, &this_register->status_address);
 262                 if (ACPI_FAILURE(status)) {
 263                         goto error_exit;
 264                 }
 265
 266                 this_register++;
 267         }
 268
 269         return_ACPI_STATUS(AE_OK);
 270
 271 error_exit:
 272         if (gpe_register_info) {
 273                 ACPI_FREE(gpe_register_info);
 274         }
 275         if (gpe_event_info) {
 276                 ACPI_FREE(gpe_event_info);
 277         }
 278
 279         return_ACPI_STATUS(status);
 280 }
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    acpi_ev_create_gpe_block
 285  *
 286  * PARAMETERS:  gpe_device          - Handle to the parent GPE block
 287  *              gpe_block_address   - Address and space_ID
 288  *              register_count      - Number of GPE register pairs in the block
 289  *              gpe_block_base_number - Starting GPE number for the block
 290  *              interrupt_number    - H/W interrupt for the block
 291  *              return_gpe_block    - Where the new block descriptor is returned
 292  *
 293  * RETURN:      Status
 294  *
 295  * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
 296  *              the block are disabled at exit.
 297  *              Note: Assumes namespace is locked.
 298  *
 299  ******************************************************************************/
 300
 301 acpi_status
 302 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
 303                          u64 address,
 304                          u8 space_id,
 305                          u32 register_count,
 306                          u16 gpe_block_base_number,
 307                          u32 interrupt_number,
 308                          struct acpi_gpe_block_info **return_gpe_block)
 309 {
 310         acpi_status status;
 311         struct acpi_gpe_block_info *gpe_block;
 312         struct acpi_gpe_walk_info walk_info;
 313
 314         ACPI_FUNCTION_TRACE(ev_create_gpe_block);
 315
 316         if (!register_count) {
 317                 return_ACPI_STATUS(AE_OK);
 318         }
 319
 320         /* Allocate a new GPE block */
 321
 322         gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
 323         if (!gpe_block) {
 324                 return_ACPI_STATUS(AE_NO_MEMORY);
 325         }
 326
 327         /* Initialize the new GPE block */
 328
 329         gpe_block->address = address;
 330         gpe_block->space_id = space_id;
 331         gpe_block->node = gpe_device;
 332         gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
 333         gpe_block->initialized = FALSE;
 334         gpe_block->register_count = register_count;
 335         gpe_block->block_base_number = gpe_block_base_number;
 336
 337         /*
 338          * Create the register_info and event_info sub-structures
 339          * Note: disables and clears all GPEs in the block
 340          */
 341         status = acpi_ev_create_gpe_info_blocks(gpe_block);
 342         if (ACPI_FAILURE(status)) {
 343                 ACPI_FREE(gpe_block);
 344                 return_ACPI_STATUS(status);
 345         }
 346
 347         /* Install the new block in the global lists */
 348
 349         status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
 350         if (ACPI_FAILURE(status)) {
 351                 ACPI_FREE(gpe_block->register_info);
 352                 ACPI_FREE(gpe_block->event_info);
 353                 ACPI_FREE(gpe_block);
 354                 return_ACPI_STATUS(status);
 355         }
 356
 357         acpi_gbl_all_gpes_initialized = FALSE;
 358
 359         /* Find all GPE methods (_Lxx or_Exx) for this block */
 360
 361         walk_info.gpe_block = gpe_block;
 362         walk_info.gpe_device = gpe_device;
 363         walk_info.execute_by_owner_id = FALSE;
 364
 365         (void)acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
 366                                      ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
 367                                      acpi_ev_match_gpe_method, NULL, &walk_info,
 368                                      NULL);
 369
 370         /* Return the new block */
 371
 372         if (return_gpe_block) {
 373                 (*return_gpe_block) = gpe_block;
 374         }
 375
 376         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
 377                               "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
 378                               (u32)gpe_block->block_base_number,
 379                               (u32)(gpe_block->block_base_number +
 380                                     (gpe_block->gpe_count - 1)),
 381                               gpe_device->name.ascii, gpe_block->register_count,
 382                               interrupt_number,
 383                               interrupt_number ==
 384                               acpi_gbl_FADT.sci_interrupt ? " (SCI)" : ""));
 385
 386         /* Update global count of currently available GPEs */
 387
 388         acpi_current_gpe_count += gpe_block->gpe_count;
 389         return_ACPI_STATUS(AE_OK);
 390 }
 391
 392 /*******************************************************************************
 393  *
 394  * FUNCTION:    acpi_ev_initialize_gpe_block
 395  *
 396  * PARAMETERS:  acpi_gpe_callback
 397  *
 398  * RETURN:      Status
 399  *
 400  * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
 401  *              associated methods.
 402  *              Note: Assumes namespace is locked.
 403  *
 404  ******************************************************************************/
 405
 406 acpi_status
 407 acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 408                              struct acpi_gpe_block_info *gpe_block,
 409                              void *context)
 410 {
 411         acpi_status status;
 412         struct acpi_gpe_event_info *gpe_event_info;
 413         u32 gpe_enabled_count;
 414         u32 gpe_index;
 415         u32 i;
 416         u32 j;
 417         u8 *is_polling_needed = context;
 418         ACPI_ERROR_ONLY(u32 gpe_number);
 419
 420         ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
 421
 422         /*
 423          * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
 424          * any GPE blocks that have been initialized already.
 425          */
 426         if (!gpe_block || gpe_block->initialized) {
 427                 return_ACPI_STATUS(AE_OK);
 428         }
 429
 430         /*
 431          * Enable all GPEs that have a corresponding method and have the
 432          * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
 433          * must be enabled via the acpi_enable_gpe() interface.
 434          */
 435         gpe_enabled_count = 0;
 436
 437         for (i = 0; i < gpe_block->register_count; i++) {
 438                 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 439
 440                         /* Get the info block for this particular GPE */
 441
 442                         gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j;
 443                         gpe_event_info = &gpe_block->event_info[gpe_index];
 444                         ACPI_ERROR_ONLY(gpe_number =
 445                                         gpe_block->block_base_number +
 446                                         gpe_index);
 447                         gpe_event_info->flags |= ACPI_GPE_INITIALIZED;
 448
 449                         /*
 450                          * Ignore GPEs that have no corresponding _Lxx/_Exx method
 451                          * and GPEs that are used for wakeup
 452                          */
 453                         if ((ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
 454                              ACPI_GPE_DISPATCH_METHOD)
 455                             || (gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
 456                                 continue;
 457                         }
 458
 459                         status = acpi_ev_add_gpe_reference(gpe_event_info, FALSE);
 460                         if (ACPI_FAILURE(status)) {
 461                                 ACPI_EXCEPTION((AE_INFO, status,
 462                                         "Could not enable GPE 0x%02X",
 463                                         gpe_number));
 464                                 continue;
 465                         }
 466
 467                         gpe_event_info->flags |= ACPI_GPE_AUTO_ENABLED;
 468
 469                         if (is_polling_needed &&
 470                             ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
 471                                 *is_polling_needed = TRUE;
 472                         }
 473
 474                         gpe_enabled_count++;
 475                 }
 476         }
 477
 478         if (gpe_enabled_count) {
 479                 ACPI_INFO(("Enabled %u GPEs in block %02X to %02X",
 480                            gpe_enabled_count, (u32)gpe_block->block_base_number,
 481                            (u32)(gpe_block->block_base_number +
 482                                  (gpe_block->gpe_count - 1))));
 483         }
 484
 485         gpe_block->initialized = TRUE;
 486
 487         return_ACPI_STATUS(AE_OK);
 488 }
 489
 490 #endif                          /* !ACPI_REDUCED_HARDWARE */