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

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