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, 113 insertions, 78 deletions

diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index 5ff32c78ea2d..7c7bbb4d402c 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -203,21 +203,26 @@ ACPI_EXPORT_SYMBOL(acpi_enable_event)
  *
  * FUNCTION:    acpi_set_gpe
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device
+ * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
  *              gpe_number      - GPE level within the GPE block
- *              action          - Enable or disable
- *                                Called from ISR or not
+ *              action          - ACPI_GPE_ENABLE or ACPI_GPE_DISABLE
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable or disable an ACPI event (general purpose)
+ * DESCRIPTION: Enable or disable an individual GPE. This function bypasses
+ *              the reference count mechanism used in the acpi_enable_gpe and
+ *              acpi_disable_gpe interfaces -- and should be used with care.
+ *
+ * Note: Typically used to disable a runtime GPE for short period of time,
+ * then re-enable it, without disturbing the existing reference counts. This
+ * is useful, for example, in the Embedded Controller (EC) driver.
  *
  ******************************************************************************/
 acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action)
 {
-        acpi_status status = AE_OK;
-        acpi_cpu_flags flags;
         struct acpi_gpe_event_info *gpe_event_info;
+        acpi_status status;
+        acpi_cpu_flags flags;
 
         ACPI_FUNCTION_TRACE(acpi_set_gpe);
 
@@ -243,7 +248,6 @@ acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action)
                 break;
 
         default:
-                ACPI_ERROR((AE_INFO, "Invalid action\n"));
                 status = AE_BAD_PARAMETER;
                 break;
         }
@@ -259,25 +263,31 @@ ACPI_EXPORT_SYMBOL(acpi_set_gpe)
  *
  * FUNCTION:    acpi_enable_gpe
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device
+ * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
  *              gpe_number      - GPE level within the GPE block
- *              type            - Purpose the GPE will be used for
+ *              gpe_type        - ACPI_GPE_TYPE_RUNTIME or ACPI_GPE_TYPE_WAKE
+ *                                or both
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Take a reference to a GPE and enable it if necessary
+ * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
+ *              hardware-enabled (for runtime GPEs), or the GPE register mask
+ *              is updated (for wake GPEs).
  *
  ******************************************************************************/
-acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
+acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 gpe_type)
 {
         acpi_status status = AE_OK;
-        acpi_cpu_flags flags;
         struct acpi_gpe_event_info *gpe_event_info;
+        acpi_cpu_flags flags;
 
         ACPI_FUNCTION_TRACE(acpi_enable_gpe);
 
-        if (type & ~ACPI_GPE_TYPE_WAKE_RUN)
+        /* Parameter validation */
+
+        if (!gpe_type || (gpe_type & ~ACPI_GPE_TYPE_WAKE_RUN)) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
+        }
 
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
@@ -289,26 +299,43 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
                 goto unlock_and_exit;
         }
 
-        if (type & ACPI_GPE_TYPE_RUNTIME) {
-                if (++gpe_event_info->runtime_count == 1) {
+        if (gpe_type & ACPI_GPE_TYPE_RUNTIME) {
+                if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
+                        status = AE_LIMIT;      /* Too many references */
+                        goto unlock_and_exit;
+                }
+
+                gpe_event_info->runtime_count++;
+                if (gpe_event_info->runtime_count == 1) {
                         status = acpi_ev_enable_gpe(gpe_event_info);
-                        if (ACPI_FAILURE(status))
+                        if (ACPI_FAILURE(status)) {
                                 gpe_event_info->runtime_count--;
+                                goto unlock_and_exit;
+                        }
                 }
         }
 
-        if (type & ACPI_GPE_TYPE_WAKE) {
+        if (gpe_type & ACPI_GPE_TYPE_WAKE) {
+                /* The GPE must have the ability to wake the system */
+
                 if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
-                        status = AE_BAD_PARAMETER;
+                        status = AE_TYPE;
+                        goto unlock_and_exit;
+                }
+
+                if (gpe_event_info->wakeup_count == ACPI_UINT8_MAX) {
+                        status = AE_LIMIT;      /* Too many references */
                         goto unlock_and_exit;
                 }
 
                 /*
-                 * Wake-up GPEs are only enabled right prior to putting the
-                 * system into a sleep state.
+                 * Update the enable mask on the first wakeup reference. Wake GPEs
+                 * are only hardware-enabled just before sleeping.
                  */
-                if (++gpe_event_info->wakeup_count == 1)
-                        acpi_ev_update_gpe_enable_masks(gpe_event_info);
+                gpe_event_info->wakeup_count++;
+                if (gpe_event_info->wakeup_count == 1) {
+                        (void)acpi_ev_update_gpe_enable_masks(gpe_event_info);
+                }
         }
 
 unlock_and_exit:
@@ -321,27 +348,34 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
  *
  * FUNCTION:    acpi_disable_gpe
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device
+ * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
  *              gpe_number      - GPE level within the GPE block
- *              type            - Purpose the GPE won't be used for any more
+ *              gpe_type        - ACPI_GPE_TYPE_RUNTIME or ACPI_GPE_TYPE_WAKE
+ *                                or both
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Release a reference to a GPE and disable it if necessary
+ * DESCRIPTION: Remove a reference to a GPE. When the last reference is
+ *              removed, only then is the GPE disabled (for runtime GPEs), or
+ *              the GPE mask bit disabled (for wake GPEs)
  *
  ******************************************************************************/
-acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
+acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 gpe_type)
 {
         acpi_status status = AE_OK;
-        acpi_cpu_flags flags;
         struct acpi_gpe_event_info *gpe_event_info;
+        acpi_cpu_flags flags;
 
         ACPI_FUNCTION_TRACE(acpi_disable_gpe);
 
-        if (type & ~ACPI_GPE_TYPE_WAKE_RUN)
+        /* Parameter validation */
+
+        if (!gpe_type || (gpe_type & ~ACPI_GPE_TYPE_WAKE_RUN)) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
+        }
 
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
+
         /* Ensure that we have a valid GPE number */
 
         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
@@ -350,18 +384,39 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
                 goto unlock_and_exit;
         }
 
-        if ((type & ACPI_GPE_TYPE_RUNTIME) && gpe_event_info->runtime_count) {
-                if (--gpe_event_info->runtime_count == 0)
+        /* Hardware-disable a runtime GPE on removal of the last reference */
+
+        if (gpe_type & ACPI_GPE_TYPE_RUNTIME) {
+                if (!gpe_event_info->runtime_count) {
+                        status = AE_LIMIT;      /* There are no references to remove */
+                        goto unlock_and_exit;
+                }
+
+                gpe_event_info->runtime_count--;
+                if (!gpe_event_info->runtime_count) {
                         status = acpi_ev_disable_gpe(gpe_event_info);
+                        if (ACPI_FAILURE(status)) {
+                                gpe_event_info->runtime_count++;
+                                goto unlock_and_exit;
+                        }
+                }
         }
 
-        if ((type & ACPI_GPE_TYPE_WAKE) && gpe_event_info->wakeup_count) {
-                /*
-                 * Wake-up GPEs are not enabled after leaving system sleep
-                 * states, so we don't need to disable them here.
-                 */
-                if (--gpe_event_info->wakeup_count == 0)
-                        acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        /*
+         * Update masks for wake GPE on removal of the last reference.
+         * No need to hardware-disable wake GPEs here, they are not currently
+         * enabled.
+         */
+        if (gpe_type & ACPI_GPE_TYPE_WAKE) {
+                if (!gpe_event_info->wakeup_count) {
+                        status = AE_LIMIT;      /* There are no references to remove */
+                        goto unlock_and_exit;
+                }
+
+                gpe_event_info->wakeup_count--;
+                if (!gpe_event_info->wakeup_count) {
+                        (void)acpi_ev_update_gpe_enable_masks(gpe_event_info);
+                }
         }
 
 unlock_and_exit:
@@ -465,30 +520,23 @@ ACPI_EXPORT_SYMBOL(acpi_clear_event)
  *
  * FUNCTION:    acpi_clear_gpe
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device
+ * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Called from an ISR or not
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Clear an ACPI event (general purpose)
  *
  ******************************************************************************/
-acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
+acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
         acpi_status status = AE_OK;
         struct acpi_gpe_event_info *gpe_event_info;
+        acpi_cpu_flags flags;
 
         ACPI_FUNCTION_TRACE(acpi_clear_gpe);
 
-        /* Use semaphore lock if not executing at interrupt level */
-
-        if (flags & ACPI_NOT_ISR) {
-                status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
-                if (ACPI_FAILURE(status)) {
-                        return_ACPI_STATUS(status);
-                }
-        }
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Ensure that we have a valid GPE number */
 
@@ -501,9 +549,7 @@ acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
         status = acpi_hw_clear_gpe(gpe_event_info);
 
       unlock_and_exit:
-        if (flags & ACPI_NOT_ISR) {
-                (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
-        }
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
 
@@ -569,9 +615,8 @@ ACPI_EXPORT_SYMBOL(acpi_get_event_status)
  *
  * FUNCTION:    acpi_get_gpe_status
  *
- * PARAMETERS:  gpe_device      - Parent GPE Device
+ * PARAMETERS:  gpe_device      - Parent GPE Device. NULL for GPE0/GPE1
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Called from an ISR or not
  *              event_status    - Where the current status of the event will
  *                                be returned
  *
@@ -582,21 +627,15 @@ ACPI_EXPORT_SYMBOL(acpi_get_event_status)
  ******************************************************************************/
 acpi_status
 acpi_get_gpe_status(acpi_handle gpe_device,
-                    u32 gpe_number, u32 flags, acpi_event_status * event_status)
+                    u32 gpe_number, acpi_event_status *event_status)
 {
         acpi_status status = AE_OK;
         struct acpi_gpe_event_info *gpe_event_info;
+        acpi_cpu_flags flags;
 
         ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
 
-        /* Use semaphore lock if not executing at interrupt level */
-
-        if (flags & ACPI_NOT_ISR) {
-                status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
-                if (ACPI_FAILURE(status)) {
-                        return_ACPI_STATUS(status);
-                }
-        }
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Ensure that we have a valid GPE number */
 
@@ -614,9 +653,7 @@ acpi_get_gpe_status(acpi_handle gpe_device,
                 *event_status |= ACPI_EVENT_FLAG_HANDLE;
 
       unlock_and_exit:
-        if (flags & ACPI_NOT_ISR) {
-                (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
-        }
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
 
@@ -673,20 +710,15 @@ acpi_install_gpe_block(acpi_handle gpe_device,
                 goto unlock_and_exit;
         }
 
-        /* Run the _PRW methods and enable the GPEs */
-
-        status = acpi_ev_initialize_gpe_block(node, gpe_block);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
-        /* Get the device_object attached to the node */
+        /* Install block in the device_object attached to the node */
 
         obj_desc = acpi_ns_get_attached_object(node);
         if (!obj_desc) {
 
-                /* No object, create a new one */
-
+                /*
+                 * No object, create a new one (Device nodes do not always have
+                 * an attached object)
+                 */
                 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
                 if (!obj_desc) {
                         status = AE_NO_MEMORY;
@@ -705,10 +737,14 @@ acpi_install_gpe_block(acpi_handle gpe_device,
                 }
         }
 
-        /* Install the GPE block in the device_object */
+        /* Now install the GPE block in the device_object */
 
         obj_desc->device.gpe_block = gpe_block;
 
+        /* Run the _PRW methods and enable the runtime GPEs in the new block */
+
+        status = acpi_ev_initialize_gpe_block(node, gpe_block);
+
       unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_ACPI_STATUS(status);
@@ -839,8 +875,7 @@ acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 
         /* Increment Index by the number of GPEs in this block */
 
-        info->next_block_base_index +=
-            (gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH);
+        info->next_block_base_index += gpe_block->gpe_count;
 
         if (info->index < info->next_block_base_index) {
                 /*