ACPICA: Minimize the differences between linux GPE code and ACPICA code base

We have ported Rafael's major GPE changes
(ACPI: Use GPE reference counting to support shared GPEs) into ACPICA code base.
But the port and Rafael's original patch have some differences, so we made
below patch to make linux GPE code consistent with ACPICA code base.

Most changes are about comments and coding styles.
Other noticeable changes are based on:

Rafael: Reduce code duplication related to GPE lookup
https://patchwork.kernel.org/patch/86237/

Rafael: Always use the same lock for GPE locking
https://patchwork.kernel.org/patch/90471/

A new field gpe_count in struct acpi_gpe_block_info to record the number
of individual GPEs in block.

Rename acpi_ev_save_method_info to acpi_ev_match_gpe_method.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Robert Moore <robert.moore@intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 109 insertions, 44 deletions

diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index b9d50ef9f3ec..deb26f4c6623 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -60,7 +60,8 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Updates GPE register enable masks based on the GPE type
+ * DESCRIPTION: Updates GPE register enable masks based upon whether there are
+ *              references (either wake or run) to this GPE
  *
  ******************************************************************************/
 
@@ -81,14 +82,20 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
             (1 <<
              (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number));
 
+        /* Clear the wake/run bits up front */
+
         ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit);
         ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
 
-        if (gpe_event_info->runtime_count)
+        /* Set the mask bits only if there are references to this GPE */
+
+        if (gpe_event_info->runtime_count) {
                 ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
+        }
 
-        if (gpe_event_info->wakeup_count)
+        if (gpe_event_info->wakeup_count) {
                 ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
+        }
 
         return_ACPI_STATUS(AE_OK);
 }
@@ -101,7 +108,10 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable a GPE based on the GPE type
+ * DESCRIPTION: Hardware-enable a GPE. Always enables the GPE, regardless
+ *              of type or number of references.
+ *
+ * Note: The GPE lock should be already acquired when this function is called.
  *
  ******************************************************************************/
 
@@ -109,20 +119,36 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 {
         acpi_status status;
 
+
         ACPI_FUNCTION_TRACE(ev_enable_gpe);
 
-        /* Make sure HW enable masks are updated */
+
+        /*
+         * We will only allow a GPE to be enabled if it has either an
+         * associated method (_Lxx/_Exx) or a handler. Otherwise, the
+         * GPE will be immediately disabled by acpi_ev_gpe_dispatch the
+         * first time it fires.
+         */
+        if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)) {
+                return_ACPI_STATUS(AE_NO_HANDLER);
+        }
+
+        /* Ensure the HW enable masks are current */
 
         status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
-        if (ACPI_FAILURE(status))
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
+        }
+
+        /* Clear the GPE (of stale events) */
 
-        /* Clear the GPE (of stale events), then enable it */
         status = acpi_hw_clear_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status))
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
+        }
 
         /* Enable the requested GPE */
+
         status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
         return_ACPI_STATUS(status);
 }
@@ -135,7 +161,10 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disable a GPE based on the GPE type
+ * DESCRIPTION: Hardware-disable a GPE. Always disables the requested GPE,
+ *              regardless of the type or number of references.
+ *
+ * Note: The GPE lock should be already acquired when this function is called.
  *
  ******************************************************************************/
 
@@ -145,24 +174,71 @@ acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
         ACPI_FUNCTION_TRACE(ev_disable_gpe);
 
-        /* Make sure HW enable masks are updated */
+
+        /*
+         * Note: Always disable the GPE, even if we think that that it is already
+         * disabled. It is possible that the AML or some other code has enabled
+         * the GPE behind our back.
+         */
+
+        /* Ensure the HW enable masks are current */
 
         status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
-        if (ACPI_FAILURE(status))
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
+        }
 
         /*
-         * Even if we don't know the GPE type, make sure that we always
-         * disable it. low_disable_gpe will just clear the enable bit for this
-         * GPE and write it. It will not write out the current GPE enable mask,
-         * since this may inadvertently enable GPEs too early, if a rogue GPE has
-         * come in during ACPICA initialization - possibly as a result of AML or
-         * other code that has enabled the GPE.
+         * Always H/W disable this GPE, even if we don't know the GPE type.
+         * Simply clear the enable bit for this particular GPE, but do not
+         * write out the current GPE enable mask since this may inadvertently
+         * enable GPEs too early. An example is a rogue GPE that has arrived
+         * during ACPICA initialization - possibly because AML or other code
+         * has enabled the GPE.
          */
         status = acpi_hw_low_disable_gpe(gpe_event_info);
         return_ACPI_STATUS(status);
 }
 
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_low_get_gpe_info
+ *
+ * PARAMETERS:  gpe_number          - Raw GPE number
+ *              gpe_block           - A GPE info block
+ *
+ * RETURN:      A GPE event_info struct. NULL if not a valid GPE (The gpe_number
+ *              is not within the specified GPE block)
+ *
+ * DESCRIPTION: Returns the event_info struct associated with this GPE. This is
+ *              the low-level implementation of ev_get_gpe_event_info.
+ *
+ ******************************************************************************/
+
+struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
+                                                     struct acpi_gpe_block_info
+                                                     *gpe_block)
+{
+        u32 gpe_index;
+
+        /*
+         * Validate that the gpe_number is within the specified gpe_block.
+         * (Two steps)
+         */
+        if (!gpe_block || (gpe_number < gpe_block->block_base_number)) {
+                return (NULL);
+        }
+
+        gpe_index = gpe_number - gpe_block->block_base_number;
+        if (gpe_index >= gpe_block->gpe_count) {
+                return (NULL);
+        }
+
+        return (&gpe_block->event_info[gpe_index]);
+}
+
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_get_gpe_event_info
@@ -184,7 +260,7 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
                                                        u32 gpe_number)
 {
         union acpi_operand_object *obj_desc;
-        struct acpi_gpe_block_info *gpe_block;
+        struct acpi_gpe_event_info *gpe_info;
         u32 i;
 
         ACPI_FUNCTION_ENTRY();
@@ -196,17 +272,11 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
                 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
 
                 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
-                        gpe_block = acpi_gbl_gpe_fadt_blocks[i];
-                        if (gpe_block) {
-                                if ((gpe_number >= gpe_block->block_base_number)
-                                    && (gpe_number <
-                                        gpe_block->block_base_number +
-                                        (gpe_block->register_count * 8))) {
-                                        return (&gpe_block->
-                                                event_info[gpe_number -
-                                                           gpe_block->
-                                                           block_base_number]);
-                                }
+                        gpe_info = acpi_ev_low_get_gpe_info(gpe_number,
+                                                            acpi_gbl_gpe_fadt_blocks
+                                                            [i]);
+                        if (gpe_info) {
+                                return (gpe_info);
                         }
                 }
 
@@ -223,16 +293,8 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
                 return (NULL);
         }
 
-        gpe_block = obj_desc->device.gpe_block;
-
-        if ((gpe_number >= gpe_block->block_base_number) &&
-            (gpe_number <
-             gpe_block->block_base_number + (gpe_block->register_count * 8))) {
-                return (&gpe_block->
-                        event_info[gpe_number - gpe_block->block_base_number]);
-        }
-
-        return (NULL);
+        return (acpi_ev_low_get_gpe_info
+                (gpe_number, obj_desc->device.gpe_block));
 }
 
 /*******************************************************************************
@@ -389,7 +451,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
                 return_VOID;
         }
 
-        /* Set the GPE flags for return to enabled state */
+        /* Update the GPE register masks for return to enabled state */
 
         (void)acpi_ev_update_gpe_enable_masks(gpe_event_info);
 
@@ -569,15 +631,18 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
 
         default:
 
-                /* No handler or method to run! */
-
+                /*
+                 * No handler or method to run!
+                 * 03/2010: This case should no longer be possible. We will not allow
+                 * a GPE to be enabled if it has no handler or method.
+                 */
                 ACPI_ERROR((AE_INFO,
                             "No handler or method for GPE[0x%2X], disabling event",
                             gpe_number));
 
                 /*
-                 * Disable the GPE. The GPE will remain disabled until the ACPICA
-                 * Core Subsystem is restarted, or a handler is installed.
+                 * Disable the GPE. The GPE will remain disabled a handler
+                 * is installed or ACPICA is restarted.
                  */
                 status = acpi_ev_disable_gpe(gpe_event_info);
                 if (ACPI_FAILURE(status)) {