6 files changed, 144 insertions, 228 deletions

diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index ca86c1ce7c8a..dcd73ccb514c 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -669,39 +669,20 @@ static void dock_notify(struct dock_station *ds, u32 event)
         }
 }
 
-struct dock_data {
-        struct dock_station *ds;
-        u32 event;
-};
-
-static void acpi_dock_deferred_cb(void *context)
+static void acpi_dock_deferred_cb(void *data, u32 event)
 {
-        struct dock_data *data = context;
-
         acpi_scan_lock_acquire();
-        dock_notify(data->ds, data->event);
+        dock_notify(data, event);
         acpi_scan_lock_release();
-        kfree(data);
 }
 
 static void dock_notify_handler(acpi_handle handle, u32 event, void *data)
 {
-        struct dock_data *dd;
-
         if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK
            && event != ACPI_NOTIFY_EJECT_REQUEST)
                 return;
 
-        dd = kmalloc(sizeof(*dd), GFP_KERNEL);
-        if (dd) {
-                acpi_status status;
-
-                dd->ds = data;
-                dd->event = event;
-                status = acpi_os_hotplug_execute(acpi_dock_deferred_cb, dd);
-                if (ACPI_FAILURE(status))
-                        kfree(dd);
-        }
+        acpi_hotplug_execute(acpi_dock_deferred_cb, data, event);
 }
 
 /**
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index e9304dc7ebfa..a29739c0ba79 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -26,11 +26,6 @@
 acpi_status acpi_os_initialize1(void);
 int init_acpi_device_notify(void);
 int acpi_scan_init(void);
-#ifdef  CONFIG_ACPI_PCI_SLOT
-void acpi_pci_slot_init(void);
-#else
-static inline void acpi_pci_slot_init(void) { }
-#endif
 void acpi_pci_root_init(void);
 void acpi_pci_link_init(void);
 void acpi_pci_root_hp_init(void);
@@ -92,6 +87,7 @@ void acpi_device_add_finalize(struct acpi_device *device);
 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp);
 int acpi_bind_one(struct device *dev, acpi_handle handle);
 int acpi_unbind_one(struct device *dev);
+void acpi_bus_device_eject(void *data, u32 ost_src);
 
 /* --------------------------------------------------------------------------
                                   Power Resource
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index a0c09adf7e7d..54a20ff4b864 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -61,7 +61,6 @@ struct acpi_os_dpc {
         acpi_osd_exec_callback function;
         void *context;
         struct work_struct work;
-        int wait;
 };
 
 #ifdef CONFIG_ACPI_CUSTOM_DSDT
@@ -1087,9 +1086,6 @@ static void acpi_os_execute_deferred(struct work_struct *work)
 {
         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
 
-        if (dpc->wait)
-                acpi_os_wait_events_complete();
-
         dpc->function(dpc->context);
         kfree(dpc);
 }
@@ -1109,8 +1105,8 @@ static void acpi_os_execute_deferred(struct work_struct *work)
  *
  ******************************************************************************/
 
-static acpi_status __acpi_os_execute(acpi_execute_type type,
-        acpi_osd_exec_callback function, void *context, int hp)
+acpi_status acpi_os_execute(acpi_execute_type type,
+                            acpi_osd_exec_callback function, void *context)
 {
         acpi_status status = AE_OK;
         struct acpi_os_dpc *dpc;
@@ -1137,20 +1133,11 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
         dpc->context = context;
 
         /*
-         * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
-         * because the hotplug code may call driver .remove() functions,
-         * which invoke flush_scheduled_work/acpi_os_wait_events_complete
-         * to flush these workqueues.
-         *
          * To prevent lockdep from complaining unnecessarily, make sure that
          * there is a different static lockdep key for each workqueue by using
          * INIT_WORK() for each of them separately.
          */
-        if (hp) {
-                queue = kacpi_hotplug_wq;
-                dpc->wait = 1;
-                INIT_WORK(&dpc->work, acpi_os_execute_deferred);
-        } else if (type == OSL_NOTIFY_HANDLER) {
+        if (type == OSL_NOTIFY_HANDLER) {
                 queue = kacpi_notify_wq;
                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
         } else {
@@ -1175,28 +1162,59 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
         }
         return status;
 }
+EXPORT_SYMBOL(acpi_os_execute);
 
-acpi_status acpi_os_execute(acpi_execute_type type,
-                            acpi_osd_exec_callback function, void *context)
+void acpi_os_wait_events_complete(void)
 {
-        return __acpi_os_execute(type, function, context, 0);
+        flush_workqueue(kacpid_wq);
+        flush_workqueue(kacpi_notify_wq);
 }
-EXPORT_SYMBOL(acpi_os_execute);
 
-acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
-        void *context)
+struct acpi_hp_work {
+        struct work_struct work;
+        acpi_hp_callback func;
+        void *data;
+        u32 src;
+};
+
+static void acpi_hotplug_work_fn(struct work_struct *work)
 {
-        return __acpi_os_execute(0, function, context, 1);
+        struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
+
+        acpi_os_wait_events_complete();
+        hpw->func(hpw->data, hpw->src);
+        kfree(hpw);
 }
-EXPORT_SYMBOL(acpi_os_hotplug_execute);
 
-void acpi_os_wait_events_complete(void)
+acpi_status acpi_hotplug_execute(acpi_hp_callback func, void *data, u32 src)
 {
-        flush_workqueue(kacpid_wq);
-        flush_workqueue(kacpi_notify_wq);
+        struct acpi_hp_work *hpw;
+
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                  "Scheduling function [%p(%p, %u)] for deferred execution.\n",
+                  func, data, src));
+
+        hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
+        if (!hpw)
+                return AE_NO_MEMORY;
+
+        INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
+        hpw->func = func;
+        hpw->data = data;
+        hpw->src = src;
+        /*
+         * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because
+         * the hotplug code may call driver .remove() functions, which may
+         * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush
+         * these workqueues.
+         */
+        if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
+                kfree(hpw);
+                return AE_ERROR;
+        }
+        return AE_OK;
 }
 
-EXPORT_SYMBOL(acpi_os_wait_events_complete);
 
 acpi_status
 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
@@ -1845,25 +1863,3 @@ void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
 {
         __acpi_os_prepare_extended_sleep = func;
 }
-
-
-void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
-                        void (*func)(struct work_struct *work))
-{
-        struct acpi_hp_work *hp_work;
-        int ret;
-
-        hp_work = kmalloc(sizeof(*hp_work), GFP_KERNEL);
-        if (!hp_work)
-                return;
-
-        hp_work->handle = handle;
-        hp_work->type = type;
-        hp_work->context = context;
-
-        INIT_WORK(&hp_work->work, func);
-        ret = queue_work(kacpi_hotplug_wq, &hp_work->work);
-        if (!ret)
-                kfree(hp_work);
-}
-EXPORT_SYMBOL_GPL(alloc_acpi_hp_work);
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index d3874f425653..417876bce854 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -39,6 +39,8 @@
 #include <acpi/acpi_drivers.h>
 #include <acpi/apei.h>
 
+#include "internal.h"
+
 #define PREFIX "ACPI: "
 
 #define _COMPONENT              ACPI_PCI_COMPONENT
@@ -590,39 +592,10 @@ static void handle_root_bridge_insertion(acpi_handle handle)
                 acpi_handle_err(handle, "cannot add bridge to acpi list\n");
 }
 
-static void handle_root_bridge_removal(struct acpi_device *device)
-{
-        acpi_status status;
-        struct acpi_eject_event *ej_event;
-
-        ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
-        if (!ej_event) {
-                /* Inform firmware the hot-remove operation has error */
-                (void) acpi_evaluate_hotplug_ost(device->handle,
-                                        ACPI_NOTIFY_EJECT_REQUEST,
-                                        ACPI_OST_SC_NON_SPECIFIC_FAILURE,
-                                        NULL);
-                return;
-        }
-
-        ej_event->device = device;
-        ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
-
-        status = acpi_os_hotplug_execute(acpi_bus_hot_remove_device, ej_event);
-        if (ACPI_FAILURE(status))
-                kfree(ej_event);
-}
-
-static void _handle_hotplug_event_root(struct work_struct *work)
+static void hotplug_event_root(void *data, u32 type)
 {
+        acpi_handle handle = data;
         struct acpi_pci_root *root;
-        struct acpi_hp_work *hp_work;
-        acpi_handle handle;
-        u32 type;
-
-        hp_work = container_of(work, struct acpi_hp_work, work);
-        handle = hp_work->handle;
-        type = hp_work->type;
 
         acpi_scan_lock_acquire();
 
@@ -652,9 +625,15 @@ static void _handle_hotplug_event_root(struct work_struct *work)
                 /* request device eject */
                 acpi_handle_printk(KERN_DEBUG, handle,
                                    "Device eject notify on %s\n", __func__);
-                if (root)
-                        handle_root_bridge_removal(root->device);
-                break;
+                if (!root)
+                        break;
+
+                get_device(&root->device->dev);
+
+                acpi_scan_lock_release();
+
+                acpi_bus_device_eject(root->device, ACPI_NOTIFY_EJECT_REQUEST);
+                return;
         default:
                 acpi_handle_warn(handle,
                                  "notify_handler: unknown event type 0x%x\n",
@@ -663,14 +642,12 @@ static void _handle_hotplug_event_root(struct work_struct *work)
         }
 
         acpi_scan_lock_release();
-        kfree(hp_work); /* allocated in handle_hotplug_event_bridge */
 }
 
 static void handle_hotplug_event_root(acpi_handle handle, u32 type,
                                         void *context)
 {
-        alloc_acpi_hp_work(handle, type, context,
-                                _handle_hotplug_event_root);
+        acpi_hotplug_execute(hotplug_event_root, handle, type);
 }
 
 static acpi_status __init
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index fee8a297c7d9..55f9dedbbf9f 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -125,8 +125,8 @@ acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, cha
 }
 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 
-static acpi_status acpi_bus_offline_companions(acpi_handle handle, u32 lvl,
-                                               void *data, void **ret_p)
+static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
+                                    void **ret_p)
 {
         struct acpi_device *device = NULL;
         struct acpi_device_physical_node *pn;
@@ -136,6 +136,11 @@ static acpi_status acpi_bus_offline_companions(acpi_handle handle, u32 lvl,
         if (acpi_bus_get_device(handle, &device))
                 return AE_OK;
 
+        if (device->handler && !device->handler->hotplug.enabled) {
+                *ret_p = &device->dev;
+                return AE_SUPPORT;
+        }
+
         mutex_lock(&device->physical_node_lock);
 
         list_for_each_entry(pn, &device->physical_node_list, node) {
@@ -168,8 +173,8 @@ static acpi_status acpi_bus_offline_companions(acpi_handle handle, u32 lvl,
         return status;
 }
 
-static acpi_status acpi_bus_online_companions(acpi_handle handle, u32 lvl,
-                                              void *data, void **ret_p)
+static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
+                                   void **ret_p)
 {
         struct acpi_device *device = NULL;
         struct acpi_device_physical_node *pn;
@@ -214,26 +219,32 @@ static int acpi_scan_hot_remove(struct acpi_device *device)
          * If the first pass is successful, the second one isn't needed, though.
          */
         errdev = NULL;
-        acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
-                            NULL, acpi_bus_offline_companions,
-                            (void *)false, (void **)&errdev);
-        acpi_bus_offline_companions(handle, 0, (void *)false, (void **)&errdev);
+        status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
+                                     NULL, acpi_bus_offline, (void *)false,
+                                     (void **)&errdev);
+        if (status == AE_SUPPORT) {
+                dev_warn(errdev, "Offline disabled.\n");
+                acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
+                                    acpi_bus_online, NULL, NULL, NULL);
+                put_device(&device->dev);
+                return -EPERM;
+        }
+        acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
         if (errdev) {
                 errdev = NULL;
                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
-                                    NULL, acpi_bus_offline_companions,
-                                    (void *)true , (void **)&errdev);
+                                    NULL, acpi_bus_offline, (void *)true,
+                                    (void **)&errdev);
                 if (!errdev || acpi_force_hot_remove)
-                        acpi_bus_offline_companions(handle, 0, (void *)true,
-                                                    (void **)&errdev);
+                        acpi_bus_offline(handle, 0, (void *)true,
+                                         (void **)&errdev);
 
                 if (errdev && !acpi_force_hot_remove) {
                         dev_warn(errdev, "Offline failed.\n");
-                        acpi_bus_online_companions(handle, 0, NULL, NULL);
+                        acpi_bus_online(handle, 0, NULL, NULL);
                         acpi_walk_namespace(ACPI_TYPE_ANY, handle,
-                                            ACPI_UINT32_MAX,
-                                            acpi_bus_online_companions, NULL,
-                                            NULL, NULL);
+                                            ACPI_UINT32_MAX, acpi_bus_online,
+                                            NULL, NULL, NULL);
                         put_device(&device->dev);
                         return -EBUSY;
                 }
@@ -274,10 +285,10 @@ static int acpi_scan_hot_remove(struct acpi_device *device)
         return 0;
 }
 
-static void acpi_bus_device_eject(void *context)
+void acpi_bus_device_eject(void *data, u32 ost_src)
 {
-        acpi_handle handle = context;
-        struct acpi_device *device = NULL;
+        struct acpi_device *device = data;
+        acpi_handle handle = device->handle;
         struct acpi_scan_handler *handler;
         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
         int error;
@@ -285,38 +296,41 @@ static void acpi_bus_device_eject(void *context)
         lock_device_hotplug();
         mutex_lock(&acpi_scan_lock);
 
-        acpi_bus_get_device(handle, &device);
-        if (!device)
-                goto err_out;
-
         handler = device->handler;
         if (!handler || !handler->hotplug.enabled) {
-                ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
-                goto err_out;
+                put_device(&device->dev);
+                goto err_support;
         }
-        acpi_evaluate_hotplug_ost(handle, ACPI_NOTIFY_EJECT_REQUEST,
-                                  ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
+
+        if (ost_src == ACPI_NOTIFY_EJECT_REQUEST)
+                acpi_evaluate_hotplug_ost(handle, ACPI_NOTIFY_EJECT_REQUEST,
+                                          ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
+
         if (handler->hotplug.mode == AHM_CONTAINER)
                 kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
 
-        get_device(&device->dev);
         error = acpi_scan_hot_remove(device);
-        if (error)
+        if (error == -EPERM) {
+                goto err_support;
+        } else if (error) {
                 goto err_out;
+        }
 
  out:
         mutex_unlock(&acpi_scan_lock);
         unlock_device_hotplug();
         return;
 
+ err_support:
+        ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
  err_out:
-        acpi_evaluate_hotplug_ost(handle, ACPI_NOTIFY_EJECT_REQUEST, ost_code,
-                                  NULL);
+        acpi_evaluate_hotplug_ost(handle, ost_src, ost_code, NULL);
         goto out;
 }
 
-static void acpi_scan_bus_device_check(acpi_handle handle, u32 ost_source)
+static void acpi_scan_bus_device_check(void *data, u32 ost_source)
 {
+        acpi_handle handle = data;
         struct acpi_device *device = NULL;
         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
         int error;
@@ -331,8 +345,6 @@ static void acpi_scan_bus_device_check(acpi_handle handle, u32 ost_source)
                         goto out;
                 }
         }
-        acpi_evaluate_hotplug_ost(handle, ost_source,
-                                  ACPI_OST_SC_INSERT_IN_PROGRESS, NULL);
         error = acpi_bus_scan(handle);
         if (error) {
                 acpi_handle_warn(handle, "Namespace scan failure\n");
@@ -353,18 +365,6 @@ static void acpi_scan_bus_device_check(acpi_handle handle, u32 ost_source)
         unlock_device_hotplug();
 }
 
-static void acpi_scan_bus_check(void *context)
-{
-        acpi_scan_bus_device_check((acpi_handle)context,
-                                   ACPI_NOTIFY_BUS_CHECK);
-}
-
-static void acpi_scan_device_check(void *context)
-{
-        acpi_scan_bus_device_check((acpi_handle)context,
-                                   ACPI_NOTIFY_DEVICE_CHECK);
-}
-
 static void acpi_hotplug_unsupported(acpi_handle handle, u32 type)
 {
         u32 ost_status;
@@ -395,8 +395,8 @@ static void acpi_hotplug_unsupported(acpi_handle handle, u32 type)
 
 static void acpi_hotplug_notify_cb(acpi_handle handle, u32 type, void *data)
 {
-        acpi_osd_exec_callback callback;
         struct acpi_scan_handler *handler = data;
+        struct acpi_device *adev;
         acpi_status status;
 
         if (!handler->hotplug.enabled)
@@ -405,56 +405,35 @@ static void acpi_hotplug_notify_cb(acpi_handle handle, u32 type, void *data)
         switch (type) {
         case ACPI_NOTIFY_BUS_CHECK:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
-                callback = acpi_scan_bus_check;
                 break;
         case ACPI_NOTIFY_DEVICE_CHECK:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
-                callback = acpi_scan_device_check;
                 break;
         case ACPI_NOTIFY_EJECT_REQUEST:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
-                callback = acpi_bus_device_eject;
-                break;
+                status = acpi_bus_get_device(handle, &adev);
+                if (ACPI_FAILURE(status))
+                        goto err_out;
+
+                get_device(&adev->dev);
+                status = acpi_hotplug_execute(acpi_bus_device_eject, adev, type);
+                if (ACPI_SUCCESS(status))
+                        return;
+
+                put_device(&adev->dev);
+                goto err_out;
         default:
                 /* non-hotplug event; possibly handled by other handler */
                 return;
         }
-        status = acpi_os_hotplug_execute(callback, handle);
-        if (ACPI_FAILURE(status))
-                acpi_evaluate_hotplug_ost(handle, type,
-                                          ACPI_OST_SC_NON_SPECIFIC_FAILURE,
-                                          NULL);
-}
-
-/**
- * acpi_bus_hot_remove_device: hot-remove a device and its children
- * @context: struct acpi_eject_event pointer (freed in this func)
- *
- * Hot-remove a device and its children. This function frees up the
- * memory space passed by arg context, so that the caller may call
- * this function asynchronously through acpi_os_hotplug_execute().
- */
-void acpi_bus_hot_remove_device(void *context)
-{
-        struct acpi_eject_event *ej_event = context;
-        struct acpi_device *device = ej_event->device;
-        acpi_handle handle = device->handle;
-        int error;
-
-        lock_device_hotplug();
-        mutex_lock(&acpi_scan_lock);
-
-        error = acpi_scan_hot_remove(device);
-        if (error && handle)
-                acpi_evaluate_hotplug_ost(handle, ej_event->event,
-                                          ACPI_OST_SC_NON_SPECIFIC_FAILURE,
-                                          NULL);
+        status = acpi_hotplug_execute(acpi_scan_bus_device_check, handle, type);
+        if (ACPI_SUCCESS(status))
+                return;
 
-        mutex_unlock(&acpi_scan_lock);
-        unlock_device_hotplug();
-        kfree(context);
+ err_out:
+        acpi_evaluate_hotplug_ost(handle, type,
+                                  ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
 }
-EXPORT_SYMBOL(acpi_bus_hot_remove_device);
 
 static ssize_t real_power_state_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
@@ -487,10 +466,8 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct acpi_device *acpi_device = to_acpi_device(d);
-        struct acpi_eject_event *ej_event;
         acpi_object_type not_used;
         acpi_status status;
-        int ret;
 
         if (!count || buf[0] != '1')
                 return -EINVAL;
@@ -503,28 +480,18 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
         if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
                 return -ENODEV;
 
-        ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
-        if (!ej_event) {
-                ret = -ENOMEM;
-                goto err_out;
-        }
         acpi_evaluate_hotplug_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
                                   ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
-        ej_event->device = acpi_device;
-        ej_event->event = ACPI_OST_EC_OSPM_EJECT;
         get_device(&acpi_device->dev);
-        status = acpi_os_hotplug_execute(acpi_bus_hot_remove_device, ej_event);
+        status = acpi_hotplug_execute(acpi_bus_device_eject, acpi_device,
+                                      ACPI_OST_EC_OSPM_EJECT);
         if (ACPI_SUCCESS(status))
                 return count;
 
         put_device(&acpi_device->dev);
-        kfree(ej_event);
-        ret = status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
-
- err_out:
         acpi_evaluate_hotplug_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
                                   ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
-        return ret;
+        return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
 }
 
 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
@@ -1676,7 +1643,6 @@ void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
 
 void acpi_device_add_finalize(struct acpi_device *device)
 {
-        device->flags.match_driver = true;
         dev_set_uevent_suppress(&device->dev, false);
         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
 }
@@ -1915,8 +1881,12 @@ static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
                 return AE_OK;
 
         ret = acpi_scan_attach_handler(device);
-        if (ret)
-                return ret > 0 ? AE_OK : AE_CTRL_DEPTH;
+        if (ret < 0)
+                return AE_CTRL_DEPTH;
+
+        device->flags.match_driver = true;
+        if (ret > 0)
+                return AE_OK;
 
         ret = device_attach(&device->dev);
         return ret >= 0 ? AE_OK : AE_CTRL_DEPTH;
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index be12fbfcae10..e98018b43e2a 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -875,21 +875,17 @@ static void hotplug_event(acpi_handle handle, u32 type, void *data)
                 put_bridge(bridge);
 }
 
-static void hotplug_event_work(struct work_struct *work)
+static void hotplug_event_work(void *data, u32 type)
 {
-        struct acpiphp_context *context;
-        struct acpi_hp_work *hp_work;
+        struct acpiphp_context *context = data;
+        acpi_handle handle = context->handle;
 
-        hp_work = container_of(work, struct acpi_hp_work, work);
-        context = hp_work->context;
         acpi_scan_lock_acquire();
 
-        hotplug_event(hp_work->handle, hp_work->type, context);
+        hotplug_event(handle, type, context);
 
         acpi_scan_lock_release();
-        acpi_evaluate_hotplug_ost(hp_work->handle, hp_work->type,
-                                  ACPI_OST_SC_SUCCESS, NULL);
-        kfree(hp_work); /* allocated in handle_hotplug_event() */
+        acpi_evaluate_hotplug_ost(handle, type, ACPI_OST_SC_SUCCESS, NULL);
         put_bridge(context->func.parent);
 }
 
@@ -940,10 +936,10 @@ static void handle_hotplug_event(acpi_handle handle, u32 type, void *data)
 
         mutex_lock(&acpiphp_context_lock);
         context = acpiphp_get_context(handle);
-        if (context) {
+        if (context && !WARN_ON(context->handle != handle)) {
                 get_bridge(context->func.parent);
                 acpiphp_put_context(context);
-                alloc_acpi_hp_work(handle, type, context, hotplug_event_work);
+                acpi_hotplug_execute(hotplug_event_work, context, type);
                 mutex_unlock(&acpiphp_context_lock);
                 return;
         }