drivers/acpi/acpica/evxfgpe.c

   1 /******************************************************************************
   2  *
   3  * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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 #define EXPORT_ACPI_INTERFACES
  45
  46 #include <acpi/acpi.h>
  47 #include "accommon.h"
  48 #include "acevents.h"
  49 #include "acnamesp.h"
  50
  51 #define _COMPONENT          ACPI_EVENTS
  52 ACPI_MODULE_NAME("evxfgpe")
  53
  54 #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    acpi_update_all_gpes
  58  *
  59  * PARAMETERS:  None
  60  *
  61  * RETURN:      Status
  62  *
  63  * DESCRIPTION: Complete GPE initialization and enable all GPEs that have
  64  *              associated _Lxx or _Exx methods and are not pointed to by any
  65  *              device _PRW methods (this indicates that these GPEs are
  66  *              generally intended for system or device wakeup. Such GPEs
  67  *              have to be enabled directly when the devices whose _PRW
  68  *              methods point to them are set up for wakeup signaling.)
  69  *
  70  * NOTE: Should be called after any GPEs are added to the system. Primarily,
  71  * after the system _PRW methods have been run, but also after a GPE Block
  72  * Device has been added or if any new GPE methods have been added via a
  73  * dynamic table load.
  74  *
  75  ******************************************************************************/
  76
  77 acpi_status acpi_update_all_gpes(void)
  78 {
  79         acpi_status status;
  80
  81         ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
  82
  83         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
  84         if (ACPI_FAILURE(status)) {
  85                 return_ACPI_STATUS(status);
  86         }
  87
  88         if (acpi_gbl_all_gpes_initialized) {
  89                 goto unlock_and_exit;
  90         }
  91
  92         status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);
  93         if (ACPI_SUCCESS(status)) {
  94                 acpi_gbl_all_gpes_initialized = TRUE;
  95         }
  96
  97 unlock_and_exit:
  98         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
  99
 100         return_ACPI_STATUS(status);
 101 }
 102
 103 ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
 104
 105 /*******************************************************************************
 106  *
 107  * FUNCTION:    acpi_enable_gpe
 108  *
 109  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
 110  *              gpe_number      - GPE level within the GPE block
 111  *
 112  * RETURN:      Status
 113  *
 114  * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
 115  *              hardware-enabled.
 116  *
 117  ******************************************************************************/
 118
 119 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 120 {
 121         acpi_status status = AE_BAD_PARAMETER;
 122         struct acpi_gpe_event_info *gpe_event_info;
 123         acpi_cpu_flags flags;
 124
 125         ACPI_FUNCTION_TRACE(acpi_enable_gpe);
 126
 127         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 128
 129         /* Ensure that we have a valid GPE number */
 130
 131         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 132         if (gpe_event_info) {
 133                 status = acpi_ev_add_gpe_reference(gpe_event_info);
 134         }
 135
 136         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 137         return_ACPI_STATUS(status);
 138 }
 139 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
 140
 141 /*******************************************************************************
 142  *
 143  * FUNCTION:    acpi_disable_gpe
 144  *
 145  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
 146  *              gpe_number      - GPE level within the GPE block
 147  *
 148  * RETURN:      Status
 149  *
 150  * DESCRIPTION: Remove a reference to a GPE. When the last reference is
 151  *              removed, only then is the GPE disabled (for runtime GPEs), or
 152  *              the GPE mask bit disabled (for wake GPEs)
 153  *
 154  ******************************************************************************/
 155
 156 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
 157 {
 158         acpi_status status = AE_BAD_PARAMETER;
 159         struct acpi_gpe_event_info *gpe_event_info;
 160         acpi_cpu_flags flags;
 161
 162         ACPI_FUNCTION_TRACE(acpi_disable_gpe);
 163
 164         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 165
 166         /* Ensure that we have a valid GPE number */
 167
 168         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 169         if (gpe_event_info) {
 170                 status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
 171         }
 172
 173         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 174         return_ACPI_STATUS(status);
 175 }
 176
 177 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
 178
 179
 180 /*******************************************************************************
 181  *
 182  * FUNCTION:    acpi_setup_gpe_for_wake
 183  *
 184  * PARAMETERS:  wake_device         - Device associated with the GPE (via _PRW)
 185  *              gpe_device          - Parent GPE Device. NULL for GPE0/GPE1
 186  *              gpe_number          - GPE level within the GPE block
 187  *
 188  * RETURN:      Status
 189  *
 190  * DESCRIPTION: Mark a GPE as having the ability to wake the system. This
 191  *              interface is intended to be used as the host executes the
 192  *              _PRW methods (Power Resources for Wake) in the system tables.
 193  *              Each _PRW appears under a Device Object (The wake_device), and
 194  *              contains the info for the wake GPE associated with the
 195  *              wake_device.
 196  *
 197  ******************************************************************************/
 198 acpi_status
 199 acpi_setup_gpe_for_wake(acpi_handle wake_device,
 200                         acpi_handle gpe_device, u32 gpe_number)
 201 {
 202         acpi_status status;
 203         struct acpi_gpe_event_info *gpe_event_info;
 204         struct acpi_namespace_node *device_node;
 205         struct acpi_gpe_notify_info *notify;
 206         struct acpi_gpe_notify_info *new_notify;
 207         acpi_cpu_flags flags;
 208
 209         ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
 210
 211         /* Parameter Validation */
 212
 213         if (!wake_device) {
 214                 /*
 215                  * By forcing wake_device to be valid, we automatically enable the
 216                  * implicit notify feature on all hosts.
 217                  */
 218                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 219         }
 220
 221         /* Handle root object case */
 222
 223         if (wake_device == ACPI_ROOT_OBJECT) {
 224                 device_node = acpi_gbl_root_node;
 225         } else {
 226                 device_node =
 227                     ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
 228         }
 229
 230         /* Validate wake_device is of type Device */
 231
 232         if (device_node->type != ACPI_TYPE_DEVICE) {
 233                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 234         }
 235
 236         /*
 237          * Allocate a new notify object up front, in case it is needed.
 238          * Memory allocation while holding a spinlock is a big no-no
 239          * on some hosts.
 240          */
 241         new_notify = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_notify_info));
 242         if (!new_notify) {
 243                 return_ACPI_STATUS(AE_NO_MEMORY);
 244         }
 245
 246         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 247
 248         /* Ensure that we have a valid GPE number */
 249
 250         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 251         if (!gpe_event_info) {
 252                 status = AE_BAD_PARAMETER;
 253                 goto unlock_and_exit;
 254         }
 255
 256         /*
 257          * If there is no method or handler for this GPE, then the
 258          * wake_device will be notified whenever this GPE fires. This is
 259          * known as an "implicit notify". Note: The GPE is assumed to be
 260          * level-triggered (for windows compatibility).
 261          */
 262         if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
 263             ACPI_GPE_DISPATCH_NONE) {
 264                 /*
 265                  * This is the first device for implicit notify on this GPE.
 266                  * Just set the flags here, and enter the NOTIFY block below.
 267                  */
 268                 gpe_event_info->flags =
 269                     (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);
 270         }
 271
 272         /*
 273          * If we already have an implicit notify on this GPE, add
 274          * this device to the notify list.
 275          */
 276         if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
 277             ACPI_GPE_DISPATCH_NOTIFY) {
 278
 279                 /* Ensure that the device is not already in the list */
 280
 281                 notify = gpe_event_info->dispatch.notify_list;
 282                 while (notify) {
 283                         if (notify->device_node == device_node) {
 284                                 status = AE_ALREADY_EXISTS;
 285                                 goto unlock_and_exit;
 286                         }
 287                         notify = notify->next;
 288                 }
 289
 290                 /* Add this device to the notify list for this GPE */
 291
 292                 new_notify->device_node = device_node;
 293                 new_notify->next = gpe_event_info->dispatch.notify_list;
 294                 gpe_event_info->dispatch.notify_list = new_notify;
 295                 new_notify = NULL;
 296         }
 297
 298         /* Mark the GPE as a possible wake event */
 299
 300         gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
 301         status = AE_OK;
 302
 303 unlock_and_exit:
 304         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 305
 306         /* Delete the notify object if it was not used above */
 307
 308         if (new_notify) {
 309                 ACPI_FREE(new_notify);
 310         }
 311         return_ACPI_STATUS(status);
 312 }
 313 ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
 314
 315 /*******************************************************************************
 316  *
 317  * FUNCTION:    acpi_set_gpe_wake_mask
 318  *
 319  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
 320  *              gpe_number      - GPE level within the GPE block
 321  *              action              - Enable or Disable
 322  *
 323  * RETURN:      Status
 324  *
 325  * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
 326  *              already be marked as a WAKE GPE.
 327  *
 328  ******************************************************************************/
 329
 330 acpi_status
 331 acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
 332 {
 333         acpi_status status = AE_OK;
 334         struct acpi_gpe_event_info *gpe_event_info;
 335         struct acpi_gpe_register_info *gpe_register_info;
 336         acpi_cpu_flags flags;
 337         u32 register_bit;
 338
 339         ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
 340
 341         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 342
 343         /*
 344          * Ensure that we have a valid GPE number and that this GPE is in
 345          * fact a wake GPE
 346          */
 347         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 348         if (!gpe_event_info) {
 349                 status = AE_BAD_PARAMETER;
 350                 goto unlock_and_exit;
 351         }
 352
 353         if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
 354                 status = AE_TYPE;
 355                 goto unlock_and_exit;
 356         }
 357
 358         gpe_register_info = gpe_event_info->register_info;
 359         if (!gpe_register_info) {
 360                 status = AE_NOT_EXIST;
 361                 goto unlock_and_exit;
 362         }
 363
 364         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
 365
 366         /* Perform the action */
 367
 368         switch (action) {
 369         case ACPI_GPE_ENABLE:
 370
 371                 ACPI_SET_BIT(gpe_register_info->enable_for_wake,
 372                              (u8)register_bit);
 373                 break;
 374
 375         case ACPI_GPE_DISABLE:
 376
 377                 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
 378                                (u8)register_bit);
 379                 break;
 380
 381         default:
 382
 383                 ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
 384                 status = AE_BAD_PARAMETER;
 385                 break;
 386         }
 387
 388 unlock_and_exit:
 389         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 390         return_ACPI_STATUS(status);
 391 }
 392
 393 ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
 394
 395 /*******************************************************************************
 396  *
 397  * FUNCTION:    acpi_clear_gpe
 398  *
 399  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
 400  *              gpe_number      - GPE level within the GPE block
 401  *
 402  * RETURN:      Status
 403  *
 404  * DESCRIPTION: Clear an ACPI event (general purpose)
 405  *
 406  ******************************************************************************/
 407 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
 408 {
 409         acpi_status status = AE_OK;
 410         struct acpi_gpe_event_info *gpe_event_info;
 411         acpi_cpu_flags flags;
 412
 413         ACPI_FUNCTION_TRACE(acpi_clear_gpe);
 414
 415         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 416
 417         /* Ensure that we have a valid GPE number */
 418
 419         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 420         if (!gpe_event_info) {
 421                 status = AE_BAD_PARAMETER;
 422                 goto unlock_and_exit;
 423         }
 424
 425         status = acpi_hw_clear_gpe(gpe_event_info);
 426
 427       unlock_and_exit:
 428         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 429         return_ACPI_STATUS(status);
 430 }
 431
 432 ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
 433
 434 /*******************************************************************************
 435  *
 436  * FUNCTION:    acpi_get_gpe_status
 437  *
 438  * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
 439  *              gpe_number      - GPE level within the GPE block
 440  *              event_status        - Where the current status of the event
 441  *                                    will be returned
 442  *
 443  * RETURN:      Status
 444  *
 445  * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
 446  *
 447  ******************************************************************************/
 448 acpi_status
 449 acpi_get_gpe_status(acpi_handle gpe_device,
 450                     u32 gpe_number, acpi_event_status *event_status)
 451 {
 452         acpi_status status = AE_OK;
 453         struct acpi_gpe_event_info *gpe_event_info;
 454         acpi_cpu_flags flags;
 455
 456         ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
 457
 458         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 459
 460         /* Ensure that we have a valid GPE number */
 461
 462         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
 463         if (!gpe_event_info) {
 464                 status = AE_BAD_PARAMETER;
 465                 goto unlock_and_exit;
 466         }
 467
 468         /* Obtain status on the requested GPE number */
 469
 470         status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
 471
 472         if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
 473                 *event_status |= ACPI_EVENT_FLAG_HANDLE;
 474
 475 unlock_and_exit:
 476         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 477         return_ACPI_STATUS(status);
 478 }
 479
 480 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
 481
 482 /******************************************************************************
 483  *
 484  * FUNCTION:    acpi_disable_all_gpes
 485  *
 486  * PARAMETERS:  None
 487  *
 488  * RETURN:      Status
 489  *
 490  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
 491  *
 492  ******************************************************************************/
 493
 494 acpi_status acpi_disable_all_gpes(void)
 495 {
 496         acpi_status status;
 497
 498         ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
 499
 500         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 501         if (ACPI_FAILURE(status)) {
 502                 return_ACPI_STATUS(status);
 503         }
 504
 505         status = acpi_hw_disable_all_gpes();
 506         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 507
 508         return_ACPI_STATUS(status);
 509 }
 510
 511 ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
 512
 513 /******************************************************************************
 514  *
 515  * FUNCTION:    acpi_enable_all_runtime_gpes
 516  *
 517  * PARAMETERS:  None
 518  *
 519  * RETURN:      Status
 520  *
 521  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
 522  *
 523  ******************************************************************************/
 524
 525 acpi_status acpi_enable_all_runtime_gpes(void)
 526 {
 527         acpi_status status;
 528
 529         ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
 530
 531         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 532         if (ACPI_FAILURE(status)) {
 533                 return_ACPI_STATUS(status);
 534         }
 535
 536         status = acpi_hw_enable_all_runtime_gpes();
 537         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 538
 539         return_ACPI_STATUS(status);
 540 }
 541
 542 ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
 543
 544 /*******************************************************************************
 545  *
 546  * FUNCTION:    acpi_install_gpe_block
 547  *
 548  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
 549  *              gpe_block_address   - Address and space_ID
 550  *              register_count      - Number of GPE register pairs in the block
 551  *              interrupt_number    - H/W interrupt for the block
 552  *
 553  * RETURN:      Status
 554  *
 555  * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
 556  *              enabled here.
 557  *
 558  ******************************************************************************/
 559 acpi_status
 560 acpi_install_gpe_block(acpi_handle gpe_device,
 561                        struct acpi_generic_address *gpe_block_address,
 562                        u32 register_count, u32 interrupt_number)
 563 {
 564         acpi_status status;
 565         union acpi_operand_object *obj_desc;
 566         struct acpi_namespace_node *node;
 567         struct acpi_gpe_block_info *gpe_block;
 568
 569         ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
 570
 571         if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
 572                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 573         }
 574
 575         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 576         if (ACPI_FAILURE(status)) {
 577                 return_ACPI_STATUS(status);
 578         }
 579
 580         node = acpi_ns_validate_handle(gpe_device);
 581         if (!node) {
 582                 status = AE_BAD_PARAMETER;
 583                 goto unlock_and_exit;
 584         }
 585
 586         /* Validate the parent device */
 587
 588         if (node->type != ACPI_TYPE_DEVICE) {
 589                 status = AE_TYPE;
 590                 goto unlock_and_exit;
 591         }
 592
 593         if (node->object) {
 594                 status = AE_ALREADY_EXISTS;
 595                 goto unlock_and_exit;
 596         }
 597
 598         /*
 599          * For user-installed GPE Block Devices, the gpe_block_base_number
 600          * is always zero
 601          */
 602         status = acpi_ev_create_gpe_block(node, gpe_block_address->address,
 603                                           gpe_block_address->space_id,
 604                                           register_count, 0, interrupt_number,
 605                                           &gpe_block);
 606         if (ACPI_FAILURE(status)) {
 607                 goto unlock_and_exit;
 608         }
 609
 610         /* Install block in the device_object attached to the node */
 611
 612         obj_desc = acpi_ns_get_attached_object(node);
 613         if (!obj_desc) {
 614
 615                 /*
 616                  * No object, create a new one (Device nodes do not always have
 617                  * an attached object)
 618                  */
 619                 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
 620                 if (!obj_desc) {
 621                         status = AE_NO_MEMORY;
 622                         goto unlock_and_exit;
 623                 }
 624
 625                 status =
 626                     acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
 627
 628                 /* Remove local reference to the object */
 629
 630                 acpi_ut_remove_reference(obj_desc);
 631
 632                 if (ACPI_FAILURE(status)) {
 633                         goto unlock_and_exit;
 634                 }
 635         }
 636
 637         /* Now install the GPE block in the device_object */
 638
 639         obj_desc->device.gpe_block = gpe_block;
 640
 641 unlock_and_exit:
 642         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 643         return_ACPI_STATUS(status);
 644 }
 645
 646 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
 647
 648 /*******************************************************************************
 649  *
 650  * FUNCTION:    acpi_remove_gpe_block
 651  *
 652  * PARAMETERS:  gpe_device          - Handle to the parent GPE Block Device
 653  *
 654  * RETURN:      Status
 655  *
 656  * DESCRIPTION: Remove a previously installed block of GPE registers
 657  *
 658  ******************************************************************************/
 659 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
 660 {
 661         union acpi_operand_object *obj_desc;
 662         acpi_status status;
 663         struct acpi_namespace_node *node;
 664
 665         ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
 666
 667         if (!gpe_device) {
 668                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 669         }
 670
 671         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 672         if (ACPI_FAILURE(status)) {
 673                 return_ACPI_STATUS(status);
 674         }
 675
 676         node = acpi_ns_validate_handle(gpe_device);
 677         if (!node) {
 678                 status = AE_BAD_PARAMETER;
 679                 goto unlock_and_exit;
 680         }
 681
 682         /* Validate the parent device */
 683
 684         if (node->type != ACPI_TYPE_DEVICE) {
 685                 status = AE_TYPE;
 686                 goto unlock_and_exit;
 687         }
 688
 689         /* Get the device_object attached to the node */
 690
 691         obj_desc = acpi_ns_get_attached_object(node);
 692         if (!obj_desc || !obj_desc->device.gpe_block) {
 693                 return_ACPI_STATUS(AE_NULL_OBJECT);
 694         }
 695
 696         /* Delete the GPE block (but not the device_object) */
 697
 698         status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
 699         if (ACPI_SUCCESS(status)) {
 700                 obj_desc->device.gpe_block = NULL;
 701         }
 702
 703 unlock_and_exit:
 704         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 705         return_ACPI_STATUS(status);
 706 }
 707
 708 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
 709
 710 /*******************************************************************************
 711  *
 712  * FUNCTION:    acpi_get_gpe_device
 713  *
 714  * PARAMETERS:  index               - System GPE index (0-current_gpe_count)
 715  *              gpe_device          - Where the parent GPE Device is returned
 716  *
 717  * RETURN:      Status
 718  *
 719  * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
 720  *              gpe device indicates that the gpe number is contained in one of
 721  *              the FADT-defined gpe blocks. Otherwise, the GPE block device.
 722  *
 723  ******************************************************************************/
 724 acpi_status acpi_get_gpe_device(u32 index, acpi_handle * gpe_device)
 725 {
 726         struct acpi_gpe_device_info info;
 727         acpi_status status;
 728
 729         ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
 730
 731         if (!gpe_device) {
 732                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 733         }
 734
 735         if (index >= acpi_current_gpe_count) {
 736                 return_ACPI_STATUS(AE_NOT_EXIST);
 737         }
 738
 739         /* Setup and walk the GPE list */
 740
 741         info.index = index;
 742         info.status = AE_NOT_EXIST;
 743         info.gpe_device = NULL;
 744         info.next_block_base_index = 0;
 745
 746         status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
 747         if (ACPI_FAILURE(status)) {
 748                 return_ACPI_STATUS(status);
 749         }
 750
 751         *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
 752         return_ACPI_STATUS(info.status);
 753 }
 754
 755 ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
 756 #endif                          /* !ACPI_REDUCED_HARDWARE */