Merge with mainline to remove plat-omap/Kconfig conflict

Conflicts:
	arch/arm/plat-omap/Kconfig

8 files changed, 276 insertions, 283 deletions

diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 0bba148a2c61..4ced54f7a5d9 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -76,12 +76,9 @@ acpi_ev_queue_notify_request(struct acpi_namespace_node *node,
  * evgpe - GPE handling and dispatch
  */
 acpi_status
-acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
-                                u8 type);
+acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info);
 
-acpi_status
-acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
-                   u8 write_to_hardware);
+acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
@@ -122,9 +119,6 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info,
 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list);
 
 acpi_status
-acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type);
-
-acpi_status
 acpi_ev_check_for_wake_only_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_gpe_initialize(void);
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 81e64f478679..13cb80caacde 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -426,6 +426,8 @@ struct acpi_gpe_event_info {
         struct acpi_gpe_register_info *register_info;   /* Backpointer to register info */
         u8 flags;               /* Misc info about this GPE */
         u8 gpe_number;          /* This GPE */
+        u8 runtime_count;
+        u8 wakeup_count;
 };
 
 /* Information about a GPE register pair, one per each status/enable pair in an array */
diff --git a/drivers/acpi/acpica/acobject.h b/drivers/acpi/acpica/acobject.h
index 64062b1be3ee..07f6e2ea2ee5 100644
--- a/drivers/acpi/acpica/acobject.h
+++ b/drivers/acpi/acpica/acobject.h
@@ -287,8 +287,10 @@ struct acpi_object_buffer_field {
 
 struct acpi_object_notify_handler {
         ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *node;     /* Parent device */
+        u32 handler_type;
         acpi_notify_handler handler;
         void *context;
+        struct acpi_object_notify_handler *next;
 };
 
 struct acpi_object_addr_handler {
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index afacf4416c73..0b453467a5a0 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -54,54 +54,9 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ev_set_gpe_type
- *
- * PARAMETERS:  gpe_event_info          - GPE to set
- *              Type                    - New type
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Sets the new type for the GPE (wake, run, or wake/run)
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_set_gpe_type);
-
-        /* Validate type and update register enable masks */
-
-        switch (type) {
-        case ACPI_GPE_TYPE_WAKE:
-        case ACPI_GPE_TYPE_RUNTIME:
-        case ACPI_GPE_TYPE_WAKE_RUN:
-                break;
-
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
-
-        /* Disable the GPE if currently enabled */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-
-        /* Clear the type bits and insert the new Type */
-
-        gpe_event_info->flags &= ~ACPI_GPE_TYPE_MASK;
-        gpe_event_info->flags |= type;
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_ev_update_gpe_enable_masks
  *
  * PARAMETERS:  gpe_event_info          - GPE to update
- *              Type                    - What to do: ACPI_GPE_DISABLE or
- *                                        ACPI_GPE_ENABLE
  *
  * RETURN:      Status
  *
@@ -110,8 +65,7 @@ acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type)
  ******************************************************************************/
 
 acpi_status
-acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
-                                u8 type)
+acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
 {
         struct acpi_gpe_register_info *gpe_register_info;
         u8 register_bit;
@@ -127,37 +81,14 @@ 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));
 
-        /* 1) Disable case. Simply clear all enable bits */
-
-        if (type == ACPI_GPE_DISABLE) {
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
-                               register_bit);
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        /* 2) Enable case. Set/Clear the appropriate enable bits */
+        ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit);
+        ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
 
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-                ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
-
-        case ACPI_GPE_TYPE_RUNTIME:
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
-                               register_bit);
+        if (gpe_event_info->runtime_count)
                 ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
 
-        case ACPI_GPE_TYPE_WAKE_RUN:
+        if (gpe_event_info->wakeup_count)
                 ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
-                ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
-
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
 
         return_ACPI_STATUS(AE_OK);
 }
@@ -167,8 +98,6 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
  * FUNCTION:    acpi_ev_enable_gpe
  *
  * PARAMETERS:  gpe_event_info          - GPE to enable
- *              write_to_hardware       - Enable now, or just mark data structs
- *                                        (WAKE GPEs should be deferred)
  *
  * RETURN:      Status
  *
@@ -176,9 +105,7 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
  *
  ******************************************************************************/
 
-acpi_status
-acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
-                   u8 write_to_hardware)
+acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 {
         acpi_status status;
 
@@ -186,47 +113,20 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
 
         /* Make sure HW enable masks are updated */
 
-        status =
-            acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_ENABLE);
-        if (ACPI_FAILURE(status)) {
+        status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        if (ACPI_FAILURE(status))
                 return_ACPI_STATUS(status);
-        }
 
         /* Mark wake-enabled or HW enable, or both */
 
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-                break;
-
-        case ACPI_GPE_TYPE_WAKE_RUN:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-
-                /*lint -fallthrough */
-
-        case ACPI_GPE_TYPE_RUNTIME:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
-
-                if (write_to_hardware) {
-
-                        /* Clear the GPE (of stale events), then enable it */
-
-                        status = acpi_hw_clear_gpe(gpe_event_info);
-                        if (ACPI_FAILURE(status)) {
-                                return_ACPI_STATUS(status);
-                        }
-
-                        /* Enable the requested runtime GPE */
-
-                        status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
-                }
-                break;
+        if (gpe_event_info->runtime_count) {
+                /* Clear the GPE (of stale events), then enable it */
+                status = acpi_hw_clear_gpe(gpe_event_info);
+                if (ACPI_FAILURE(status))
+                        return_ACPI_STATUS(status);
 
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                /* Enable the requested runtime GPE */
+                status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
         }
 
         return_ACPI_STATUS(AE_OK);
@@ -252,34 +152,9 @@ acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
         /* Make sure HW enable masks are updated */
 
-        status =
-            acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_DISABLE);
-        if (ACPI_FAILURE(status)) {
+        status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        if (ACPI_FAILURE(status))
                 return_ACPI_STATUS(status);
-        }
-
-        /* Clear the appropriate enabled flags for this GPE */
-
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-                break;
-
-        case ACPI_GPE_TYPE_WAKE_RUN:
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-
-                /* fallthrough */
-
-        case ACPI_GPE_TYPE_RUNTIME:
-
-                /* Disable the requested runtime GPE */
-
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
-                break;
-
-        default:
-                break;
-        }
 
         /*
          * Even if we don't know the GPE type, make sure that we always
@@ -521,7 +396,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
 
         /* Set the GPE flags for return to enabled state */
 
-        (void)acpi_ev_enable_gpe(gpe_event_info, FALSE);
+        (void)acpi_ev_update_gpe_enable_masks(gpe_event_info);
 
         /*
          * Take a snapshot of the GPE info for this level - we copy the info to
diff --git a/drivers/acpi/acpica/evgpeblk.c b/drivers/acpi/acpica/evgpeblk.c
index 247920900187..3d4c4aca11cd 100644
--- a/drivers/acpi/acpica/evgpeblk.c
+++ b/drivers/acpi/acpica/evgpeblk.c
@@ -258,7 +258,6 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
         u32 gpe_number;
         char name[ACPI_NAME_SIZE + 1];
         u8 type;
-        acpi_status status;
 
         ACPI_FUNCTION_TRACE(ev_save_method_info);
 
@@ -325,26 +324,20 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
 
         /*
          * Now we can add this information to the gpe_event_info block for use
-         * during dispatch of this GPE. Default type is RUNTIME, although this may
-         * change when the _PRW methods are executed later.
+         * during dispatch of this GPE.
          */
         gpe_event_info =
             &gpe_block->event_info[gpe_number - gpe_block->block_base_number];
 
-        gpe_event_info->flags = (u8)
-            (type | ACPI_GPE_DISPATCH_METHOD | ACPI_GPE_TYPE_RUNTIME);
+        gpe_event_info->flags = (u8) (type | ACPI_GPE_DISPATCH_METHOD);
 
         gpe_event_info->dispatch.method_node =
             (struct acpi_namespace_node *)obj_handle;
 
-        /* Update enable mask, but don't enable the HW GPE as of yet */
-
-        status = acpi_ev_enable_gpe(gpe_event_info, FALSE);
-
         ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
                           "Registered GPE method %s as GPE number 0x%.2X\n",
                           name, gpe_number));
-        return_ACPI_STATUS(status);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -454,20 +447,7 @@ acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
                                                         gpe_block->
                                                         block_base_number];
 
-                /* Mark GPE for WAKE-ONLY but WAKE_DISABLED */
-
-                gpe_event_info->flags &=
-                    ~(ACPI_GPE_WAKE_ENABLED | ACPI_GPE_RUN_ENABLED);
-
-                status =
-                    acpi_ev_set_gpe_type(gpe_event_info, ACPI_GPE_TYPE_WAKE);
-                if (ACPI_FAILURE(status)) {
-                        goto cleanup;
-                }
-
-                status =
-                    acpi_ev_update_gpe_enable_masks(gpe_event_info,
-                                                    ACPI_GPE_DISABLE);
+                gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
         }
 
       cleanup:
@@ -989,7 +969,6 @@ acpi_status
 acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                              struct acpi_gpe_block_info *gpe_block)
 {
-        acpi_status status;
         struct acpi_gpe_event_info *gpe_event_info;
         struct acpi_gpe_walk_info gpe_info;
         u32 wake_gpe_count;
@@ -1019,42 +998,50 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                 gpe_info.gpe_block = gpe_block;
                 gpe_info.gpe_device = gpe_device;
 
-                status =
-                    acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                                            ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
                                            acpi_ev_match_prw_and_gpe, NULL,
                                            &gpe_info, NULL);
         }
 
         /*
-         * Enable all GPEs in this block that have these attributes:
-         * 1) are "runtime" or "run/wake" GPEs, and
-         * 2) have a corresponding _Lxx or _Exx method
-         *
-         * Any other GPEs within this block must be enabled via the
-         * acpi_enable_gpe() external interface.
+         * Enable all GPEs that have a corresponding method and aren't
+         * capable of generating wakeups. Any other GPEs within this block
+         * must be enabled via the acpi_enable_gpe() interface.
          */
         wake_gpe_count = 0;
         gpe_enabled_count = 0;
+        if (gpe_device == acpi_gbl_fadt_gpe_device)
+                gpe_device = NULL;
 
         for (i = 0; i < gpe_block->register_count; i++) {
-                for (j = 0; j < 8; j++) {
+                for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
+                        acpi_status status;
+                        acpi_size gpe_index;
+                        int gpe_number;
 
                         /* Get the info block for this particular GPE */
+                        gpe_index = (acpi_size)i * ACPI_GPE_REGISTER_WIDTH + j;
+                        gpe_event_info = &gpe_block->event_info[gpe_index];
 
-                        gpe_event_info = &gpe_block->event_info[((acpi_size) i *
-                                                                 ACPI_GPE_REGISTER_WIDTH)
-                                                                + j];
-
-                        if (((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
-                             ACPI_GPE_DISPATCH_METHOD) &&
-                            (gpe_event_info->flags & ACPI_GPE_TYPE_RUNTIME)) {
-                                gpe_enabled_count++;
-                        }
-
-                        if (gpe_event_info->flags & ACPI_GPE_TYPE_WAKE) {
+                        if (gpe_event_info->flags & ACPI_GPE_CAN_WAKE) {
                                 wake_gpe_count++;
+                                if (acpi_gbl_leave_wake_gpes_disabled)
+                                        continue;
                         }
+
+                        if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD))
+                                continue;
+
+                        gpe_number = gpe_index + gpe_block->block_base_number;
+                        status = acpi_enable_gpe(gpe_device, gpe_number,
+                                                ACPI_GPE_TYPE_RUNTIME);
+                        if (ACPI_FAILURE(status))
+                                ACPI_ERROR((AE_INFO,
+                                                "Failed to enable GPE %02X\n",
+                                                gpe_number));
+                        else
+                                gpe_enabled_count++;
                 }
         }
 
@@ -1062,15 +1049,7 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                           "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
                           wake_gpe_count, gpe_enabled_count));
 
-        /* Enable all valid runtime GPEs found above */
-
-        status = acpi_hw_enable_runtime_gpe_block(NULL, gpe_block, NULL);
-        if (ACPI_FAILURE(status)) {
-                ACPI_ERROR((AE_INFO, "Could not enable GPEs in GpeBlock %p",
-                            gpe_block));
-        }
-
-        return_ACPI_STATUS(status);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
diff --git a/drivers/acpi/acpica/evmisc.c b/drivers/acpi/acpica/evmisc.c
index ce224e1eaa89..8f0fac6c4366 100644
--- a/drivers/acpi/acpica/evmisc.c
+++ b/drivers/acpi/acpica/evmisc.c
@@ -259,9 +259,15 @@ static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
 
         handler_obj = notify_info->notify.handler_obj;
         if (handler_obj) {
-                handler_obj->notify.handler(notify_info->notify.node,
-                                            notify_info->notify.value,
-                                            handler_obj->notify.context);
+                struct acpi_object_notify_handler *notifier;
+
+                notifier = &handler_obj->notify;
+                while (notifier) {
+                        notifier->handler(notify_info->notify.node,
+                                          notify_info->notify.value,
+                                          notifier->context);
+                        notifier = notifier->next;
+                }
         }
 
         /* All done with the info object */
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index 2fe0809d4eb2..474e2cab603d 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -218,6 +218,72 @@ ACPI_EXPORT_SYMBOL(acpi_remove_fixed_event_handler)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_populate_handler_object
+ *
+ * PARAMETERS:  handler_obj        - Handler object to populate
+ *              handler_type       - The type of handler:
+ *                                  ACPI_SYSTEM_NOTIFY: system_handler (00-7f)
+ *                                  ACPI_DEVICE_NOTIFY: driver_handler (80-ff)
+ *                                  ACPI_ALL_NOTIFY:  both system and device
+ *              handler            - Address of the handler
+ *              context            - Value passed to the handler on each GPE
+ *              next               - Address of a handler object to link to
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Populate a handler object.
+ *
+ ******************************************************************************/
+static void
+acpi_populate_handler_object(struct acpi_object_notify_handler *handler_obj,
+                             u32 handler_type,
+                             acpi_notify_handler handler, void *context,
+                             struct acpi_object_notify_handler *next)
+{
+        handler_obj->handler_type = handler_type;
+        handler_obj->handler = handler;
+        handler_obj->context = context;
+        handler_obj->next = next;
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_add_handler_object
+ *
+ * PARAMETERS:  parent_obj         - Parent of the new object
+ *              handler            - Address of the handler
+ *              context            - Value passed to the handler on each GPE
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Create a new handler object and populate it.
+ *
+ ******************************************************************************/
+static acpi_status
+acpi_add_handler_object(struct acpi_object_notify_handler *parent_obj,
+                        acpi_notify_handler handler, void *context)
+{
+        struct acpi_object_notify_handler *handler_obj;
+
+        /* The parent must not be a defice notify handler object. */
+        if (parent_obj->handler_type & ACPI_DEVICE_NOTIFY)
+                return AE_BAD_PARAMETER;
+
+        handler_obj = ACPI_ALLOCATE_ZEROED(sizeof(*handler_obj));
+        if (!handler_obj)
+                return AE_NO_MEMORY;
+
+        acpi_populate_handler_object(handler_obj,
+                                        ACPI_SYSTEM_NOTIFY,
+                                        handler, context,
+                                        parent_obj->next);
+        parent_obj->next = handler_obj;
+
+        return AE_OK;
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_install_notify_handler
  *
  * PARAMETERS:  Device          - The device for which notifies will be handled
@@ -316,15 +382,32 @@ acpi_install_notify_handler(acpi_handle device,
                 obj_desc = acpi_ns_get_attached_object(node);
                 if (obj_desc) {
 
-                        /* Object exists - make sure there's no handler */
+                        /* Object exists. */
 
-                        if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
-                             obj_desc->common_notify.system_notify) ||
-                            ((handler_type & ACPI_DEVICE_NOTIFY) &&
-                             obj_desc->common_notify.device_notify)) {
+                        /* For a device notify, make sure there's no handler. */
+                        if ((handler_type & ACPI_DEVICE_NOTIFY) &&
+                             obj_desc->common_notify.device_notify) {
                                 status = AE_ALREADY_EXISTS;
                                 goto unlock_and_exit;
                         }
+
+                        /* System notifies may have more handlers installed. */
+                        notify_obj = obj_desc->common_notify.system_notify;
+
+                        if ((handler_type & ACPI_SYSTEM_NOTIFY) && notify_obj) {
+                                struct acpi_object_notify_handler *parent_obj;
+
+                                if (handler_type & ACPI_DEVICE_NOTIFY) {
+                                        status = AE_ALREADY_EXISTS;
+                                        goto unlock_and_exit;
+                                }
+
+                                parent_obj = &notify_obj->notify;
+                                status = acpi_add_handler_object(parent_obj,
+                                                                 handler,
+                                                                 context);
+                                goto unlock_and_exit;
+                        }
                 } else {
                         /* Create a new object */
 
@@ -356,9 +439,10 @@ acpi_install_notify_handler(acpi_handle device,
                         goto unlock_and_exit;
                 }
 
-                notify_obj->notify.node = node;
-                notify_obj->notify.handler = handler;
-                notify_obj->notify.context = context;
+                acpi_populate_handler_object(&notify_obj->notify,
+                                                handler_type,
+                                                handler, context,
+                                                NULL);
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
                         obj_desc->common_notify.system_notify = notify_obj;
@@ -418,6 +502,10 @@ acpi_remove_notify_handler(acpi_handle device,
                 goto exit;
         }
 
+
+        /* Make sure all deferred tasks are completed */
+        acpi_os_wait_events_complete(NULL);
+
         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
         if (ACPI_FAILURE(status)) {
                 goto exit;
@@ -445,15 +533,6 @@ acpi_remove_notify_handler(acpi_handle device,
                         goto unlock_and_exit;
                 }
 
-                /* Make sure all deferred tasks are completed */
-
-                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                acpi_os_wait_events_complete(NULL);
-                status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                if (ACPI_FAILURE(status)) {
-                        goto exit;
-                }
-
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
                         acpi_gbl_system_notify.node = NULL;
                         acpi_gbl_system_notify.handler = NULL;
@@ -488,28 +567,60 @@ acpi_remove_notify_handler(acpi_handle device,
                 /* Object exists - make sure there's an existing handler */
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
+                        struct acpi_object_notify_handler *handler_obj;
+                        struct acpi_object_notify_handler *parent_obj;
+
                         notify_obj = obj_desc->common_notify.system_notify;
                         if (!notify_obj) {
                                 status = AE_NOT_EXIST;
                                 goto unlock_and_exit;
                         }
 
-                        if (notify_obj->notify.handler != handler) {
+                        handler_obj = &notify_obj->notify;
+                        parent_obj = NULL;
+                        while (handler_obj->handler != handler) {
+                                if (handler_obj->next) {
+                                        parent_obj = handler_obj;
+                                        handler_obj = handler_obj->next;
+                                } else {
+                                        break;
+                                }
+                        }
+
+                        if (handler_obj->handler != handler) {
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
-                        /* Make sure all deferred tasks are completed */
 
-                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                        acpi_os_wait_events_complete(NULL);
-                        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                        if (ACPI_FAILURE(status)) {
-                                goto exit;
+                        /*
+                         * Remove the handler.  There are three possible cases.
+                         * First, we may need to remove a non-embedded object.
+                         * Second, we may need to remove the embedded object's
+                         * handler data, while non-embedded objects exist.
+                         * Finally, we may need to remove the embedded object
+                         * entirely along with its container.
+                         */
+                        if (parent_obj) {
+                                /* Non-embedded object is being removed. */
+                                parent_obj->next = handler_obj->next;
+                                ACPI_FREE(handler_obj);
+                        } else if (notify_obj->notify.next) {
+                                /*
+                                 * The handler matches the embedded object, but
+                                 * there are more handler objects in the list.
+                                 * Replace the embedded object's data with the
+                                 * first next object's data and remove that
+                                 * object.
+                                 */
+                                parent_obj = &notify_obj->notify;
+                                handler_obj = notify_obj->notify.next;
+                                *parent_obj = *handler_obj;
+                                ACPI_FREE(handler_obj);
+                        } else {
+                                /* No more handler objects in the list. */
+                                obj_desc->common_notify.system_notify = NULL;
+                                acpi_ut_remove_reference(notify_obj);
                         }
-
-                        /* Remove the handler */
-                        obj_desc->common_notify.system_notify = NULL;
-                        acpi_ut_remove_reference(notify_obj);
                 }
 
                 if (handler_type & ACPI_DEVICE_NOTIFY) {
@@ -523,14 +634,6 @@ acpi_remove_notify_handler(acpi_handle device,
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
-                        /* Make sure all deferred tasks are completed */
-
-                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                        acpi_os_wait_events_complete(NULL);
-                        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                        if (ACPI_FAILURE(status)) {
-                                goto exit;
-                        }
 
                         /* Remove the handler */
                         obj_desc->common_notify.device_notify = NULL;
@@ -617,13 +720,6 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
         handler->context = context;
         handler->method_node = gpe_event_info->dispatch.method_node;
 
-        /* Disable the GPE before installing the handler */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
         /* Install the handler */
 
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
@@ -707,13 +803,6 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 goto unlock_and_exit;
         }
 
-        /* Disable the GPE before removing the handler */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
         /* Make sure all deferred tasks are completed */
 
         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index eed7a38d25f2..124c157215bf 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -201,23 +201,27 @@ ACPI_EXPORT_SYMBOL(acpi_enable_event)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_set_gpe_type
+ * FUNCTION:    acpi_set_gpe
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Type            - New GPE type
+ *              action          - Enable or disable
+ *                                Called from ISR or not
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Set the type of an individual GPE
+ * DESCRIPTION: Enable or disable an ACPI event (general purpose)
  *
  ******************************************************************************/
-acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
+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_FUNCTION_TRACE(acpi_set_gpe_type);
+        ACPI_FUNCTION_TRACE(acpi_set_gpe);
+
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Ensure that we have a valid GPE number */
 
@@ -227,19 +231,29 @@ acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
                 goto unlock_and_exit;
         }
 
-        if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
-                return_ACPI_STATUS(AE_OK);
-        }
+        /* Perform the action */
+
+        switch (action) {
+        case ACPI_GPE_ENABLE:
+                status = acpi_ev_enable_gpe(gpe_event_info);
+                break;
 
-        /* Set the new type (will disable GPE if currently enabled) */
+        case ACPI_GPE_DISABLE:
+                status = acpi_ev_disable_gpe(gpe_event_info);
+                break;
 
-        status = acpi_ev_set_gpe_type(gpe_event_info, type);
+        default:
+                ACPI_ERROR((AE_INFO, "Invalid action\n"));
+                status = AE_BAD_PARAMETER;
+                break;
+        }
 
       unlock_and_exit:
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
 
-ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
+ACPI_EXPORT_SYMBOL(acpi_set_gpe)
 
 /*******************************************************************************
  *
@@ -247,15 +261,14 @@ ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Just enable, or also wake enable?
- *                                Called from ISR or not
+ *              type            - Purpose the GPE will be used for
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable an ACPI event (general purpose)
+ * DESCRIPTION: Take a reference to a GPE and enable it if necessary
  *
  ******************************************************************************/
-acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
+acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
 {
         acpi_status status = AE_OK;
         acpi_cpu_flags flags;
@@ -263,6 +276,9 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 
         ACPI_FUNCTION_TRACE(acpi_enable_gpe);
 
+        if (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 */
@@ -273,15 +289,32 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
                 goto unlock_and_exit;
         }
 
-        /* Perform the enable */
+        if (type & ACPI_GPE_TYPE_RUNTIME) {
+                if (++gpe_event_info->runtime_count == 1) {
+                        status = acpi_ev_enable_gpe(gpe_event_info);
+                        if (ACPI_FAILURE(status))
+                                gpe_event_info->runtime_count--;
+                }
+        }
+
+        if (type & ACPI_GPE_TYPE_WAKE) {
+                if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
+                        status = AE_BAD_PARAMETER;
+                        goto unlock_and_exit;
+                }
 
-        status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
+                /*
+                 * Wake-up GPEs are only enabled right prior to putting the
+                 * system into a sleep state.
+                 */
+                if (++gpe_event_info->wakeup_count == 1)
+                        acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        }
 
-      unlock_and_exit:
+unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
-
 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
 
 /*******************************************************************************
@@ -290,15 +323,14 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Just disable, or also wake disable?
- *                                Called from ISR or not
+ *              type            - Purpose the GPE won't be used for any more
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disable an ACPI event (general purpose)
+ * DESCRIPTION: Release a reference to a GPE and disable it if necessary
  *
  ******************************************************************************/
-acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
+acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
 {
         acpi_status status = AE_OK;
         acpi_cpu_flags flags;
@@ -306,6 +338,9 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
 
         ACPI_FUNCTION_TRACE(acpi_disable_gpe);
 
+        if (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 */
 
@@ -315,13 +350,24 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
                 goto unlock_and_exit;
         }
 
-        status = acpi_ev_disable_gpe(gpe_event_info);
+        if ((type & ACPI_GPE_TYPE_RUNTIME) && gpe_event_info->runtime_count) {
+                if (--gpe_event_info->runtime_count == 0)
+                        status = acpi_ev_disable_gpe(gpe_event_info);
+        }
+
+        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);
+        }
 
 unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
-
 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
 
 /*******************************************************************************