150 files changed, 2643 insertions, 2966 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 100bd724f648..3278a210c435 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -91,24 +91,6 @@ config ACPI_EC_DEBUGFS
           Thus this option is a debug option that helps to write ACPI drivers
           and can be used to identify ACPI code or EC firmware bugs.
 
-config ACPI_PROC_EVENT
-        bool "Deprecated /proc/acpi/event support"
-        depends on PROC_FS
-        default y
-        help
-          A user-space daemon, acpid, typically reads /proc/acpi/event
-          and handles all ACPI-generated events.
-
-          These events are now delivered to user-space either
-          via the input layer or as netlink events.
-
-          This build option enables the old code for legacy
-          user-space implementation.  After some time, this will
-          be moved under CONFIG_ACPI_PROCFS, and then deleted.
-
-          Say Y here to retain the old behaviour.  Say N if your
-          user-space is newer than kernel 2.6.23 (September 2007).
-
 config ACPI_AC
         tristate "AC Adapter"
         depends on X86
diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 4f4e741d34b2..f37beaa32750 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -267,7 +267,6 @@ static void acpi_ac_notify(struct acpi_device *device, u32 event)
                         msleep(ac_sleep_before_get_state_ms);
 
                 acpi_ac_get_state(ac);
-                acpi_bus_generate_proc_event(device, event, (u32) ac->state);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event,
                                                   (u32) ac->state);
diff --git a/drivers/acpi/acpi_pad.c b/drivers/acpi/acpi_pad.c
index 27bb6a91de5f..6230637054c6 100644
--- a/drivers/acpi/acpi_pad.c
+++ b/drivers/acpi/acpi_pad.c
@@ -452,7 +452,6 @@ static void acpi_pad_notify(acpi_handle handle, u32 event,
         switch (event) {
         case ACPI_PROCESSOR_AGGREGATOR_NOTIFY:
                 acpi_pad_handle_notify(handle);
-                acpi_bus_generate_proc_event(device, event, 0);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                         dev_name(&device->dev), event, 0);
                 break;
diff --git a/drivers/acpi/acpi_platform.c b/drivers/acpi/acpi_platform.c
index fafec5ddf17f..1bde12708f9e 100644
--- a/drivers/acpi/acpi_platform.c
+++ b/drivers/acpi/acpi_platform.c
@@ -52,7 +52,7 @@ int acpi_create_platform_device(struct acpi_device *adev,
         struct platform_device_info pdevinfo;
         struct resource_list_entry *rentry;
         struct list_head resource_list;
-        struct resource *resources;
+        struct resource *resources = NULL;
         int count;
 
         /* If the ACPI node already has a physical device attached, skip it. */
@@ -61,20 +61,22 @@ int acpi_create_platform_device(struct acpi_device *adev,
 
         INIT_LIST_HEAD(&resource_list);
         count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
-        if (count <= 0)
+        if (count < 0) {
                 return 0;
+        } else if (count > 0) {
+                resources = kmalloc(count * sizeof(struct resource),
+                                    GFP_KERNEL);
+                if (!resources) {
+                        dev_err(&adev->dev, "No memory for resources\n");
+                        acpi_dev_free_resource_list(&resource_list);
+                        return -ENOMEM;
+                }
+                count = 0;
+                list_for_each_entry(rentry, &resource_list, node)
+                        resources[count++] = rentry->res;
 
-        resources = kmalloc(count * sizeof(struct resource), GFP_KERNEL);
-        if (!resources) {
-                dev_err(&adev->dev, "No memory for resources\n");
                 acpi_dev_free_resource_list(&resource_list);
-                return -ENOMEM;
         }
-        count = 0;
-        list_for_each_entry(rentry, &resource_list, node)
-                resources[count++] = rentry->res;
-
-        acpi_dev_free_resource_list(&resource_list);
 
         memset(&pdevinfo, 0, sizeof(pdevinfo));
         /*
diff --git a/drivers/acpi/acpi_processor.c b/drivers/acpi/acpi_processor.c
index 5a74a9c1e42c..f29e06efa479 100644
--- a/drivers/acpi/acpi_processor.c
+++ b/drivers/acpi/acpi_processor.c
@@ -178,14 +178,17 @@ static int acpi_processor_hotadd_init(struct acpi_processor *pr)
         if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
                 return -ENODEV;
 
+        cpu_maps_update_begin();
+        cpu_hotplug_begin();
+
         ret = acpi_map_lsapic(pr->handle, &pr->id);
         if (ret)
-                return ret;
+                goto out;
 
         ret = arch_register_cpu(pr->id);
         if (ret) {
                 acpi_unmap_lsapic(pr->id);
-                return ret;
+                goto out;
         }
 
         /*
@@ -195,7 +198,11 @@ static int acpi_processor_hotadd_init(struct acpi_processor *pr)
          */
         pr_info("CPU%d has been hot-added\n", pr->id);
         pr->flags.need_hotplug_init = 1;
-        return 0;
+
+out:
+        cpu_hotplug_done();
+        cpu_maps_update_done();
+        return ret;
 }
 #else
 static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
@@ -452,11 +459,15 @@ static void acpi_processor_remove(struct acpi_device *device)
         per_cpu(processor_device_array, pr->id) = NULL;
         per_cpu(processors, pr->id) = NULL;
 
+        cpu_maps_update_begin();
+        cpu_hotplug_begin();
+
         /* Remove the CPU. */
-        get_online_cpus();
         arch_unregister_cpu(pr->id);
         acpi_unmap_lsapic(pr->id);
-        put_online_cpus();
+
+        cpu_hotplug_done();
+        cpu_maps_update_done();
 
         try_offline_node(cpu_to_node(pr->id));
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index b8d38117a20c..90e846f985fa 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -138,6 +138,12 @@ u8 ACPI_INIT_GLOBAL(acpi_gbl_disable_auto_repair, FALSE);
  */
 u8 ACPI_INIT_GLOBAL(acpi_gbl_disable_ssdt_table_load, FALSE);
 
+/*
+ * We keep track of the latest version of Windows that has been requested by
+ * the BIOS.
+ */
+u8 ACPI_INIT_GLOBAL(acpi_gbl_osi_data, 0);
+
 /* acpi_gbl_FADT is a local copy of the FADT, converted to a common format. */
 
 struct acpi_table_fadt acpi_gbl_FADT;
@@ -285,7 +291,6 @@ ACPI_EXTERN u8 acpi_gbl_debugger_configuration;
 ACPI_EXTERN u8 acpi_gbl_step_to_next_call;
 ACPI_EXTERN u8 acpi_gbl_acpi_hardware_present;
 ACPI_EXTERN u8 acpi_gbl_events_initialized;
-ACPI_EXTERN u8 acpi_gbl_osi_data;
 ACPI_EXTERN struct acpi_interface_info *acpi_gbl_supported_interfaces;
 ACPI_EXTERN struct acpi_address_range
     *acpi_gbl_address_range_list[ACPI_ADDRESS_RANGE_MAX];
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index d4a4901637cd..0ed00669cd21 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -942,6 +942,9 @@ struct acpi_interface_info {
 
 #define ACPI_OSI_INVALID                0x01
 #define ACPI_OSI_DYNAMIC                0x02
+#define ACPI_OSI_FEATURE                0x04
+#define ACPI_OSI_DEFAULT_INVALID        0x08
+#define ACPI_OSI_OPTIONAL_FEATURE       (ACPI_OSI_FEATURE | ACPI_OSI_DEFAULT_INVALID | ACPI_OSI_INVALID)
 
 struct acpi_port_info {
         char *name;
@@ -1030,6 +1033,7 @@ struct acpi_external_list {
         u8 type;
         u8 flags;
         u8 resolved;
+        u8 emitted;
 };
 
 /* Values for Flags field above */
diff --git a/drivers/acpi/acpica/acnamesp.h b/drivers/acpi/acpica/acnamesp.h
index b83dc32a5ae0..40b04bd5579e 100644
--- a/drivers/acpi/acpica/acnamesp.h
+++ b/drivers/acpi/acpica/acnamesp.h
@@ -104,8 +104,8 @@ acpi_ns_walk_namespace(acpi_object_type type,
                        acpi_handle start_object,
                        u32 max_depth,
                        u32 flags,
-                       acpi_walk_callback pre_order_visit,
-                       acpi_walk_callback post_order_visit,
+                       acpi_walk_callback descending_callback,
+                       acpi_walk_callback ascending_callback,
                        void *context, void **return_value);
 
 struct acpi_namespace_node *acpi_ns_get_next_node(struct acpi_namespace_node
diff --git a/drivers/acpi/acpica/actables.h b/drivers/acpi/acpica/actables.h
index 7755e915a007..c54f42c64fe2 100644
--- a/drivers/acpi/acpica/actables.h
+++ b/drivers/acpi/acpica/actables.h
@@ -47,6 +47,13 @@
 acpi_status acpi_allocate_root_table(u32 initial_table_count);
 
 /*
+ * tbxfroot - Root pointer utilities
+ */
+acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
+
+u8 *acpi_tb_scan_memory_for_rsdp(u8 *start_address, u32 length);
+
+/*
  * tbfadt - FADT parse/convert/validate
  */
 void acpi_tb_parse_fadt(u32 table_index);
diff --git a/drivers/acpi/acpica/acutils.h b/drivers/acpi/acpica/acutils.h
index 3c76edea6803..d5a62a6182bb 100644
--- a/drivers/acpi/acpica/acutils.h
+++ b/drivers/acpi/acpica/acutils.h
@@ -470,6 +470,8 @@ acpi_status acpi_ut_install_interface(acpi_string interface_name);
 
 acpi_status acpi_ut_remove_interface(acpi_string interface_name);
 
+acpi_status acpi_ut_update_interfaces(u8 action);
+
 struct acpi_interface_info *acpi_ut_get_interface(acpi_string interface_name);
 
 acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state);
@@ -616,7 +618,7 @@ int acpi_ut_stricmp(char *string1, char *string2);
 
 acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer);
 
-void acpi_ut_print_string(char *string, u8 max_length);
+void acpi_ut_print_string(char *string, u16 max_length);
 
 void ut_convert_backslashes(char *pathname);
 
diff --git a/drivers/acpi/acpica/evgpeinit.c b/drivers/acpi/acpica/evgpeinit.c
index 9037f17c9608..7842700346a4 100644
--- a/drivers/acpi/acpica/evgpeinit.c
+++ b/drivers/acpi/acpica/evgpeinit.c
@@ -125,7 +125,6 @@ acpi_status acpi_ev_gpe_initialize(void)
                 /* GPE block 0 exists (has both length and address > 0) */
 
                 register_count0 = (u16)(acpi_gbl_FADT.gpe0_block_length / 2);
-
                 gpe_number_max =
                     (register_count0 * ACPI_GPE_REGISTER_WIDTH) - 1;
 
@@ -204,16 +203,6 @@ acpi_status acpi_ev_gpe_initialize(void)
                 goto cleanup;
         }
 
-        /* Check for Max GPE number out-of-range */
-
-        if (gpe_number_max > ACPI_GPE_MAX) {
-                ACPI_ERROR((AE_INFO,
-                            "Maximum GPE number from FADT is too large: 0x%X",
-                            gpe_number_max));
-                status = AE_BAD_VALUE;
-                goto cleanup;
-        }
-
       cleanup:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_ACPI_STATUS(AE_OK);
diff --git a/drivers/acpi/acpica/exdump.c b/drivers/acpi/acpica/exdump.c
index c740f24e3101..4d046faac48c 100644
--- a/drivers/acpi/acpica/exdump.c
+++ b/drivers/acpi/acpica/exdump.c
@@ -338,6 +338,7 @@ acpi_ex_dump_object(union acpi_operand_object *obj_desc,
 {
         u8 *target;
         char *name;
+        const char *reference_name;
         u8 count;
 
         if (!info) {
@@ -426,10 +427,9 @@ acpi_ex_dump_object(union acpi_operand_object *obj_desc,
 
                 case ACPI_EXD_REFERENCE:
 
+                        reference_name = acpi_ut_get_reference_name(obj_desc);
                         acpi_ex_out_string("Class Name",
-                                           ACPI_CAST_PTR(char,
-                                                         acpi_ut_get_reference_name
-                                                         (obj_desc)));
+                                           ACPI_CAST_PTR(char, reference_name));
                         acpi_ex_dump_reference_obj(obj_desc);
                         break;
 
diff --git a/drivers/acpi/acpica/exoparg1.c b/drivers/acpi/acpica/exoparg1.c
index 814b4a3d656a..2cdd41d8ade6 100644
--- a/drivers/acpi/acpica/exoparg1.c
+++ b/drivers/acpi/acpica/exoparg1.c
@@ -962,10 +962,17 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
                                          */
                                         return_desc =
                                             *(operand[0]->reference.where);
-                                        if (return_desc) {
-                                                acpi_ut_add_reference
-                                                    (return_desc);
+                                        if (!return_desc) {
+                                                /*
+                                                 * Element is NULL, do not allow the dereference.
+                                                 * This provides compatibility with other ACPI
+                                                 * implementations.
+                                                 */
+                                                return_ACPI_STATUS
+                                                    (AE_AML_UNINITIALIZED_ELEMENT);
                                         }
+
+                                        acpi_ut_add_reference(return_desc);
                                         break;
 
                                 default:
@@ -990,11 +997,40 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
                                                                          acpi_namespace_node
                                                                          *)
                                                                         return_desc);
-                                }
+                                        if (!return_desc) {
+                                                break;
+                                        }
 
-                                /* Add another reference to the object! */
+                                        /*
+                                         * June 2013:
+                                         * buffer_fields/field_units require additional resolution
+                                         */
+                                        switch (return_desc->common.type) {
+                                        case ACPI_TYPE_BUFFER_FIELD:
+                                        case ACPI_TYPE_LOCAL_REGION_FIELD:
+                                        case ACPI_TYPE_LOCAL_BANK_FIELD:
+                                        case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
-                                acpi_ut_add_reference(return_desc);
+                                                status =
+                                                    acpi_ex_read_data_from_field
+                                                    (walk_state, return_desc,
+                                                     &temp_desc);
+                                                if (ACPI_FAILURE(status)) {
+                                                        goto cleanup;
+                                                }
+
+                                                return_desc = temp_desc;
+                                                break;
+
+                                        default:
+
+                                                /* Add another reference to the object */
+
+                                                acpi_ut_add_reference
+                                                    (return_desc);
+                                                break;
+                                        }
+                                }
                                 break;
 
                         default:
diff --git a/drivers/acpi/acpica/hwesleep.c b/drivers/acpi/acpica/hwesleep.c
index 5e5f76230f5e..414076818d40 100644
--- a/drivers/acpi/acpica/hwesleep.c
+++ b/drivers/acpi/acpica/hwesleep.c
@@ -43,6 +43,7 @@
  */
 
 #include <acpi/acpi.h>
+#include <linux/acpi.h>
 #include "accommon.h"
 
 #define _COMPONENT          ACPI_HARDWARE
@@ -128,6 +129,14 @@ acpi_status acpi_hw_extended_sleep(u8 sleep_state)
 
         ACPI_FLUSH_CPU_CACHE();
 
+        status = acpi_os_prepare_extended_sleep(sleep_state,
+                                                acpi_gbl_sleep_type_a,
+                                                acpi_gbl_sleep_type_b);
+        if (ACPI_SKIP(status))
+                return_ACPI_STATUS(AE_OK);
+        if (ACPI_FAILURE(status))
+                return_ACPI_STATUS(status);
+
         /*
          * Set the SLP_TYP and SLP_EN bits.
          *
diff --git a/drivers/acpi/acpica/hwtimer.c b/drivers/acpi/acpica/hwtimer.c
index 0c1a8bbd05d6..2d7d22ebc782 100644
--- a/drivers/acpi/acpica/hwtimer.c
+++ b/drivers/acpi/acpica/hwtimer.c
@@ -100,8 +100,13 @@ acpi_status acpi_get_timer(u32 * ticks)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        status = acpi_hw_read(ticks, &acpi_gbl_FADT.xpm_timer_block);
+        /* ACPI 5.0A: PM Timer is optional */
+
+        if (!acpi_gbl_FADT.xpm_timer_block.address) {
+                return_ACPI_STATUS(AE_SUPPORT);
+        }
 
+        status = acpi_hw_read(ticks, &acpi_gbl_FADT.xpm_timer_block);
         return_ACPI_STATUS(status);
 }
 
@@ -148,6 +153,12 @@ acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
+        /* ACPI 5.0A: PM Timer is optional */
+
+        if (!acpi_gbl_FADT.xpm_timer_block.address) {
+                return_ACPI_STATUS(AE_SUPPORT);
+        }
+
         /*
          * Compute Tick Delta:
          * Handle (max one) timer rollovers on 24-bit versus 32-bit timers.
diff --git a/drivers/acpi/acpica/nspredef.c b/drivers/acpi/acpica/nspredef.c
index 24b71a01bf93..098e7666cbc9 100644
--- a/drivers/acpi/acpica/nspredef.c
+++ b/drivers/acpi/acpica/nspredef.c
@@ -151,6 +151,15 @@ acpi_ns_check_return_value(struct acpi_namespace_node *node,
         }
 
         /*
+         *
+         * 4) If there is no return value and it is optional, just return
+         * AE_OK (_WAK).
+         */
+        if (!(*return_object_ptr)) {
+                goto exit;
+        }
+
+        /*
          * For returned Package objects, check the type of all sub-objects.
          * Note: Package may have been newly created by call above.
          */
@@ -268,7 +277,12 @@ acpi_ns_check_object_type(struct acpi_evaluate_info *info,
 
         acpi_ut_get_expected_return_types(type_buffer, expected_btypes);
 
-        if (package_index == ACPI_NOT_PACKAGE_ELEMENT) {
+        if (!return_object) {
+                ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
+                                      info->node_flags,
+                                      "Expected return object of type %s",
+                                      type_buffer));
+        } else if (package_index == ACPI_NOT_PACKAGE_ELEMENT) {
                 ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
                                       info->node_flags,
                                       "Return type mismatch - found %s, expected %s",
diff --git a/drivers/acpi/acpica/nswalk.c b/drivers/acpi/acpica/nswalk.c
index e70911a9e441..e81f15ef659a 100644
--- a/drivers/acpi/acpica/nswalk.c
+++ b/drivers/acpi/acpica/nswalk.c
@@ -156,9 +156,9 @@ struct acpi_namespace_node *acpi_ns_get_next_node_typed(acpi_object_type type,
  *              max_depth           - Depth to which search is to reach
  *              flags               - Whether to unlock the NS before invoking
  *                                    the callback routine
- *              pre_order_visit     - Called during tree pre-order visit
+ *              descending_callback - Called during tree descent
  *                                    when an object of "Type" is found
- *              post_order_visit    - Called during tree post-order visit
+ *              ascending_callback  - Called during tree ascent
  *                                    when an object of "Type" is found
  *              context             - Passed to user function(s) above
  *              return_value        - from the user_function if terminated
@@ -185,8 +185,8 @@ acpi_ns_walk_namespace(acpi_object_type type,
                        acpi_handle start_node,
                        u32 max_depth,
                        u32 flags,
-                       acpi_walk_callback pre_order_visit,
-                       acpi_walk_callback post_order_visit,
+                       acpi_walk_callback descending_callback,
+                       acpi_walk_callback ascending_callback,
                        void *context, void **return_value)
 {
         acpi_status status;
@@ -255,22 +255,22 @@ acpi_ns_walk_namespace(acpi_object_type type,
                         }
 
                         /*
-                         * Invoke the user function, either pre-order or post-order
+                         * Invoke the user function, either descending, ascending,
                          * or both.
                          */
                         if (!node_previously_visited) {
-                                if (pre_order_visit) {
+                                if (descending_callback) {
                                         status =
-                                            pre_order_visit(child_node, level,
-                                                            context,
-                                                            return_value);
+                                            descending_callback(child_node,
+                                                                level, context,
+                                                                return_value);
                                 }
                         } else {
-                                if (post_order_visit) {
+                                if (ascending_callback) {
                                         status =
-                                            post_order_visit(child_node, level,
-                                                             context,
-                                                             return_value);
+                                            ascending_callback(child_node,
+                                                               level, context,
+                                                               return_value);
                                 }
                         }
 
diff --git a/drivers/acpi/acpica/nsxfeval.c b/drivers/acpi/acpica/nsxfeval.c
index f553cfdb71dd..b38b4b07f86e 100644
--- a/drivers/acpi/acpica/nsxfeval.c
+++ b/drivers/acpi/acpica/nsxfeval.c
@@ -533,9 +533,9 @@ static void acpi_ns_resolve_references(struct acpi_evaluate_info *info)
  * PARAMETERS:  type                - acpi_object_type to search for
  *              start_object        - Handle in namespace where search begins
  *              max_depth           - Depth to which search is to reach
- *              pre_order_visit     - Called during tree pre-order visit
+ *              descending_callback - Called during tree descent
  *                                    when an object of "Type" is found
- *              post_order_visit    - Called during tree post-order visit
+ *              ascending_callback  - Called during tree ascent
  *                                    when an object of "Type" is found
  *              context             - Passed to user function(s) above
  *              return_value        - Location where return value of
@@ -563,8 +563,8 @@ acpi_status
 acpi_walk_namespace(acpi_object_type type,
                     acpi_handle start_object,
                     u32 max_depth,
-                    acpi_walk_callback pre_order_visit,
-                    acpi_walk_callback post_order_visit,
+                    acpi_walk_callback descending_callback,
+                    acpi_walk_callback ascending_callback,
                     void *context, void **return_value)
 {
         acpi_status status;
@@ -574,7 +574,7 @@ acpi_walk_namespace(acpi_object_type type,
         /* Parameter validation */
 
         if ((type > ACPI_TYPE_LOCAL_MAX) ||
-            (!max_depth) || (!pre_order_visit && !post_order_visit)) {
+            (!max_depth) || (!descending_callback && !ascending_callback)) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
@@ -606,9 +606,9 @@ acpi_walk_namespace(acpi_object_type type,
         }
 
         status = acpi_ns_walk_namespace(type, start_object, max_depth,
-                                        ACPI_NS_WALK_UNLOCK, pre_order_visit,
-                                        post_order_visit, context,
-                                        return_value);
+                                        ACPI_NS_WALK_UNLOCK,
+                                        descending_callback, ascending_callback,
+                                        context, return_value);
 
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 
diff --git a/drivers/acpi/acpica/nsxfname.c b/drivers/acpi/acpica/nsxfname.c
index f3a4d95899f7..83c164434580 100644
--- a/drivers/acpi/acpica/nsxfname.c
+++ b/drivers/acpi/acpica/nsxfname.c
@@ -158,6 +158,7 @@ acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
 {
         acpi_status status;
         struct acpi_namespace_node *node;
+        char *node_name;
 
         /* Parameter validation */
 
@@ -202,7 +203,8 @@ acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
 
         /* Just copy the ACPI name from the Node and zero terminate it */
 
-        ACPI_MOVE_NAME(buffer->pointer, acpi_ut_get_node_name(node));
+        node_name = acpi_ut_get_node_name(node);
+        ACPI_MOVE_NAME(buffer->pointer, node_name);
         ((char *)buffer->pointer)[ACPI_NAME_SIZE] = 0;
         status = AE_OK;
 
@@ -379,9 +381,14 @@ acpi_get_object_info(acpi_handle handle,
                  * Get extra info for ACPI Device/Processor objects only:
                  * Run the _STA, _ADR and, sx_w, and _sx_d methods.
                  *
-                 * Note: none of these methods are required, so they may or may
+                 * Notes: none of these methods are required, so they may or may
                  * not be present for this device. The Info->Valid bitfield is used
                  * to indicate which methods were found and run successfully.
+                 *
+                 * For _STA, if the method does not exist, then (as per the ACPI
+                 * specification), the returned current_status flags will indicate
+                 * that the device is present/functional/enabled. Otherwise, the
+                 * current_status flags reflect the value returned from _STA.
                  */
 
                 /* Execute the Device._STA method */
diff --git a/drivers/acpi/acpica/tbfadt.c b/drivers/acpi/acpica/tbfadt.c
index 33b00d22300a..9d99f2189693 100644
--- a/drivers/acpi/acpica/tbfadt.c
+++ b/drivers/acpi/acpica/tbfadt.c
@@ -117,7 +117,7 @@ static struct acpi_fadt_info fadt_info_table[] = {
          ACPI_FADT_OFFSET(pm_timer_block),
          ACPI_FADT_OFFSET(pm_timer_length),
          ACPI_PM_TIMER_WIDTH,
-         ACPI_FADT_REQUIRED},
+         ACPI_FADT_SEPARATE_LENGTH},    /* ACPI 5.0A: Timer is optional */
 
         {"Gpe0Block",
          ACPI_FADT_OFFSET(xgpe0_block),
@@ -574,7 +574,7 @@ static void acpi_tb_validate_fadt(void)
 
                 if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
                         /*
-                         * Field is required (Pm1a_event, Pm1a_control, pm_timer).
+                         * Field is required (Pm1a_event, Pm1a_control).
                          * Both the address and length must be non-zero.
                          */
                         if (!address64->address || !length) {
diff --git a/drivers/acpi/acpica/tbxfroot.c b/drivers/acpi/acpica/tbxfroot.c
index 7c2ecfb7c2c3..948c95e80d44 100644
--- a/drivers/acpi/acpica/tbxfroot.c
+++ b/drivers/acpi/acpica/tbxfroot.c
@@ -48,11 +48,6 @@
 #define _COMPONENT          ACPI_TABLES
 ACPI_MODULE_NAME("tbxfroot")
 
-/* Local prototypes */
-static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length);
-
-static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_tb_validate_rsdp
@@ -64,8 +59,7 @@ static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
  * DESCRIPTION: Validate the RSDP (ptr)
  *
  ******************************************************************************/
-
-static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp)
+acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp)
 {
 
         /*
@@ -74,7 +68,7 @@ static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp)
          * Note: Sometimes there exists more than one RSDP in memory; the valid
          * RSDP has a valid checksum, all others have an invalid checksum.
          */
-        if (ACPI_STRNCMP((char *)rsdp, ACPI_SIG_RSDP,
+        if (ACPI_STRNCMP((char *)rsdp->signature, ACPI_SIG_RSDP,
                          sizeof(ACPI_SIG_RSDP) - 1) != 0) {
 
                 /* Nope, BAD Signature */
@@ -231,7 +225,7 @@ acpi_status acpi_find_root_pointer(acpi_size *table_address)
  * DESCRIPTION: Search a block of memory for the RSDP signature
  *
  ******************************************************************************/
-static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length)
+u8 *acpi_tb_scan_memory_for_rsdp(u8 *start_address, u32 length)
 {
         acpi_status status;
         u8 *mem_rover;
diff --git a/drivers/acpi/acpica/uteval.c b/drivers/acpi/acpica/uteval.c
index ee83adb97b1e..4fd68971019b 100644
--- a/drivers/acpi/acpica/uteval.c
+++ b/drivers/acpi/acpica/uteval.c
@@ -239,7 +239,8 @@ acpi_ut_evaluate_numeric_object(char *object_name,
  * RETURN:      Status
  *
  * DESCRIPTION: Executes _STA for selected device and stores results in
- *              *Flags.
+ *              *Flags. If _STA does not exist, then the device is assumed
+ *              to be present/functional/enabled (as per the ACPI spec).
  *
  *              NOTE: Internal function, no parameter validation
  *
@@ -257,6 +258,11 @@ acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
                                          ACPI_BTYPE_INTEGER, &obj_desc);
         if (ACPI_FAILURE(status)) {
                 if (AE_NOT_FOUND == status) {
+                        /*
+                         * if _STA does not exist, then (as per the ACPI specification),
+                         * the returned flags will indicate that the device is present,
+                         * functional, and enabled.
+                         */
                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
                                           "_STA on %4.4s was not found, assuming device is present\n",
                                           acpi_ut_get_node_name(device_node)));
diff --git a/drivers/acpi/acpica/utglobal.c b/drivers/acpi/acpica/utglobal.c
index f736448a8606..d6f26bf8a062 100644
--- a/drivers/acpi/acpica/utglobal.c
+++ b/drivers/acpi/acpica/utglobal.c
@@ -336,7 +336,6 @@ acpi_status acpi_ut_init_globals(void)
         acpi_gbl_trace_dbg_layer = 0;
         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
         acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
-        acpi_gbl_osi_data = 0;
         acpi_gbl_osi_mutex = NULL;
         acpi_gbl_reg_methods_executed = FALSE;
 
diff --git a/drivers/acpi/acpica/utosi.c b/drivers/acpi/acpica/utosi.c
index 7e807725c636..8856bd37bc76 100644
--- a/drivers/acpi/acpica/utosi.c
+++ b/drivers/acpi/acpica/utosi.c
@@ -77,21 +77,20 @@ static struct acpi_interface_info acpi_default_supported_interfaces[] = {
 
         /* Feature Group Strings */
 
-        {"Extended Address Space Descriptor", NULL, 0, 0}
+        {"Extended Address Space Descriptor", NULL, ACPI_OSI_FEATURE, 0},
 
         /*
          * All "optional" feature group strings (features that are implemented
-         * by the host) should be dynamically added by the host via
-         * acpi_install_interface and should not be manually added here.
-         *
-         * Examples of optional feature group strings:
-         *
-         * "Module Device"
-         * "Processor Device"
-         * "3.0 Thermal Model"
-         * "3.0 _SCP Extensions"
-         * "Processor Aggregator Device"
+         * by the host) should be dynamically modified to VALID by the host via
+         * acpi_install_interface or acpi_update_interfaces. Such optional feature
+         * group strings are set as INVALID by default here.
          */
+
+        {"Module Device", NULL, ACPI_OSI_OPTIONAL_FEATURE, 0},
+        {"Processor Device", NULL, ACPI_OSI_OPTIONAL_FEATURE, 0},
+        {"3.0 Thermal Model", NULL, ACPI_OSI_OPTIONAL_FEATURE, 0},
+        {"3.0 _SCP Extensions", NULL, ACPI_OSI_OPTIONAL_FEATURE, 0},
+        {"Processor Aggregator Device", NULL, ACPI_OSI_OPTIONAL_FEATURE, 0}
 };
 
 /*******************************************************************************
@@ -158,11 +157,20 @@ acpi_status acpi_ut_interface_terminate(void)
         while (next_interface) {
                 acpi_gbl_supported_interfaces = next_interface->next;
 
-                /* Only interfaces added at runtime can be freed */
-
                 if (next_interface->flags & ACPI_OSI_DYNAMIC) {
+
+                        /* Only interfaces added at runtime can be freed */
+
                         ACPI_FREE(next_interface->name);
                         ACPI_FREE(next_interface);
+                } else {
+                        /* Interface is in static list. Reset it to invalid or valid. */
+
+                        if (next_interface->flags & ACPI_OSI_DEFAULT_INVALID) {
+                                next_interface->flags |= ACPI_OSI_INVALID;
+                        } else {
+                                next_interface->flags &= ~ACPI_OSI_INVALID;
+                        }
                 }
 
                 next_interface = acpi_gbl_supported_interfaces;
@@ -278,6 +286,49 @@ acpi_status acpi_ut_remove_interface(acpi_string interface_name)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ut_update_interfaces
+ *
+ * PARAMETERS:  action              - Actions to be performed during the
+ *                                    update
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Update _OSI interface strings, disabling or enabling OS vendor
+ *              strings or/and feature group strings.
+ *              Caller MUST hold acpi_gbl_osi_mutex
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ut_update_interfaces(u8 action)
+{
+        struct acpi_interface_info *next_interface;
+
+        next_interface = acpi_gbl_supported_interfaces;
+        while (next_interface) {
+                if (((next_interface->flags & ACPI_OSI_FEATURE) &&
+                     (action & ACPI_FEATURE_STRINGS)) ||
+                    (!(next_interface->flags & ACPI_OSI_FEATURE) &&
+                     (action & ACPI_VENDOR_STRINGS))) {
+                        if (action & ACPI_DISABLE_INTERFACES) {
+
+                                /* Mark the interfaces as invalid */
+
+                                next_interface->flags |= ACPI_OSI_INVALID;
+                        } else {
+                                /* Mark the interfaces as valid */
+
+                                next_interface->flags &= ~ACPI_OSI_INVALID;
+                        }
+                }
+
+                next_interface = next_interface->next;
+        }
+
+        return (AE_OK);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ut_get_interface
  *
  * PARAMETERS:  interface_name      - The interface to find
diff --git a/drivers/acpi/acpica/utstring.c b/drivers/acpi/acpica/utstring.c
index c53759b76a3f..cb1e9cc32d5f 100644
--- a/drivers/acpi/acpica/utstring.c
+++ b/drivers/acpi/acpica/utstring.c
@@ -333,7 +333,8 @@ acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer)
  * FUNCTION:    acpi_ut_print_string
  *
  * PARAMETERS:  string          - Null terminated ASCII string
- *              max_length      - Maximum output length
+ *              max_length      - Maximum output length. Used to constrain the
+ *                                length of strings during debug output only.
  *
  * RETURN:      None
  *
@@ -342,7 +343,7 @@ acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer)
  *
  ******************************************************************************/
 
-void acpi_ut_print_string(char *string, u8 max_length)
+void acpi_ut_print_string(char *string, u16 max_length)
 {
         u32 i;
 
diff --git a/drivers/acpi/acpica/utxface.c b/drivers/acpi/acpica/utxface.c
index 6505774f223e..03a211e6e26a 100644
--- a/drivers/acpi/acpica/utxface.c
+++ b/drivers/acpi/acpica/utxface.c
@@ -389,6 +389,34 @@ ACPI_EXPORT_SYMBOL(acpi_install_interface_handler)
 
 /*****************************************************************************
  *
+ * FUNCTION:    acpi_update_interfaces
+ *
+ * PARAMETERS:  action              - Actions to be performed during the
+ *                                    update
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Update _OSI interface strings, disabling or enabling OS vendor
+ *              string or/and feature group strings.
+ *
+ ****************************************************************************/
+acpi_status acpi_update_interfaces(u8 action)
+{
+        acpi_status status;
+
+        status = acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
+        if (ACPI_FAILURE(status)) {
+                return (status);
+        }
+
+        status = acpi_ut_update_interfaces(action);
+
+        acpi_os_release_mutex(acpi_gbl_osi_mutex);
+        return (status);
+}
+
+/*****************************************************************************
+ *
  * FUNCTION:    acpi_check_address_range
  *
  * PARAMETERS:  space_id            - Address space ID
@@ -402,6 +430,7 @@ ACPI_EXPORT_SYMBOL(acpi_install_interface_handler)
  *              ASL operation region address ranges.
  *
  ****************************************************************************/
+
 u32
 acpi_check_address_range(acpi_adr_space_type space_id,
                          acpi_physical_address address,
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index d405fbad406a..2c9958cd7a43 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -527,18 +527,14 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 {
         acpi_status status = 0;
-        union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg0 };
 
         if (!acpi_battery_present(battery) ||
             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
                 return -ENODEV;
 
-        arg0.integer.value = battery->alarm;
-
         mutex_lock(&battery->lock);
-        status = acpi_evaluate_object(battery->device->handle, "_BTP",
-                                 &arg_list, NULL);
+        status = acpi_execute_simple_method(battery->device->handle, "_BTP",
+                                            battery->alarm);
         mutex_unlock(&battery->lock);
 
         if (ACPI_FAILURE(status))
@@ -550,12 +546,8 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery)
 
 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 {
-        acpi_status status = AE_OK;
-        acpi_handle handle = NULL;
-
         /* See if alarms are supported, and if so, set default */
-        status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
-        if (ACPI_FAILURE(status)) {
+        if (!acpi_has_method(battery->device->handle, "_BTP")) {
                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
                 return 0;
         }
@@ -1036,8 +1028,6 @@ static void acpi_battery_notify(struct acpi_device *device, u32 event)
         if (event == ACPI_BATTERY_NOTIFY_INFO)
                 acpi_battery_refresh(battery);
         acpi_battery_update(battery);
-        acpi_bus_generate_proc_event(device, event,
-                                     acpi_battery_present(battery));
         acpi_bus_generate_netlink_event(device->pnp.device_class,
                                         dev_name(&device->dev), event,
                                         acpi_battery_present(battery));
@@ -1068,7 +1058,7 @@ static int acpi_battery_add(struct acpi_device *device)
 {
         int result = 0;
         struct acpi_battery *battery = NULL;
-        acpi_handle handle;
+
         if (!device)
                 return -EINVAL;
         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
@@ -1080,8 +1070,7 @@ static int acpi_battery_add(struct acpi_device *device)
         device->driver_data = battery;
         mutex_init(&battery->lock);
         mutex_init(&battery->sysfs_lock);
-        if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
-                        "_BIX", &handle)))
+        if (acpi_has_method(battery->device->handle, "_BIX"))
                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
         result = acpi_battery_update(battery);
         if (result)
diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index cb9629638def..9515f18898b2 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -192,6 +192,12 @@ static int __init dmi_disable_osi_win7(const struct dmi_system_id *d)
         acpi_osi_setup("!Windows 2009");
         return 0;
 }
+static int __init dmi_disable_osi_win8(const struct dmi_system_id *d)
+{
+        printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
+        acpi_osi_setup("!Windows 2012");
+        return 0;
+}
 
 static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
         {
@@ -267,6 +273,30 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P305D"),
                 },
         },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "ASUS Zenbook Prime UX31A",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "UX31A"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "Dell Inspiron 15R SE",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "Lenovo ThinkPad Edge E530",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "3259A2G"),
+                },
+        },
 
         /*
          * BIOS invocation of _OSI(Linux) is almost always a BIOS bug.
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index a5bb33bab448..b587ec8257b2 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -89,27 +89,6 @@ static struct dmi_system_id dsdt_dmi_table[] __initdata = {
                                 Device Management
    -------------------------------------------------------------------------- */
 
-int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
-{
-        acpi_status status;
-
-        if (!device)
-                return -EINVAL;
-
-        /* TBD: Support fixed-feature devices */
-
-        status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
-        if (ACPI_FAILURE(status) || !*device) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
-                                  handle));
-                return -ENODEV;
-        }
-
-        return 0;
-}
-
-EXPORT_SYMBOL(acpi_bus_get_device);
-
 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
                                        unsigned long long *sta)
 {
@@ -346,104 +325,6 @@ static void acpi_bus_osc_support(void)
 }
 
 /* --------------------------------------------------------------------------
-                                Event Management
-   -------------------------------------------------------------------------- */
-
-#ifdef CONFIG_ACPI_PROC_EVENT
-static DEFINE_SPINLOCK(acpi_bus_event_lock);
-
-LIST_HEAD(acpi_bus_event_list);
-DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
-
-extern int event_is_open;
-
-int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
-{
-        struct acpi_bus_event *event;
-        unsigned long flags;
-
-        /* drop event on the floor if no one's listening */
-        if (!event_is_open)
-                return 0;
-
-        event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
-        if (!event)
-                return -ENOMEM;
-
-        strcpy(event->device_class, device_class);
-        strcpy(event->bus_id, bus_id);
-        event->type = type;
-        event->data = data;
-
-        spin_lock_irqsave(&acpi_bus_event_lock, flags);
-        list_add_tail(&event->node, &acpi_bus_event_list);
-        spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
-
-        wake_up_interruptible(&acpi_bus_event_queue);
-
-        return 0;
-
-}
-
-EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);
-
-int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
-{
-        if (!device)
-                return -EINVAL;
-        return acpi_bus_generate_proc_event4(device->pnp.device_class,
-                                             device->pnp.bus_id, type, data);
-}
-
-EXPORT_SYMBOL(acpi_bus_generate_proc_event);
-
-int acpi_bus_receive_event(struct acpi_bus_event *event)
-{
-        unsigned long flags;
-        struct acpi_bus_event *entry = NULL;
-
-        DECLARE_WAITQUEUE(wait, current);
-
-
-        if (!event)
-                return -EINVAL;
-
-        if (list_empty(&acpi_bus_event_list)) {
-
-                set_current_state(TASK_INTERRUPTIBLE);
-                add_wait_queue(&acpi_bus_event_queue, &wait);
-
-                if (list_empty(&acpi_bus_event_list))
-                        schedule();
-
-                remove_wait_queue(&acpi_bus_event_queue, &wait);
-                set_current_state(TASK_RUNNING);
-
-                if (signal_pending(current))
-                        return -ERESTARTSYS;
-        }
-
-        spin_lock_irqsave(&acpi_bus_event_lock, flags);
-        if (!list_empty(&acpi_bus_event_list)) {
-                entry = list_entry(acpi_bus_event_list.next,
-                                   struct acpi_bus_event, node);
-                list_del(&entry->node);
-        }
-        spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
-
-        if (!entry)
-                return -ENODEV;
-
-        memcpy(event, entry, sizeof(struct acpi_bus_event));
-
-        kfree(entry);
-
-        return 0;
-}
-
-#endif  /* CONFIG_ACPI_PROC_EVENT */
-
-/* --------------------------------------------------------------------------
                              Notification Handling
    -------------------------------------------------------------------------- */
 
@@ -499,19 +380,6 @@ static void acpi_bus_check_scope(acpi_handle handle)
          */
 }
 
-static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
-int register_acpi_bus_notifier(struct notifier_block *nb)
-{
-        return blocking_notifier_chain_register(&acpi_bus_notify_list, nb);
-}
-EXPORT_SYMBOL_GPL(register_acpi_bus_notifier);
-
-void unregister_acpi_bus_notifier(struct notifier_block *nb)
-{
-        blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb);
-}
-EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);
-
 /**
  * acpi_bus_notify
  * ---------------
@@ -525,9 +393,6 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
                           type, handle));
 
-        blocking_notifier_call_chain(&acpi_bus_notify_list,
-                type, (void *)handle);
-
         switch (type) {
 
         case ACPI_NOTIFY_BUS_CHECK:
@@ -593,8 +458,6 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
 static int __init acpi_bus_init_irq(void)
 {
         acpi_status status;
-        union acpi_object arg = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg };
         char *message = NULL;
 
 
@@ -623,9 +486,7 @@ static int __init acpi_bus_init_irq(void)
 
         printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
 
-        arg.integer.value = acpi_irq_model;
-
-        status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
+        status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
                 return -ENODEV;
@@ -715,7 +576,6 @@ static int __init acpi_bus_init(void)
 {
         int result;
         acpi_status status;
-        extern acpi_status acpi_os_initialize1(void);
 
         acpi_os_initialize1();
 
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index d2e617b5b3f6..a55773801c5f 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -303,8 +303,6 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
 
                         pm_wakeup_event(&device->dev, 0);
                 }
-
-                acpi_bus_generate_proc_event(device, event, ++button->pushed);
                 break;
         default:
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
index 4ab807dc8518..59d3202f6b36 100644
--- a/drivers/acpi/device_pm.c
+++ b/drivers/acpi/device_pm.c
@@ -159,26 +159,29 @@ int acpi_device_set_power(struct acpi_device *device, int state)
         int result = 0;
         bool cut_power = false;
 
-        if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
+        if (!device || !device->flags.power_manageable
+            || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
                 return -EINVAL;
 
         /* Make sure this is a valid target state */
 
         if (state == device->power.state) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at %s\n",
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
+                                  device->pnp.bus_id,
                                   acpi_power_state_string(state)));
                 return 0;
         }
 
         if (!device->power.states[state].flags.valid) {
-                printk(KERN_WARNING PREFIX "Device does not support %s\n",
-                       acpi_power_state_string(state));
+                dev_warn(&device->dev, "Power state %s not supported\n",
+                         acpi_power_state_string(state));
                 return -ENODEV;
         }
         if (device->parent && (state < device->parent->power.state)) {
-                printk(KERN_WARNING PREFIX
-                              "Cannot set device to a higher-powered"
-                              " state than parent\n");
+                dev_warn(&device->dev,
+                         "Cannot transition to power state %s for parent in %s\n",
+                         acpi_power_state_string(state),
+                         acpi_power_state_string(device->parent->power.state));
                 return -ENODEV;
         }
 
@@ -191,8 +194,8 @@ int acpi_device_set_power(struct acpi_device *device, int state)
 
         if (state < device->power.state && state != ACPI_STATE_D0
             && device->power.state >= ACPI_STATE_D3_HOT) {
-                printk(KERN_WARNING PREFIX
-                        "Cannot transition to non-D0 state from D3\n");
+                dev_warn(&device->dev,
+                         "Cannot transition to non-D0 state from D3\n");
                 return -ENODEV;
         }
 
@@ -219,10 +222,8 @@ int acpi_device_set_power(struct acpi_device *device, int state)
 
  end:
         if (result) {
-                printk(KERN_WARNING PREFIX
-                              "Device [%s] failed to transition to %s\n",
-                              device->pnp.bus_id,
-                              acpi_power_state_string(state));
+                dev_warn(&device->dev, "Failed to change power state to %s\n",
+                         acpi_power_state_string(state));
         } else {
                 device->power.state = state;
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -244,13 +245,6 @@ int acpi_bus_set_power(acpi_handle handle, int state)
         if (result)
                 return result;
 
-        if (!device->flags.power_manageable) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                "Device [%s] is not power manageable\n",
-                                dev_name(&device->dev)));
-                return -ENODEV;
-        }
-
         return acpi_device_set_power(device, state);
 }
 EXPORT_SYMBOL(acpi_bus_set_power);
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 826560753389..05ea4be01a83 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -51,8 +51,6 @@ MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
         " the driver to wait for userspace to write the undock sysfs file "
         " before undocking");
 
-static struct atomic_notifier_head dock_notifier_list;
-
 static const struct acpi_device_id dock_device_ids[] = {
         {"LNXDOCK", 0},
         {"", 0},
@@ -63,8 +61,6 @@ struct dock_station {
         acpi_handle handle;
         unsigned long last_dock_time;
         u32 flags;
-        spinlock_t dd_lock;
-        struct mutex hp_lock;
         struct list_head dependent_devices;
 
         struct list_head sibling;
@@ -91,6 +87,12 @@ struct dock_dependent_device {
 #define DOCK_EVENT      3
 #define UNDOCK_EVENT    2
 
+enum dock_callback_type {
+        DOCK_CALL_HANDLER,
+        DOCK_CALL_FIXUP,
+        DOCK_CALL_UEVENT,
+};
+
 /*****************************************************************************
  *                         Dock Dependent device functions                   *
  *****************************************************************************/
@@ -101,7 +103,7 @@ struct dock_dependent_device {
  *
  * Add the dependent device to the dock's dependent device list.
  */
-static int
+static int __init
 add_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
 {
         struct dock_dependent_device *dd;
@@ -112,14 +114,21 @@ add_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
 
         dd->handle = handle;
         INIT_LIST_HEAD(&dd->list);
-
-        spin_lock(&ds->dd_lock);
         list_add_tail(&dd->list, &ds->dependent_devices);
-        spin_unlock(&ds->dd_lock);
 
         return 0;
 }
 
+static void remove_dock_dependent_devices(struct dock_station *ds)
+{
+        struct dock_dependent_device *dd, *aux;
+
+        list_for_each_entry_safe(dd, aux, &ds->dependent_devices, list) {
+                list_del(&dd->list);
+                kfree(dd);
+        }
+}
+
 /**
  * dock_init_hotplug - Initialize a hotplug device on a docking station.
  * @dd: Dock-dependent device.
@@ -135,19 +144,16 @@ static int dock_init_hotplug(struct dock_dependent_device *dd,
         int ret = 0;
 
         mutex_lock(&hotplug_lock);
-
-        if (dd->hp_context) {
+        if (WARN_ON(dd->hp_context)) {
                 ret = -EEXIST;
         } else {
                 dd->hp_refcount = 1;
                 dd->hp_ops = ops;
                 dd->hp_context = context;
                 dd->hp_release = release;
+                if (init)
+                        init(context);
         }
-
-        if (!WARN_ON(ret) && init)
-                init(context);
-
         mutex_unlock(&hotplug_lock);
         return ret;
 }
@@ -162,27 +168,22 @@ static int dock_init_hotplug(struct dock_dependent_device *dd,
  */
 static void dock_release_hotplug(struct dock_dependent_device *dd)
 {
-        void (*release)(void *) = NULL;
-        void *context = NULL;
-
         mutex_lock(&hotplug_lock);
-
         if (dd->hp_context && !--dd->hp_refcount) {
+                void (*release)(void *) = dd->hp_release;
+                void *context = dd->hp_context;
+
                 dd->hp_ops = NULL;
-                context = dd->hp_context;
                 dd->hp_context = NULL;
-                release = dd->hp_release;
                 dd->hp_release = NULL;
+                if (release)
+                        release(context);
         }
-
-        if (release && context)
-                release(context);
-
         mutex_unlock(&hotplug_lock);
 }
 
 static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
-                               bool uevent)
+                               enum dock_callback_type cb_type)
 {
         acpi_notify_handler cb = NULL;
         bool run = false;
@@ -192,8 +193,18 @@ static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
         if (dd->hp_context) {
                 run = true;
                 dd->hp_refcount++;
-                if (dd->hp_ops)
-                        cb = uevent ? dd->hp_ops->uevent : dd->hp_ops->handler;
+                if (dd->hp_ops) {
+                        switch (cb_type) {
+                        case DOCK_CALL_FIXUP:
+                                cb = dd->hp_ops->fixup;
+                                break;
+                        case DOCK_CALL_UEVENT:
+                                cb = dd->hp_ops->uevent;
+                                break;
+                        default:
+                                cb = dd->hp_ops->handler;
+                        }
+                }
         }
 
         mutex_unlock(&hotplug_lock);
@@ -220,63 +231,17 @@ find_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
 {
         struct dock_dependent_device *dd;
 
-        spin_lock(&ds->dd_lock);
-        list_for_each_entry(dd, &ds->dependent_devices, list) {
-                if (handle == dd->handle) {
-                        spin_unlock(&ds->dd_lock);
+        list_for_each_entry(dd, &ds->dependent_devices, list)
+                if (handle == dd->handle)
                         return dd;
-                }
-        }
-        spin_unlock(&ds->dd_lock);
+
         return NULL;
 }
 
 /*****************************************************************************
  *                         Dock functions                                    *
  *****************************************************************************/
-/**
- * is_dock - see if a device is a dock station
- * @handle: acpi handle of the device
- *
- * If an acpi object has a _DCK method, then it is by definition a dock
- * station, so return true.
- */
-static int is_dock(acpi_handle handle)
-{
-        acpi_status status;
-        acpi_handle tmp;
-
-        status = acpi_get_handle(handle, "_DCK", &tmp);
-        if (ACPI_FAILURE(status))
-                return 0;
-        return 1;
-}
-
-static int is_ejectable(acpi_handle handle)
-{
-        acpi_status status;
-        acpi_handle tmp;
-
-        status = acpi_get_handle(handle, "_EJ0", &tmp);
-        if (ACPI_FAILURE(status))
-                return 0;
-        return 1;
-}
-
-static int is_ata(acpi_handle handle)
-{
-        acpi_handle tmp;
-
-        if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
-           (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
-           (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
-           (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
-                return 1;
-
-        return 0;
-}
-
-static int is_battery(acpi_handle handle)
+static int __init is_battery(acpi_handle handle)
 {
         struct acpi_device_info *info;
         int ret = 1;
@@ -292,17 +257,13 @@ static int is_battery(acpi_handle handle)
         return ret;
 }
 
-static int is_ejectable_bay(acpi_handle handle)
+/* Check whether ACPI object is an ejectable battery or disk bay */
+static bool __init is_ejectable_bay(acpi_handle handle)
 {
-        acpi_handle phandle;
+        if (acpi_has_method(handle, "_EJ0") && is_battery(handle))
+                return true;
 
-        if (!is_ejectable(handle))
-                return 0;
-        if (is_battery(handle) || is_ata(handle))
-                return 1;
-        if (!acpi_get_parent(handle, &phandle) && is_ata(phandle))
-                return 1;
-        return 0;
+        return acpi_bay_match(handle);
 }
 
 /**
@@ -320,7 +281,7 @@ int is_dock_device(acpi_handle handle)
         if (!dock_station_count)
                 return 0;
 
-        if (is_dock(handle))
+        if (acpi_dock_match(handle))
                 return 1;
 
         list_for_each_entry(dock_station, &dock_stations, sibling)
@@ -359,10 +320,8 @@ static int dock_present(struct dock_station *ds)
  *  handle if one does not exist already.  This should cause
  *  acpi to scan for drivers for the given devices, and call
  *  matching driver's add routine.
- *
- *  Returns a pointer to the acpi_device corresponding to the handle.
  */
-static struct acpi_device * dock_create_acpi_device(acpi_handle handle)
+static void dock_create_acpi_device(acpi_handle handle)
 {
         struct acpi_device *device;
         int ret;
@@ -375,10 +334,7 @@ static struct acpi_device * dock_create_acpi_device(acpi_handle handle)
                 ret = acpi_bus_scan(handle);
                 if (ret)
                         pr_debug("error adding bus, %x\n", -ret);
-
-                acpi_bus_get_device(handle, &device);
         }
-        return device;
 }
 
 /**
@@ -397,9 +353,29 @@ static void dock_remove_acpi_device(acpi_handle handle)
 }
 
 /**
- * hotplug_dock_devices - insert or remove devices on the dock station
+ * hot_remove_dock_devices - Remove dock station devices.
+ * @ds: Dock station.
+ */
+static void hot_remove_dock_devices(struct dock_station *ds)
+{
+        struct dock_dependent_device *dd;
+
+        /*
+         * Walk the list in reverse order so that devices that have been added
+         * last are removed first (in case there are some indirect dependencies
+         * between them).
+         */
+        list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
+                dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false);
+
+        list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
+                dock_remove_acpi_device(dd->handle);
+}
+
+/**
+ * hotplug_dock_devices - Insert devices on a dock station.
  * @ds: the dock station
- * @event: either bus check or eject request
+ * @event: either bus check or device check request
  *
  * Some devices on the dock station need to have drivers called
  * to perform hotplug operations after a dock event has occurred.
@@ -410,27 +386,21 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
 {
         struct dock_dependent_device *dd;
 
-        mutex_lock(&ds->hp_lock);
+        /* Call driver specific post-dock fixups. */
+        list_for_each_entry(dd, &ds->dependent_devices, list)
+                dock_hotplug_event(dd, event, DOCK_CALL_FIXUP);
 
-        /*
-         * First call driver specific hotplug functions
-         */
+        /* Call driver specific hotplug functions. */
         list_for_each_entry(dd, &ds->dependent_devices, list)
-                dock_hotplug_event(dd, event, false);
+                dock_hotplug_event(dd, event, DOCK_CALL_HANDLER);
 
         /*
-         * Now make sure that an acpi_device is created for each
-         * dependent device, or removed if this is an eject request.
-         * This will cause acpi_drivers to be stopped/started if they
-         * exist
+         * Now make sure that an acpi_device is created for each dependent
+         * device.  That will cause scan handlers to be attached to device
+         * objects or acpi_drivers to be stopped/started if they are present.
          */
-        list_for_each_entry(dd, &ds->dependent_devices, list) {
-                if (event == ACPI_NOTIFY_EJECT_REQUEST)
-                        dock_remove_acpi_device(dd->handle);
-                else
-                        dock_create_acpi_device(dd->handle);
-        }
-        mutex_unlock(&ds->hp_lock);
+        list_for_each_entry(dd, &ds->dependent_devices, list)
+                dock_create_acpi_device(dd->handle);
 }
 
 static void dock_event(struct dock_station *ds, u32 event, int num)
@@ -453,44 +423,13 @@ static void dock_event(struct dock_station *ds, u32 event, int num)
                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 
         list_for_each_entry(dd, &ds->dependent_devices, list)
-                dock_hotplug_event(dd, event, true);
+                dock_hotplug_event(dd, event, DOCK_CALL_UEVENT);
 
         if (num != DOCK_EVENT)
                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 }
 
 /**
- * eject_dock - respond to a dock eject request
- * @ds: the dock station
- *
- * This is called after _DCK is called, to execute the dock station's
- * _EJ0 method.
- */
-static void eject_dock(struct dock_station *ds)
-{
-        struct acpi_object_list arg_list;
-        union acpi_object arg;
-        acpi_status status;
-        acpi_handle tmp;
-
-        /* all dock devices should have _EJ0, but check anyway */
-        status = acpi_get_handle(ds->handle, "_EJ0", &tmp);
-        if (ACPI_FAILURE(status)) {
-                pr_debug("No _EJ0 support for dock device\n");
-                return;
-        }
-
-        arg_list.count = 1;
-        arg_list.pointer = &arg;
-        arg.type = ACPI_TYPE_INTEGER;
-        arg.integer.value = 1;
-
-        status = acpi_evaluate_object(ds->handle, "_EJ0", &arg_list, NULL);
-        if (ACPI_FAILURE(status))
-                pr_debug("Failed to evaluate _EJ0!\n");
-}
-
-/**
  * handle_dock - handle a dock event
  * @ds: the dock station
  * @dock: to dock, or undock - that is the question
@@ -550,27 +489,6 @@ static inline void complete_undock(struct dock_station *ds)
         ds->flags &= ~(DOCK_UNDOCKING);
 }
 
-static void dock_lock(struct dock_station *ds, int lock)
-{
-        struct acpi_object_list arg_list;
-        union acpi_object arg;
-        acpi_status status;
-
-        arg_list.count = 1;
-        arg_list.pointer = &arg;
-        arg.type = ACPI_TYPE_INTEGER;
-        arg.integer.value = !!lock;
-        status = acpi_evaluate_object(ds->handle, "_LCK", &arg_list, NULL);
-        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-                if (lock)
-                        acpi_handle_warn(ds->handle,
-                                "Locking device failed (0x%x)\n", status);
-                else
-                        acpi_handle_warn(ds->handle,
-                                "Unlocking device failed (0x%x)\n", status);
-        }
-}
-
 /**
  * dock_in_progress - see if we are in the middle of handling a dock event
  * @ds: the dock station
@@ -588,37 +506,6 @@ static int dock_in_progress(struct dock_station *ds)
 }
 
 /**
- * register_dock_notifier - add yourself to the dock notifier list
- * @nb: the callers notifier block
- *
- * If a driver wishes to be notified about dock events, they can
- * use this function to put a notifier block on the dock notifier list.
- * this notifier call chain will be called after a dock event, but
- * before hotplugging any new devices.
- */
-int register_dock_notifier(struct notifier_block *nb)
-{
-        if (!dock_station_count)
-                return -ENODEV;
-
-        return atomic_notifier_chain_register(&dock_notifier_list, nb);
-}
-EXPORT_SYMBOL_GPL(register_dock_notifier);
-
-/**
- * unregister_dock_notifier - remove yourself from the dock notifier list
- * @nb: the callers notifier block
- */
-void unregister_dock_notifier(struct notifier_block *nb)
-{
-        if (!dock_station_count)
-                return;
-
-        atomic_notifier_chain_unregister(&dock_notifier_list, nb);
-}
-EXPORT_SYMBOL_GPL(unregister_dock_notifier);
-
-/**
  * register_hotplug_dock_device - register a hotplug function
  * @handle: the handle of the device
  * @ops: handlers to call after docking
@@ -703,10 +590,10 @@ static int handle_eject_request(struct dock_station *ds, u32 event)
          */
         dock_event(ds, event, UNDOCK_EVENT);
 
-        hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
+        hot_remove_dock_devices(ds);
         undock(ds);
-        dock_lock(ds, 0);
-        eject_dock(ds);
+        acpi_evaluate_lck(ds->handle, 0);
+        acpi_evaluate_ej0(ds->handle);
         if (dock_present(ds)) {
                 acpi_handle_err(ds->handle, "Unable to undock!\n");
                 return -EBUSY;
@@ -717,18 +604,17 @@ static int handle_eject_request(struct dock_station *ds, u32 event)
 
 /**
  * dock_notify - act upon an acpi dock notification
- * @handle: the dock station handle
+ * @ds: dock station
  * @event: the acpi event
- * @data: our driver data struct
  *
  * If we are notified to dock, then check to see if the dock is
  * present and then dock.  Notify all drivers of the dock event,
  * and then hotplug and devices that may need hotplugging.
  */
-static void dock_notify(acpi_handle handle, u32 event, void *data)
+static void dock_notify(struct dock_station *ds, u32 event)
 {
-        struct dock_station *ds = data;
-        struct acpi_device *tmp;
+        acpi_handle handle = ds->handle;
+        struct acpi_device *ad;
         int surprise_removal = 0;
 
         /*
@@ -751,8 +637,7 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
         switch (event) {
         case ACPI_NOTIFY_BUS_CHECK:
         case ACPI_NOTIFY_DEVICE_CHECK:
-                if (!dock_in_progress(ds) && acpi_bus_get_device(ds->handle,
-                   &tmp)) {
+                if (!dock_in_progress(ds) && acpi_bus_get_device(handle, &ad)) {
                         begin_dock(ds);
                         dock(ds);
                         if (!dock_present(ds)) {
@@ -760,12 +645,10 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
                                 complete_dock(ds);
                                 break;
                         }
-                        atomic_notifier_call_chain(&dock_notifier_list,
-                                                   event, NULL);
                         hotplug_dock_devices(ds, event);
                         complete_dock(ds);
                         dock_event(ds, event, DOCK_EVENT);
-                        dock_lock(ds, 1);
+                        acpi_evaluate_lck(ds->handle, 1);
                         acpi_update_all_gpes();
                         break;
                 }
@@ -789,9 +672,8 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
 }
 
 struct dock_data {
-        acpi_handle handle;
-        unsigned long event;
         struct dock_station *ds;
+        u32 event;
 };
 
 static void acpi_dock_deferred_cb(void *context)
@@ -799,52 +681,31 @@ static void acpi_dock_deferred_cb(void *context)
         struct dock_data *data = context;
 
         acpi_scan_lock_acquire();
-        dock_notify(data->handle, data->event, data->ds);
+        dock_notify(data->ds, data->event);
         acpi_scan_lock_release();
         kfree(data);
 }
 
-static int acpi_dock_notifier_call(struct notifier_block *this,
-        unsigned long event, void *data)
+static void dock_notify_handler(acpi_handle handle, u32 event, void *data)
 {
-        struct dock_station *dock_station;
-        acpi_handle handle = data;
+        struct dock_data *dd;
 
         if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK
            && event != ACPI_NOTIFY_EJECT_REQUEST)
-                return 0;
-
-        acpi_scan_lock_acquire();
-
-        list_for_each_entry(dock_station, &dock_stations, sibling) {
-                if (dock_station->handle == handle) {
-                        struct dock_data *dd;
-                        acpi_status status;
-
-                        dd = kmalloc(sizeof(*dd), GFP_KERNEL);
-                        if (!dd)
-                                break;
+                return;
 
-                        dd->handle = handle;
-                        dd->event = event;
-                        dd->ds = dock_station;
-                        status = acpi_os_hotplug_execute(acpi_dock_deferred_cb,
-                                                         dd);
-                        if (ACPI_FAILURE(status))
-                                kfree(dd);
+        dd = kmalloc(sizeof(*dd), GFP_KERNEL);
+        if (dd) {
+                acpi_status status;
 
-                        break;
-                }
+                dd->ds = data;
+                dd->event = event;
+                status = acpi_os_hotplug_execute(acpi_dock_deferred_cb, dd);
+                if (ACPI_FAILURE(status))
+                        kfree(dd);
         }
-
-        acpi_scan_lock_release();
-        return 0;
 }
 
-static struct notifier_block dock_acpi_notifier = {
-        .notifier_call = acpi_dock_notifier_call,
-};
-
 /**
  * find_dock_devices - find devices on the dock station
  * @handle: the handle of the device we are examining
@@ -856,29 +717,16 @@ static struct notifier_block dock_acpi_notifier = {
  * check to see if an object has an _EJD method.  If it does, then it
  * will see if it is dependent on the dock station.
  */
-static acpi_status
-find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
+static acpi_status __init find_dock_devices(acpi_handle handle, u32 lvl,
+                                            void *context, void **rv)
 {
-        acpi_status status;
-        acpi_handle tmp, parent;
         struct dock_station *ds = context;
+        acpi_handle ejd = NULL;
 
-        status = acpi_bus_get_ejd(handle, &tmp);
-        if (ACPI_FAILURE(status)) {
-                /* try the parent device as well */
-                status = acpi_get_parent(handle, &parent);
-                if (ACPI_FAILURE(status))
-                        goto fdd_out;
-                /* see if parent is dependent on dock */
-                status = acpi_bus_get_ejd(parent, &tmp);
-                if (ACPI_FAILURE(status))
-                        goto fdd_out;
-        }
-
-        if (tmp == ds->handle)
+        acpi_bus_get_ejd(handle, &ejd);
+        if (ejd == ds->handle)
                 add_dock_dependent_device(ds, handle);
 
-fdd_out:
         return AE_OK;
 }
 
@@ -988,13 +836,13 @@ static struct attribute_group dock_attribute_group = {
  */
 static int __init dock_add(acpi_handle handle)
 {
-        int ret, id;
-        struct dock_station ds, *dock_station;
+        struct dock_station *dock_station, ds = { NULL, };
         struct platform_device *dd;
+        acpi_status status;
+        int ret;
 
-        id = dock_station_count;
-        memset(&ds, 0, sizeof(ds));
-        dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds));
+        dd = platform_device_register_data(NULL, "dock", dock_station_count,
+                                           &ds, sizeof(ds));
         if (IS_ERR(dd))
                 return PTR_ERR(dd);
 
@@ -1004,18 +852,15 @@ static int __init dock_add(acpi_handle handle)
         dock_station->dock_device = dd;
         dock_station->last_dock_time = jiffies - HZ;
 
-        mutex_init(&dock_station->hp_lock);
-        spin_lock_init(&dock_station->dd_lock);
         INIT_LIST_HEAD(&dock_station->sibling);
-        ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
         INIT_LIST_HEAD(&dock_station->dependent_devices);
 
         /* we want the dock device to send uevents */
         dev_set_uevent_suppress(&dd->dev, 0);
 
-        if (is_dock(handle))
+        if (acpi_dock_match(handle))
                 dock_station->flags |= DOCK_IS_DOCK;
-        if (is_ata(handle))
+        if (acpi_ata_match(handle))
                 dock_station->flags |= DOCK_IS_ATA;
         if (is_battery(handle))
                 dock_station->flags |= DOCK_IS_BAT;
@@ -1034,11 +879,19 @@ static int __init dock_add(acpi_handle handle)
         if (ret)
                 goto err_rmgroup;
 
+        status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
+                                             dock_notify_handler, dock_station);
+        if (ACPI_FAILURE(status)) {
+                ret = -ENODEV;
+                goto err_rmgroup;
+        }
+
         dock_station_count++;
         list_add(&dock_station->sibling, &dock_stations);
         return 0;
 
 err_rmgroup:
+        remove_dock_dependent_devices(dock_station);
         sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group);
 err_unregister:
         platform_device_unregister(dd);
@@ -1055,10 +908,10 @@ err_unregister:
  *
  * This is called by acpi_walk_namespace to look for dock stations and bays.
  */
-static __init acpi_status
+static acpi_status __init
 find_dock_and_bay(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
-        if (is_dock(handle) || is_ejectable_bay(handle))
+        if (acpi_dock_match(handle) || is_ejectable_bay(handle))
                 dock_add(handle);
 
         return AE_OK;
@@ -1078,7 +931,6 @@ void __init acpi_dock_init(void)
                 return;
         }
 
-        register_acpi_bus_notifier(&dock_acpi_notifier);
         pr_info(PREFIX "%s: %d docks/bays found\n",
                 ACPI_DOCK_DRIVER_DESCRIPTION, dock_station_count);
 }
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 80403c1a89f8..a06d98374705 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -948,7 +948,7 @@ static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
         return 0;
 }
 
-static struct dmi_system_id __initdata ec_dmi_table[] = {
+static struct dmi_system_id ec_dmi_table[] __initdata = {
         {
         ec_skip_dsdt_scan, "Compal JFL92", {
         DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
@@ -987,6 +987,10 @@ static struct dmi_system_id __initdata ec_dmi_table[] = {
         ec_skip_dsdt_scan, "HP Folio 13", {
         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
         DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
+        {
+        ec_validate_ecdt, "ASUS hardware", {
+        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
+        DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
         {},
 };
 
@@ -1049,10 +1053,8 @@ int __init acpi_ec_ecdt_probe(void)
                 * which needs it, has fake EC._INI method, so use it as flag.
                 * Keep boot_ec struct as it will be needed soon.
                 */
-                acpi_handle dummy;
                 if (!dmi_name_in_vendors("ASUS") ||
-                    ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI",
-                                                        &dummy)))
+                    !acpi_has_method(boot_ec->handle, "_INI"))
                         return -ENODEV;
         }
 install:
diff --git a/drivers/acpi/event.c b/drivers/acpi/event.c
index 1442737cedec..8247fcdde079 100644
--- a/drivers/acpi/event.c
+++ b/drivers/acpi/event.c
@@ -21,100 +21,6 @@
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
 ACPI_MODULE_NAME("event");
 
-#ifdef CONFIG_ACPI_PROC_EVENT
-/* Global vars for handling event proc entry */
-static DEFINE_SPINLOCK(acpi_system_event_lock);
-int event_is_open = 0;
-extern struct list_head acpi_bus_event_list;
-extern wait_queue_head_t acpi_bus_event_queue;
-
-static int acpi_system_open_event(struct inode *inode, struct file *file)
-{
-        spin_lock_irq(&acpi_system_event_lock);
-
-        if (event_is_open)
-                goto out_busy;
-
-        event_is_open = 1;
-
-        spin_unlock_irq(&acpi_system_event_lock);
-        return 0;
-
-      out_busy:
-        spin_unlock_irq(&acpi_system_event_lock);
-        return -EBUSY;
-}
-
-static ssize_t
-acpi_system_read_event(struct file *file, char __user * buffer, size_t count,
-                       loff_t * ppos)
-{
-        int result = 0;
-        struct acpi_bus_event event;
-        static char str[ACPI_MAX_STRING];
-        static int chars_remaining = 0;
-        static char *ptr;
-
-        if (!chars_remaining) {
-                memset(&event, 0, sizeof(struct acpi_bus_event));
-
-                if ((file->f_flags & O_NONBLOCK)
-                    && (list_empty(&acpi_bus_event_list)))
-                        return -EAGAIN;
-
-                result = acpi_bus_receive_event(&event);
-                if (result)
-                        return result;
-
-                chars_remaining = sprintf(str, "%s %s %08x %08x\n",
-                                          event.device_class ? event.
-                                          device_class : "<unknown>",
-                                          event.bus_id ? event.
-                                          bus_id : "<unknown>", event.type,
-                                          event.data);
-                ptr = str;
-        }
-
-        if (chars_remaining < count) {
-                count = chars_remaining;
-        }
-
-        if (copy_to_user(buffer, ptr, count))
-                return -EFAULT;
-
-        *ppos += count;
-        chars_remaining -= count;
-        ptr += count;
-
-        return count;
-}
-
-static int acpi_system_close_event(struct inode *inode, struct file *file)
-{
-        spin_lock_irq(&acpi_system_event_lock);
-        event_is_open = 0;
-        spin_unlock_irq(&acpi_system_event_lock);
-        return 0;
-}
-
-static unsigned int acpi_system_poll_event(struct file *file, poll_table * wait)
-{
-        poll_wait(file, &acpi_bus_event_queue, wait);
-        if (!list_empty(&acpi_bus_event_list))
-                return POLLIN | POLLRDNORM;
-        return 0;
-}
-
-static const struct file_operations acpi_system_event_ops = {
-        .owner = THIS_MODULE,
-        .open = acpi_system_open_event,
-        .read = acpi_system_read_event,
-        .release = acpi_system_close_event,
-        .poll = acpi_system_poll_event,
-        .llseek = default_llseek,
-};
-#endif  /* CONFIG_ACPI_PROC_EVENT */
-
 /* ACPI notifier chain */
 static BLOCKING_NOTIFIER_HEAD(acpi_chain_head);
 
@@ -280,9 +186,6 @@ static int acpi_event_genetlink_init(void)
 
 static int __init acpi_event_init(void)
 {
-#ifdef CONFIG_ACPI_PROC_EVENT
-        struct proc_dir_entry *entry;
-#endif
         int error = 0;
 
         if (acpi_disabled)
@@ -293,15 +196,6 @@ static int __init acpi_event_init(void)
         if (error)
                 printk(KERN_WARNING PREFIX
                        "Failed to create genetlink family for ACPI event\n");
-
-#ifdef CONFIG_ACPI_PROC_EVENT
-        /* 'event' [R] */
-        entry = proc_create("event", S_IRUSR, acpi_root_dir,
-                            &acpi_system_event_ops);
-        if (!entry)
-                return -ENODEV;
-#endif
-
         return 0;
 }
 
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 5b02a0aa540c..41ade6570bc0 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -93,7 +93,7 @@ static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
         if (result)
                 return result;
 
-        *state = (acpi_state == ACPI_STATE_D3 ? 0 :
+        *state = (acpi_state == ACPI_STATE_D3_COLD ? 0 :
                  (acpi_state == ACPI_STATE_D0 ? 1 : -1));
         return 0;
 }
@@ -108,7 +108,7 @@ fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
                 return -EINVAL;
 
         result = acpi_bus_set_power(device->handle,
-                                state ? ACPI_STATE_D0 : ACPI_STATE_D3);
+                                state ? ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
 
         return result;
 }
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 408f6b2a5fa8..94672297e1b1 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -173,6 +173,15 @@ acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge)
 }
 EXPORT_SYMBOL_GPL(acpi_find_child);
 
+static void acpi_physnode_link_name(char *buf, unsigned int node_id)
+{
+        if (node_id > 0)
+                snprintf(buf, PHYSICAL_NODE_NAME_SIZE,
+                         PHYSICAL_NODE_STRING "%u", node_id);
+        else
+                strcpy(buf, PHYSICAL_NODE_STRING);
+}
+
 int acpi_bind_one(struct device *dev, acpi_handle handle)
 {
         struct acpi_device *acpi_dev;
@@ -216,8 +225,15 @@ int acpi_bind_one(struct device *dev, acpi_handle handle)
         list_for_each_entry(pn, &acpi_dev->physical_node_list, node) {
                 /* Sanity check. */
                 if (pn->dev == dev) {
+                        mutex_unlock(&acpi_dev->physical_node_lock);
+
                         dev_warn(dev, "Already associated with ACPI node\n");
-                        goto err_free;
+                        kfree(physical_node);
+                        if (ACPI_HANDLE(dev) != handle)
+                                goto err;
+
+                        put_device(dev);
+                        return 0;
                 }
                 if (pn->node_id == node_id) {
                         physnode_list = &pn->node;
@@ -230,20 +246,23 @@ int acpi_bind_one(struct device *dev, acpi_handle handle)
         list_add(&physical_node->node, physnode_list);
         acpi_dev->physical_node_count++;
 
-        mutex_unlock(&acpi_dev->physical_node_lock);
-
         if (!ACPI_HANDLE(dev))
                 ACPI_HANDLE_SET(dev, acpi_dev->handle);
 
-        if (!physical_node->node_id)
-                strcpy(physical_node_name, PHYSICAL_NODE_STRING);
-        else
-                sprintf(physical_node_name,
-                        "physical_node%d", physical_node->node_id);
+        acpi_physnode_link_name(physical_node_name, node_id);
         retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
-                        physical_node_name);
+                                   physical_node_name);
+        if (retval)
+                dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n",
+                        physical_node_name, retval);
+
         retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
-                "firmware_node");
+                                   "firmware_node");
+        if (retval)
+                dev_err(dev, "Failed to create link firmware_node (%d)\n",
+                        retval);
+
+        mutex_unlock(&acpi_dev->physical_node_lock);
 
         if (acpi_dev->wakeup.flags.valid)
                 device_set_wakeup_capable(dev, true);
@@ -254,11 +273,6 @@ int acpi_bind_one(struct device *dev, acpi_handle handle)
         ACPI_HANDLE_SET(dev, NULL);
         put_device(dev);
         return retval;
-
- err_free:
-        mutex_unlock(&acpi_dev->physical_node_lock);
-        kfree(physical_node);
-        goto err;
 }
 EXPORT_SYMBOL_GPL(acpi_bind_one);
 
@@ -267,48 +281,37 @@ int acpi_unbind_one(struct device *dev)
         struct acpi_device_physical_node *entry;
         struct acpi_device *acpi_dev;
         acpi_status status;
-        struct list_head *node, *next;
 
         if (!ACPI_HANDLE(dev))
                 return 0;
 
         status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev);
-        if (ACPI_FAILURE(status))
-                goto err;
+        if (ACPI_FAILURE(status)) {
+                dev_err(dev, "Oops, ACPI handle corrupt in %s()\n", __func__);
+                return -EINVAL;
+        }
 
         mutex_lock(&acpi_dev->physical_node_lock);
-        list_for_each_safe(node, next, &acpi_dev->physical_node_list) {
-                char physical_node_name[PHYSICAL_NODE_NAME_SIZE];
 
-                entry = list_entry(node, struct acpi_device_physical_node,
-                        node);
-                if (entry->dev != dev)
-                        continue;
+        list_for_each_entry(entry, &acpi_dev->physical_node_list, node)
+                if (entry->dev == dev) {
+                        char physnode_name[PHYSICAL_NODE_NAME_SIZE];
 
-                list_del(node);
+                        list_del(&entry->node);
+                        acpi_dev->physical_node_count--;
 
-                acpi_dev->physical_node_count--;
+                        acpi_physnode_link_name(physnode_name, entry->node_id);
+                        sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name);
+                        sysfs_remove_link(&dev->kobj, "firmware_node");
+                        ACPI_HANDLE_SET(dev, NULL);
+                        /* acpi_bind_one() increase refcnt by one. */
+                        put_device(dev);
+                        kfree(entry);
+                        break;
+                }
 
-                if (!entry->node_id)
-                        strcpy(physical_node_name, PHYSICAL_NODE_STRING);
-                else
-                        sprintf(physical_node_name,
-                                "physical_node%d", entry->node_id);
-
-                sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name);
-                sysfs_remove_link(&dev->kobj, "firmware_node");
-                ACPI_HANDLE_SET(dev, NULL);
-                /* acpi_bind_one increase refcnt by one */
-                put_device(dev);
-                kfree(entry);
-        }
         mutex_unlock(&acpi_dev->physical_node_lock);
-
         return 0;
-
-err:
-        dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
-        return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(acpi_unbind_one);
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 5da44e81dd4d..20f423337e1f 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -23,6 +23,7 @@
 
 #define PREFIX "ACPI: "
 
+acpi_status acpi_os_initialize1(void);
 int init_acpi_device_notify(void);
 int acpi_scan_init(void);
 #ifdef  CONFIG_ACPI_PCI_SLOT
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 33e609f63585..2e82e5d76930 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -159,7 +159,7 @@ acpi_table_print_srat_entry(struct acpi_subtable_header *header)
  * distance than the others.
  * Do some quick checks here and only use the SLIT if it passes.
  */
-static __init int slit_valid(struct acpi_table_slit *slit)
+static int __init slit_valid(struct acpi_table_slit *slit)
 {
         int i, j;
         int d = slit->locality_count;
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 6ab2c3505520..e5f416c7f66e 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -52,6 +52,7 @@
 #include <acpi/acpi.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/processor.h>
+#include "internal.h"
 
 #define _COMPONENT              ACPI_OS_SERVICES
 ACPI_MODULE_NAME("osl");
@@ -79,6 +80,8 @@ extern char line_buf[80];
 
 static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
                                       u32 pm1b_ctrl);
+static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
+                                      u32 val_b);
 
 static acpi_osd_handler acpi_irq_handler;
 static void *acpi_irq_context;
@@ -140,7 +143,8 @@ static struct osi_linux {
         unsigned int    enable:1;
         unsigned int    dmi:1;
         unsigned int    cmdline:1;
-} osi_linux = {0, 0, 0};
+        unsigned int    default_disabling:1;
+} osi_linux = {0, 0, 0, 0};
 
 static u32 acpi_osi_handler(acpi_string interface, u32 supported)
 {
@@ -563,10 +567,6 @@ static const char * const table_sigs[] = {
         ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
         ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
 
-/* Non-fatal errors: Affected tables/files are ignored */
-#define INVALID_TABLE(x, path, name)                                    \
-        { pr_err("ACPI OVERRIDE: " x " [%s%s]\n", path, name); continue; }
-
 #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
 
 /* Must not increase 10 or needs code modification below */
@@ -593,9 +593,11 @@ void __init acpi_initrd_override(void *data, size_t size)
                 data += offset;
                 size -= offset;
 
-                if (file.size < sizeof(struct acpi_table_header))
-                        INVALID_TABLE("Table smaller than ACPI header",
-                                      cpio_path, file.name);
+                if (file.size < sizeof(struct acpi_table_header)) {
+                        pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
+                                cpio_path, file.name);
+                        continue;
+                }
 
                 table = file.data;
 
@@ -603,15 +605,21 @@ void __init acpi_initrd_override(void *data, size_t size)
                         if (!memcmp(table->signature, table_sigs[sig], 4))
                                 break;
 
-                if (!table_sigs[sig])
-                        INVALID_TABLE("Unknown signature",
-                                      cpio_path, file.name);
-                if (file.size != table->length)
-                        INVALID_TABLE("File length does not match table length",
-                                      cpio_path, file.name);
-                if (acpi_table_checksum(file.data, table->length))
-                        INVALID_TABLE("Bad table checksum",
-                                      cpio_path, file.name);
+                if (!table_sigs[sig]) {
+                        pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
+                                cpio_path, file.name);
+                        continue;
+                }
+                if (file.size != table->length) {
+                        pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
+                                cpio_path, file.name);
+                        continue;
+                }
+                if (acpi_table_checksum(file.data, table->length)) {
+                        pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
+                                cpio_path, file.name);
+                        continue;
+                }
 
                 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
                         table->signature, cpio_path, file.name, table->length);
@@ -1351,8 +1359,8 @@ struct osi_setup_entry {
         bool enable;
 };
 
-static struct osi_setup_entry __initdata
-                osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
+static struct osi_setup_entry
+                osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {
         {"Module Device", true},
         {"Processor Device", true},
         {"3.0 _SCP Extensions", true},
@@ -1376,6 +1384,17 @@ void __init acpi_osi_setup(char *str)
 
         if (*str == '!') {
                 str++;
+                if (*str == '\0') {
+                        osi_linux.default_disabling = 1;
+                        return;
+                } else if (*str == '*') {
+                        acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);
+                        for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
+                                osi = &osi_setup_entries[i];
+                                osi->enable = false;
+                        }
+                        return;
+                }
                 enable = false;
         }
 
@@ -1441,6 +1460,13 @@ static void __init acpi_osi_setup_late(void)
         int i;
         acpi_status status;
 
+        if (osi_linux.default_disabling) {
+                status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
+
+                if (ACPI_SUCCESS(status))
+                        printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n");
+        }
+
         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
                 osi = &osi_setup_entries[i];
                 str = osi->string;
@@ -1779,6 +1805,28 @@ void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
         __acpi_os_prepare_sleep = func;
 }
 
+acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
+                                  u32 val_b)
+{
+        int rc = 0;
+        if (__acpi_os_prepare_extended_sleep)
+                rc = __acpi_os_prepare_extended_sleep(sleep_state,
+                                             val_a, val_b);
+        if (rc < 0)
+                return AE_ERROR;
+        else if (rc > 0)
+                return AE_CTRL_SKIP;
+
+        return AE_OK;
+}
+
+void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
+                               u32 val_a, u32 val_b))
+{
+        __acpi_os_prepare_extended_sleep = func;
+}
+
+
 void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
                         void (*func)(struct work_struct *work))
 {
diff --git a/drivers/acpi/pci_slot.c b/drivers/acpi/pci_slot.c
index 033d1179bdb5..d678a180ca2a 100644
--- a/drivers/acpi/pci_slot.c
+++ b/drivers/acpi/pci_slot.c
@@ -159,12 +159,16 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         return AE_OK;
 }
 
-void acpi_pci_slot_enumerate(struct pci_bus *bus, acpi_handle handle)
+void acpi_pci_slot_enumerate(struct pci_bus *bus)
 {
-        mutex_lock(&slot_list_lock);
-        acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
-                            register_slot, NULL, bus, NULL);
-        mutex_unlock(&slot_list_lock);
+        acpi_handle handle = ACPI_HANDLE(bus->bridge);
+
+        if (handle) {
+                mutex_lock(&slot_list_lock);
+                acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
+                                    register_slot, NULL, bus, NULL);
+                mutex_unlock(&slot_list_lock);
+        }
 }
 
 void acpi_pci_slot_remove(struct pci_bus *bus)
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 5c28c894c0fc..0dbe5cdf3396 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -637,9 +637,7 @@ int acpi_device_sleep_wake(struct acpi_device *dev,
         }
 
         /* Execute _PSW */
-        arg_list.count = 1;
-        in_arg[0].integer.value = enable;
-        status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
+        status = acpi_execute_simple_method(dev->handle, "_PSW", enable);
         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
                 printk(KERN_ERR PREFIX "_PSW execution failed\n");
                 dev->wakeup.flags.valid = 0;
@@ -786,7 +784,7 @@ int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
                 }
         }
 
-        *state = ACPI_STATE_D3;
+        *state = ACPI_STATE_D3_COLD;
         return 0;
 }
 
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index a5e9f4a5b281..cf34d903f4fb 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -28,7 +28,7 @@ static int __init set_no_mwait(const struct dmi_system_id *id)
         return 0;
 }
 
-static struct dmi_system_id __initdata processor_idle_dmi_table[] = {
+static struct dmi_system_id processor_idle_dmi_table[] __initdata = {
         {
         set_no_mwait, "Extensa 5220", {
         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 870eaf5fa547..e534ba66d5b8 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -91,21 +91,17 @@ static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
                 acpi_processor_ppc_has_changed(pr, 1);
                 if (saved == pr->performance_platform_limit)
                         break;
-                acpi_bus_generate_proc_event(device, event,
-                                        pr->performance_platform_limit);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event,
                                                   pr->performance_platform_limit);
                 break;
         case ACPI_PROCESSOR_NOTIFY_POWER:
                 acpi_processor_cst_has_changed(pr);
-                acpi_bus_generate_proc_event(device, event, 0);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event, 0);
                 break;
         case ACPI_PROCESSOR_NOTIFY_THROTTLING:
                 acpi_processor_tstate_has_changed(pr);
-                acpi_bus_generate_proc_event(device, event, 0);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event, 0);
                 break;
@@ -179,7 +175,9 @@ static int __acpi_processor_start(struct acpi_device *device)
         acpi_processor_load_module(pr);
 #endif
         acpi_processor_get_throttling_info(pr);
-        acpi_processor_get_limit_info(pr);
+
+        if (pr->flags.throttling)
+                pr->flags.limit = 1;
 
         if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver)
                 acpi_processor_power_init(pr);
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 1e9732d809bf..51d7948611da 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -164,17 +164,12 @@ static void acpi_processor_ppc_ost(acpi_handle handle, int status)
                 {.type = ACPI_TYPE_INTEGER,},
         };
         struct acpi_object_list arg_list = {2, params};
-        acpi_handle temp;
 
-        params[0].integer.value = ACPI_PROCESSOR_NOTIFY_PERFORMANCE;
-        params[1].integer.value =  status;
-
-        /* when there is no _OST , skip it */
-        if (ACPI_FAILURE(acpi_get_handle(handle, "_OST", &temp)))
-                return;
-
-        acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
-        return;
+        if (acpi_has_method(handle, "_OST")) {
+                params[0].integer.value = ACPI_PROCESSOR_NOTIFY_PERFORMANCE;
+                params[1].integer.value =  status;
+                acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
+        }
 }
 
 int acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag)
@@ -468,14 +463,11 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
 int acpi_processor_get_performance_info(struct acpi_processor *pr)
 {
         int result = 0;
-        acpi_status status = AE_OK;
-        acpi_handle handle = NULL;
 
         if (!pr || !pr->performance || !pr->handle)
                 return -EINVAL;
 
-        status = acpi_get_handle(pr->handle, "_PCT", &handle);
-        if (ACPI_FAILURE(status)) {
+        if (!acpi_has_method(pr->handle, "_PCT")) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "ACPI-based processor performance control unavailable\n"));
                 return -ENODEV;
@@ -501,7 +493,7 @@ int acpi_processor_get_performance_info(struct acpi_processor *pr)
          */
  update_bios:
 #ifdef CONFIG_X86
-        if (ACPI_SUCCESS(acpi_get_handle(pr->handle, "_PPC", &handle))){
+        if (acpi_has_method(pr->handle, "_PPC")) {
                 if(boot_cpu_has(X86_FEATURE_EST))
                         printk(KERN_WARNING FW_BUG "BIOS needs update for CPU "
                                "frequency support\n");
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index e8e652710e65..d1d2e7fb5b30 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -186,18 +186,6 @@ static int cpufreq_set_cur_state(unsigned int cpu, int state)
 
 #endif
 
-int acpi_processor_get_limit_info(struct acpi_processor *pr)
-{
-
-        if (!pr)
-                return -EINVAL;
-
-        if (pr->flags.throttling)
-                pr->flags.limit = 1;
-
-        return 0;
-}
-
 /* thermal coolign device callbacks */
 static int acpi_processor_max_state(struct acpi_processor *pr)
 {
diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
index 3322b47ab7ca..b7201fc6f1e1 100644
--- a/drivers/acpi/resource.c
+++ b/drivers/acpi/resource.c
@@ -505,14 +505,12 @@ int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
                            void *preproc_data)
 {
         struct res_proc_context c;
-        acpi_handle not_used;
         acpi_status status;
 
         if (!adev || !adev->handle || !list_empty(list))
                 return -EINVAL;
 
-        status = acpi_get_handle(adev->handle, METHOD_NAME__CRS, &not_used);
-        if (ACPI_FAILURE(status))
+        if (!acpi_has_method(adev->handle, METHOD_NAME__CRS))
                 return 0;
 
         c.list = list;
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index b6241eeb1132..aef7e1cd1e5d 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -873,14 +873,9 @@ static void acpi_sbs_callback(void *context)
         u8 saved_charger_state = sbs->charger_present;
         u8 saved_battery_state;
         acpi_ac_get_present(sbs);
-        if (sbs->charger_present != saved_charger_state) {
-#ifdef CONFIG_ACPI_PROC_EVENT
-                acpi_bus_generate_proc_event4(ACPI_AC_CLASS, ACPI_AC_DIR_NAME,
-                                              ACPI_SBS_NOTIFY_STATUS,
-                                              sbs->charger_present);
-#endif
+        if (sbs->charger_present != saved_charger_state)
                 kobject_uevent(&sbs->charger.dev->kobj, KOBJ_CHANGE);
-        }
+
         if (sbs->manager_present) {
                 for (id = 0; id < MAX_SBS_BAT; ++id) {
                         if (!(sbs->batteries_supported & (1 << id)))
@@ -890,12 +885,6 @@ static void acpi_sbs_callback(void *context)
                         acpi_battery_read(bat);
                         if (saved_battery_state == bat->present)
                                 continue;
-#ifdef CONFIG_ACPI_PROC_EVENT
-                        acpi_bus_generate_proc_event4(ACPI_BATTERY_CLASS,
-                                                      bat->name,
-                                                      ACPI_SBS_NOTIFY_STATUS,
-                                                      bat->present);
-#endif
                         kobject_uevent(&bat->bat.dev->kobj, KOBJ_CHANGE);
                 }
         }
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 8a46c924effd..61d090b6ce25 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -193,9 +193,6 @@ static acpi_status acpi_bus_online_companions(acpi_handle handle, u32 lvl,
 static int acpi_scan_hot_remove(struct acpi_device *device)
 {
         acpi_handle handle = device->handle;
-        acpi_handle not_used;
-        struct acpi_object_list arg_list;
-        union acpi_object arg;
         struct device *errdev;
         acpi_status status;
         unsigned long long sta;
@@ -258,32 +255,15 @@ static int acpi_scan_hot_remove(struct acpi_device *device)
         put_device(&device->dev);
         device = NULL;
 
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_LCK", &not_used))) {
-                arg_list.count = 1;
-                arg_list.pointer = &arg;
-                arg.type = ACPI_TYPE_INTEGER;
-                arg.integer.value = 0;
-                acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
-        }
-
-        arg_list.count = 1;
-        arg_list.pointer = &arg;
-        arg.type = ACPI_TYPE_INTEGER;
-        arg.integer.value = 1;
-
+        acpi_evaluate_lck(handle, 0);
         /*
          * TBD: _EJD support.
          */
-        status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
-        if (ACPI_FAILURE(status)) {
-                if (status == AE_NOT_FOUND) {
-                        return -ENODEV;
-                } else {
-                        acpi_handle_warn(handle, "Eject failed (0x%x)\n",
-                                                                status);
-                        return -EIO;
-                }
-        }
+        status = acpi_evaluate_ej0(handle);
+        if (status == AE_NOT_FOUND)
+                return -ENODEV;
+        else if (ACPI_FAILURE(status))
+                return -EIO;
 
         /*
          * Verify if eject was indeed successful.  If not, log an error
@@ -307,6 +287,7 @@ static void acpi_bus_device_eject(void *context)
         struct acpi_device *device = NULL;
         struct acpi_scan_handler *handler;
         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
+        int error;
 
         mutex_lock(&acpi_scan_lock);
 
@@ -321,17 +302,13 @@ static void acpi_bus_device_eject(void *context)
         }
         acpi_evaluate_hotplug_ost(handle, ACPI_NOTIFY_EJECT_REQUEST,
                                   ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
-        if (handler->hotplug.mode == AHM_CONTAINER) {
-                device->flags.eject_pending = true;
+        if (handler->hotplug.mode == AHM_CONTAINER)
                 kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
-        } else {
-                int error;
 
-                get_device(&device->dev);
-                error = acpi_scan_hot_remove(device);
-                if (error)
-                        goto err_out;
-        }
+        get_device(&device->dev);
+        error = acpi_scan_hot_remove(device);
+        if (error)
+                goto err_out;
 
  out:
         mutex_unlock(&acpi_scan_lock);
@@ -516,7 +493,6 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
         struct acpi_eject_event *ej_event;
         acpi_object_type not_used;
         acpi_status status;
-        u32 ost_source;
         int ret;
 
         if (!count || buf[0] != '1')
@@ -530,43 +506,28 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
         if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
                 return -ENODEV;
 
-        mutex_lock(&acpi_scan_lock);
-
-        if (acpi_device->flags.eject_pending) {
-                /* ACPI eject notification event. */
-                ost_source = ACPI_NOTIFY_EJECT_REQUEST;
-                acpi_device->flags.eject_pending = 0;
-        } else {
-                /* Eject initiated by user space. */
-                ost_source = ACPI_OST_EC_OSPM_EJECT;
-        }
         ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
         if (!ej_event) {
                 ret = -ENOMEM;
                 goto err_out;
         }
-        acpi_evaluate_hotplug_ost(acpi_device->handle, ost_source,
+        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 = ost_source;
+        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);
-        if (ACPI_FAILURE(status)) {
-                put_device(&acpi_device->dev);
-                kfree(ej_event);
-                ret = status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
-                goto err_out;
-        }
-        ret = count;
+        if (ACPI_SUCCESS(status))
+                return count;
 
- out:
-        mutex_unlock(&acpi_scan_lock);
-        return ret;
+        put_device(&acpi_device->dev);
+        kfree(ej_event);
+        ret = status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
 
  err_out:
-        acpi_evaluate_hotplug_ost(acpi_device->handle, ost_source,
+        acpi_evaluate_hotplug_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
                                   ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
-        goto out;
+        return ret;
 }
 
 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
@@ -654,7 +615,6 @@ static int acpi_device_setup_files(struct acpi_device *dev)
 {
         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
         acpi_status status;
-        acpi_handle temp;
         unsigned long long sun;
         int result = 0;
 
@@ -680,8 +640,7 @@ static int acpi_device_setup_files(struct acpi_device *dev)
         /*
          * If device has _STR, 'description' file is created
          */
-        status = acpi_get_handle(dev->handle, "_STR", &temp);
-        if (ACPI_SUCCESS(status)) {
+        if (acpi_has_method(dev->handle, "_STR")) {
                 status = acpi_evaluate_object(dev->handle, "_STR",
                                         NULL, &buffer);
                 if (ACPI_FAILURE(status))
@@ -711,8 +670,7 @@ static int acpi_device_setup_files(struct acpi_device *dev)
          * If device has _EJ0, 'eject' file is created that is used to trigger
          * hot-removal function from userland.
          */
-        status = acpi_get_handle(dev->handle, "_EJ0", &temp);
-        if (ACPI_SUCCESS(status)) {
+        if (acpi_has_method(dev->handle, "_EJ0")) {
                 result = device_create_file(&dev->dev, &dev_attr_eject);
                 if (result)
                         return result;
@@ -734,9 +692,6 @@ end:
 
 static void acpi_device_remove_files(struct acpi_device *dev)
 {
-        acpi_status status;
-        acpi_handle temp;
-
         if (dev->flags.power_manageable) {
                 device_remove_file(&dev->dev, &dev_attr_power_state);
                 if (dev->power.flags.power_resources)
@@ -747,20 +702,17 @@ static void acpi_device_remove_files(struct acpi_device *dev)
         /*
          * If device has _STR, remove 'description' file
          */
-        status = acpi_get_handle(dev->handle, "_STR", &temp);
-        if (ACPI_SUCCESS(status)) {
+        if (acpi_has_method(dev->handle, "_STR")) {
                 kfree(dev->pnp.str_obj);
                 device_remove_file(&dev->dev, &dev_attr_description);
         }
         /*
          * If device has _EJ0, remove 'eject' file.
          */
-        status = acpi_get_handle(dev->handle, "_EJ0", &temp);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(dev->handle, "_EJ0"))
                 device_remove_file(&dev->dev, &dev_attr_eject);
 
-        status = acpi_get_handle(dev->handle, "_SUN", &temp);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(dev->handle, "_SUN"))
                 device_remove_file(&dev->dev, &dev_attr_sun);
 
         if (dev->pnp.unique_id)
@@ -999,6 +951,28 @@ struct bus_type acpi_bus_type = {
         .uevent         = acpi_device_uevent,
 };
 
+static void acpi_bus_data_handler(acpi_handle handle, void *context)
+{
+        /* Intentionally empty. */
+}
+
+int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
+{
+        acpi_status status;
+
+        if (!device)
+                return -EINVAL;
+
+        status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
+        if (ACPI_FAILURE(status) || !*device) {
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
+                                  handle));
+                return -ENODEV;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_bus_get_device);
+
 int acpi_device_add(struct acpi_device *device,
                     void (*release)(struct device *))
 {
@@ -1210,14 +1184,6 @@ acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
 }
 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
 
-void acpi_bus_data_handler(acpi_handle handle, void *context)
-{
-
-        /* TBD */
-
-        return;
-}
-
 static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
                                         struct acpi_device_wakeup *wakeup)
 {
@@ -1336,13 +1302,10 @@ static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
 
 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 {
-        acpi_handle temp;
-        acpi_status status = 0;
         int err;
 
         /* Presence of _PRW indicates wake capable */
-        status = acpi_get_handle(device->handle, "_PRW", &temp);
-        if (ACPI_FAILURE(status))
+        if (!acpi_has_method(device->handle, "_PRW"))
                 return;
 
         err = acpi_bus_extract_wakeup_device_power_package(device->handle,
@@ -1372,7 +1335,6 @@ static void acpi_bus_init_power_state(struct acpi_device *device, int state)
         struct acpi_device_power_state *ps = &device->power.states[state];
         char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        acpi_handle handle;
         acpi_status status;
 
         INIT_LIST_HEAD(&ps->resources);
@@ -1395,8 +1357,7 @@ static void acpi_bus_init_power_state(struct acpi_device *device, int state)
 
         /* Evaluate "_PSx" to see if we can do explicit sets */
         pathname[2] = 'S';
-        status = acpi_get_handle(device->handle, pathname, &handle);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, pathname))
                 ps->flags.explicit_set = 1;
 
         /*
@@ -1415,28 +1376,21 @@ static void acpi_bus_init_power_state(struct acpi_device *device, int state)
 
 static void acpi_bus_get_power_flags(struct acpi_device *device)
 {
-        acpi_status status;
-        acpi_handle handle;
         u32 i;
 
         /* Presence of _PS0|_PR0 indicates 'power manageable' */
-        status = acpi_get_handle(device->handle, "_PS0", &handle);
-        if (ACPI_FAILURE(status)) {
-                status = acpi_get_handle(device->handle, "_PR0", &handle);
-                if (ACPI_FAILURE(status))
-                        return;
-        }
+        if (!acpi_has_method(device->handle, "_PS0") &&
+            !acpi_has_method(device->handle, "_PR0"))
+                return;
 
         device->flags.power_manageable = 1;
 
         /*
          * Power Management Flags
          */
-        status = acpi_get_handle(device->handle, "_PSC", &handle);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, "_PSC"))
                 device->power.flags.explicit_get = 1;
-        status = acpi_get_handle(device->handle, "_IRC", &handle);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, "_IRC"))
                 device->power.flags.inrush_current = 1;
 
         /*
@@ -1450,8 +1404,8 @@ static void acpi_bus_get_power_flags(struct acpi_device *device)
         /* Set defaults for D0 and D3 states (always valid) */
         device->power.states[ACPI_STATE_D0].flags.valid = 1;
         device->power.states[ACPI_STATE_D0].power = 100;
-        device->power.states[ACPI_STATE_D3].flags.valid = 1;
-        device->power.states[ACPI_STATE_D3].power = 0;
+        device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
+        device->power.states[ACPI_STATE_D3_COLD].power = 0;
 
         /* Set D3cold's explicit_set flag if _PS3 exists. */
         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
@@ -1470,28 +1424,18 @@ static void acpi_bus_get_power_flags(struct acpi_device *device)
 
 static void acpi_bus_get_flags(struct acpi_device *device)
 {
-        acpi_status status = AE_OK;
-        acpi_handle temp = NULL;
-
         /* Presence of _STA indicates 'dynamic_status' */
-        status = acpi_get_handle(device->handle, "_STA", &temp);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, "_STA"))
                 device->flags.dynamic_status = 1;
 
         /* Presence of _RMV indicates 'removable' */
-        status = acpi_get_handle(device->handle, "_RMV", &temp);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, "_RMV"))
                 device->flags.removable = 1;
 
         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
-        status = acpi_get_handle(device->handle, "_EJD", &temp);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(device->handle, "_EJD") ||
+            acpi_has_method(device->handle, "_EJ0"))
                 device->flags.ejectable = 1;
-        else {
-                status = acpi_get_handle(device->handle, "_EJ0", &temp);
-                if (ACPI_SUCCESS(status))
-                        device->flags.ejectable = 1;
-        }
 }
 
 static void acpi_device_get_busid(struct acpi_device *device)
@@ -1533,46 +1477,45 @@ static void acpi_device_get_busid(struct acpi_device *device)
 }
 
 /*
+ * acpi_ata_match - see if an acpi object is an ATA device
+ *
+ * If an acpi object has one of the ACPI ATA methods defined,
+ * then we can safely call it an ATA device.
+ */
+bool acpi_ata_match(acpi_handle handle)
+{
+        return acpi_has_method(handle, "_GTF") ||
+               acpi_has_method(handle, "_GTM") ||
+               acpi_has_method(handle, "_STM") ||
+               acpi_has_method(handle, "_SDD");
+}
+
+/*
  * acpi_bay_match - see if an acpi object is an ejectable driver bay
  *
  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
  * then we can safely call it an ejectable drive bay
  */
-static int acpi_bay_match(acpi_handle handle)
+bool acpi_bay_match(acpi_handle handle)
 {
-        acpi_status status;
-        acpi_handle tmp;
         acpi_handle phandle;
 
-        status = acpi_get_handle(handle, "_EJ0", &tmp);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
-                return 0;
+        if (!acpi_has_method(handle, "_EJ0"))
+                return false;
+        if (acpi_ata_match(handle))
+                return true;
+        if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
+                return false;
 
-        if (acpi_get_parent(handle, &phandle))
-                return -ENODEV;
-
-        if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
-                (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
-                return 0;
-
-        return -ENODEV;
+        return acpi_ata_match(phandle);
 }
 
 /*
  * acpi_dock_match - see if an acpi object has a _DCK method
  */
-static int acpi_dock_match(acpi_handle handle)
+bool acpi_dock_match(acpi_handle handle)
 {
-        acpi_handle tmp;
-        return acpi_get_handle(handle, "_DCK", &tmp);
+        return acpi_has_method(handle, "_DCK");
 }
 
 const char *acpi_device_hid(struct acpi_device *device)
@@ -1610,34 +1553,26 @@ static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
  * lacks the SMBUS01 HID and the methods do not have the necessary "_"
  * prefix.  Work around this.
  */
-static int acpi_ibm_smbus_match(acpi_handle handle)
+static bool acpi_ibm_smbus_match(acpi_handle handle)
 {
-        acpi_handle h_dummy;
-        struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
-        int result;
+        char node_name[ACPI_PATH_SEGMENT_LENGTH];
+        struct acpi_buffer path = { sizeof(node_name), node_name };
 
         if (!dmi_name_in_vendors("IBM"))
-                return -ENODEV;
+                return false;
 
         /* Look for SMBS object */
-        result = acpi_get_name(handle, ACPI_SINGLE_NAME, &path);
-        if (result)
-                return result;
-
-        if (strcmp("SMBS", path.pointer)) {
-                result = -ENODEV;
-                goto out;
-        }
+        if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
+            strcmp("SMBS", path.pointer))
+                return false;
 
         /* Does it have the necessary (but misnamed) methods? */
-        result = -ENODEV;
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "SBI", &h_dummy)) &&
-            ACPI_SUCCESS(acpi_get_handle(handle, "SBR", &h_dummy)) &&
-            ACPI_SUCCESS(acpi_get_handle(handle, "SBW", &h_dummy)))
-                result = 0;
-out:
-        kfree(path.pointer);
-        return result;
+        if (acpi_has_method(handle, "SBI") &&
+            acpi_has_method(handle, "SBR") &&
+            acpi_has_method(handle, "SBW"))
+                return true;
+
+        return false;
 }
 
 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
@@ -1685,11 +1620,11 @@ static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
                  */
                 if (acpi_is_video_device(handle))
                         acpi_add_id(pnp, ACPI_VIDEO_HID);
-                else if (ACPI_SUCCESS(acpi_bay_match(handle)))
+                else if (acpi_bay_match(handle))
                         acpi_add_id(pnp, ACPI_BAY_HID);
-                else if (ACPI_SUCCESS(acpi_dock_match(handle)))
+                else if (acpi_dock_match(handle))
                         acpi_add_id(pnp, ACPI_DOCK_HID);
-                else if (!acpi_ibm_smbus_match(handle))
+                else if (acpi_ibm_smbus_match(handle))
                         acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
                 else if (list_empty(&pnp->ids) && handle == ACPI_ROOT_OBJECT) {
                         acpi_add_id(pnp, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
@@ -1900,7 +1835,6 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
         struct acpi_device *device = NULL;
         int type;
         unsigned long long sta;
-        acpi_status status;
         int result;
 
         acpi_bus_get_device(handle, &device);
@@ -1921,10 +1855,8 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
         if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
             !(sta & ACPI_STA_DEVICE_FUNCTIONING)) {
                 struct acpi_device_wakeup wakeup;
-                acpi_handle temp;
 
-                status = acpi_get_handle(handle, "_PRW", &temp);
-                if (ACPI_SUCCESS(status)) {
+                if (acpi_has_method(handle, "_PRW")) {
                         acpi_bus_extract_wakeup_device_power_package(handle,
                                                                      &wakeup);
                         acpi_power_resources_list_free(&wakeup.resources);
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 187ab61889e6..14df30580e15 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -31,12 +31,9 @@ static u8 sleep_states[ACPI_S_STATE_COUNT];
 
 static void acpi_sleep_tts_switch(u32 acpi_state)
 {
-        union acpi_object in_arg = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &in_arg };
-        acpi_status status = AE_OK;
+        acpi_status status;
 
-        in_arg.integer.value = acpi_state;
-        status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL);
+        status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
                 /*
                  * OS can't evaluate the _TTS object correctly. Some warning
@@ -141,7 +138,7 @@ static int __init init_nvs_nosave(const struct dmi_system_id *d)
         return 0;
 }
 
-static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
+static struct dmi_system_id acpisleep_dmi_table[] __initdata = {
         {
         .callback = init_old_suspend_ordering,
         .ident = "Abit KN9 (nForce4 variant)",
@@ -423,10 +420,21 @@ static void acpi_pm_finish(void)
 }
 
 /**
- *      acpi_pm_end - Finish up suspend sequence.
+ * acpi_pm_start - Start system PM transition.
+ */
+static void acpi_pm_start(u32 acpi_state)
+{
+        acpi_target_sleep_state = acpi_state;
+        acpi_sleep_tts_switch(acpi_target_sleep_state);
+        acpi_scan_lock_acquire();
+}
+
+/**
+ * acpi_pm_end - Finish up system PM transition.
  */
 static void acpi_pm_end(void)
 {
+        acpi_scan_lock_release();
         /*
          * This is necessary in case acpi_pm_finish() is not called during a
          * failing transition to a sleep state.
@@ -454,21 +462,19 @@ static u32 acpi_suspend_states[] = {
 static int acpi_suspend_begin(suspend_state_t pm_state)
 {
         u32 acpi_state = acpi_suspend_states[pm_state];
-        int error = 0;
+        int error;
 
         error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
         if (error)
                 return error;
 
-        if (sleep_states[acpi_state]) {
-                acpi_target_sleep_state = acpi_state;
-                acpi_sleep_tts_switch(acpi_target_sleep_state);
-        } else {
-                printk(KERN_ERR "ACPI does not support this state: %d\n",
-                        pm_state);
-                error = -ENOSYS;
+        if (!sleep_states[acpi_state]) {
+                pr_err("ACPI does not support sleep state S%u\n", acpi_state);
+                return -ENOSYS;
         }
-        return error;
+
+        acpi_pm_start(acpi_state);
+        return 0;
 }
 
 /**
@@ -634,10 +640,8 @@ static int acpi_hibernation_begin(void)
         int error;
 
         error = nvs_nosave ? 0 : suspend_nvs_alloc();
-        if (!error) {
-                acpi_target_sleep_state = ACPI_STATE_S4;
-                acpi_sleep_tts_switch(acpi_target_sleep_state);
-        }
+        if (!error)
+                acpi_pm_start(ACPI_STATE_S4);
 
         return error;
 }
@@ -716,8 +720,10 @@ static int acpi_hibernation_begin_old(void)
         if (!error) {
                 if (!nvs_nosave)
                         error = suspend_nvs_alloc();
-                if (!error)
+                if (!error) {
                         acpi_target_sleep_state = ACPI_STATE_S4;
+                        acpi_scan_lock_acquire();
+                }
         }
         return error;
 }
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index a33821ca3895..6a0329340b42 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -50,11 +50,6 @@
 
 #define ACPI_THERMAL_CLASS              "thermal_zone"
 #define ACPI_THERMAL_DEVICE_NAME        "Thermal Zone"
-#define ACPI_THERMAL_FILE_STATE         "state"
-#define ACPI_THERMAL_FILE_TEMPERATURE   "temperature"
-#define ACPI_THERMAL_FILE_TRIP_POINTS   "trip_points"
-#define ACPI_THERMAL_FILE_COOLING_MODE  "cooling_mode"
-#define ACPI_THERMAL_FILE_POLLING_FREQ  "polling_frequency"
 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
 #define ACPI_THERMAL_NOTIFY_THRESHOLDS  0x81
 #define ACPI_THERMAL_NOTIFY_DEVICES     0x82
@@ -190,7 +185,6 @@ struct acpi_thermal {
         struct thermal_zone_device *thermal_zone;
         int tz_enabled;
         int kelvin_offset;
-        struct mutex lock;
 };
 
 /* --------------------------------------------------------------------------
@@ -239,26 +233,16 @@ static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
 
 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
 {
-        acpi_status status = AE_OK;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg0 };
-        acpi_handle handle = NULL;
-
-
         if (!tz)
                 return -EINVAL;
 
-        status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
-        if (ACPI_FAILURE(status)) {
+        if (!acpi_has_method(tz->device->handle, "_SCP")) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
                 return -ENODEV;
-        }
-
-        arg0.integer.value = mode;
-
-        status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
-        if (ACPI_FAILURE(status))
+        } else if (ACPI_FAILURE(acpi_execute_simple_method(tz->device->handle,
+                                                           "_SCP", mode))) {
                 return -ENODEV;
+        }
 
         return 0;
 }
@@ -491,14 +475,14 @@ static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
                         break;
         }
 
-        if (flag & ACPI_TRIPS_DEVICES) {
-                memset(&devices, 0, sizeof(struct acpi_handle_list));
+        if ((flag & ACPI_TRIPS_DEVICES)
+            && acpi_has_method(tz->device->handle, "_TZD")) {
+                memset(&devices, 0, sizeof(devices));
                 status = acpi_evaluate_reference(tz->device->handle, "_TZD",
                                                 NULL, &devices);
-                if (memcmp(&tz->devices, &devices,
-                                sizeof(struct acpi_handle_list))) {
-                        memcpy(&tz->devices, &devices,
-                                sizeof(struct acpi_handle_list));
+                if (ACPI_SUCCESS(status)
+                    && memcmp(&tz->devices, &devices, sizeof(devices))) {
+                        tz->devices = devices;
                         ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
                 }
         }
@@ -769,7 +753,6 @@ static int thermal_notify(struct thermal_zone_device *thermal, int trip,
         else
                 return 0;
 
-        acpi_bus_generate_proc_event(tz->device, type, 1);
         acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
                                         dev_name(&tz->device->dev), type, 1);
 
@@ -850,12 +833,13 @@ static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
                 if (ACPI_SUCCESS(status) && (dev == device)) {
                         if (bind)
                                 result = thermal_zone_bind_cooling_device
-                                                (thermal, -1, cdev,
-                                                 THERMAL_NO_LIMIT,
+                                                (thermal, THERMAL_TRIPS_NONE,
+                                                 cdev, THERMAL_NO_LIMIT,
                                                  THERMAL_NO_LIMIT);
                         else
                                 result = thermal_zone_unbind_cooling_device
-                                                (thermal, -1, cdev);
+                                                (thermal, THERMAL_TRIPS_NONE,
+                                                 cdev);
                         if (result)
                                 goto failed;
                 }
@@ -980,14 +964,12 @@ static void acpi_thermal_notify(struct acpi_device *device, u32 event)
         case ACPI_THERMAL_NOTIFY_THRESHOLDS:
                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
                 acpi_thermal_check(tz);
-                acpi_bus_generate_proc_event(device, event, 0);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event, 0);
                 break;
         case ACPI_THERMAL_NOTIFY_DEVICES:
                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
                 acpi_thermal_check(tz);
-                acpi_bus_generate_proc_event(device, event, 0);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event, 0);
                 break;
@@ -1101,8 +1083,6 @@ static int acpi_thermal_add(struct acpi_device *device)
         strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
         device->driver_data = tz;
-        mutex_init(&tz->lock);
-
 
         result = acpi_thermal_get_info(tz);
         if (result)
@@ -1135,7 +1115,6 @@ static int acpi_thermal_remove(struct acpi_device *device)
         tz = acpi_driver_data(device);
 
         acpi_thermal_unregister_thermal_zone(tz);
-        mutex_destroy(&tz->lock);
         kfree(tz);
         return 0;
 }
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index 744371304313..552248b0005b 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -495,3 +495,73 @@ acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...)
         kfree(buffer.pointer);
 }
 EXPORT_SYMBOL(acpi_handle_printk);
+
+/**
+ * acpi_has_method: Check whether @handle has a method named @name
+ * @handle: ACPI device handle
+ * @name: name of object or method
+ *
+ * Check whether @handle has a method named @name.
+ */
+bool acpi_has_method(acpi_handle handle, char *name)
+{
+        acpi_handle tmp;
+
+        return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp));
+}
+EXPORT_SYMBOL(acpi_has_method);
+
+acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
+                                       u64 arg)
+{
+        union acpi_object obj = { .type = ACPI_TYPE_INTEGER };
+        struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, };
+
+        obj.integer.value = arg;
+
+        return acpi_evaluate_object(handle, method, &arg_list, NULL);
+}
+EXPORT_SYMBOL(acpi_execute_simple_method);
+
+/**
+ * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations
+ * @handle: ACPI device handle
+ *
+ * Evaluate device's _EJ0 method for hotplug operations.
+ */
+acpi_status acpi_evaluate_ej0(acpi_handle handle)
+{
+        acpi_status status;
+
+        status = acpi_execute_simple_method(handle, "_EJ0", 1);
+        if (status == AE_NOT_FOUND)
+                acpi_handle_warn(handle, "No _EJ0 support for device\n");
+        else if (ACPI_FAILURE(status))
+                acpi_handle_warn(handle, "Eject failed (0x%x)\n", status);
+
+        return status;
+}
+
+/**
+ * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device
+ * @handle: ACPI device handle
+ * @lock: lock device if non-zero, otherwise unlock device
+ *
+ * Evaluate device's _LCK method if present to lock/unlock device
+ */
+acpi_status acpi_evaluate_lck(acpi_handle handle, int lock)
+{
+        acpi_status status;
+
+        status = acpi_execute_simple_method(handle, "_LCK", !!lock);
+        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                if (lock)
+                        acpi_handle_warn(handle,
+                                "Locking device failed (0x%x)\n", status);
+                else
+                        acpi_handle_warn(handle,
+                                "Unlocking device failed (0x%x)\n", status);
+        }
+
+        return status;
+}
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 3270d3c8ba4e..aebcf6355df4 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -1,5 +1,5 @@
 /*
- *  video.c - ACPI Video Driver ($Revision:$)
+ *  video.c - ACPI Video Driver
  *
  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
  *  Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
@@ -88,7 +88,7 @@ module_param(allow_duplicates, bool, 0644);
 static bool use_bios_initial_backlight = 1;
 module_param(use_bios_initial_backlight, bool, 0644);
 
-static int register_count = 0;
+static int register_count;
 static int acpi_video_bus_add(struct acpi_device *device);
 static int acpi_video_bus_remove(struct acpi_device *device);
 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
@@ -118,26 +118,26 @@ struct acpi_video_bus_flags {
 };
 
 struct acpi_video_bus_cap {
-        u8 _DOS:1;              /*Enable/Disable output switching */
-        u8 _DOD:1;              /*Enumerate all devices attached to display adapter */
-        u8 _ROM:1;              /*Get ROM Data */
-        u8 _GPD:1;              /*Get POST Device */
-        u8 _SPD:1;              /*Set POST Device */
-        u8 _VPO:1;              /*Video POST Options */
+        u8 _DOS:1;              /* Enable/Disable output switching */
+        u8 _DOD:1;              /* Enumerate all devices attached to display adapter */
+        u8 _ROM:1;              /* Get ROM Data */
+        u8 _GPD:1;              /* Get POST Device */
+        u8 _SPD:1;              /* Set POST Device */
+        u8 _VPO:1;              /* Video POST Options */
         u8 reserved:2;
 };
 
 struct acpi_video_device_attrib {
         u32 display_index:4;    /* A zero-based instance of the Display */
-        u32 display_port_attachment:4;  /*This field differentiates the display type */
-        u32 display_type:4;     /*Describe the specific type in use */
-        u32 vendor_specific:4;  /*Chipset Vendor Specific */
-        u32 bios_can_detect:1;  /*BIOS can detect the device */
-        u32 depend_on_vga:1;    /*Non-VGA output device whose power is related to 
+        u32 display_port_attachment:4;  /* This field differentiates the display type */
+        u32 display_type:4;     /* Describe the specific type in use */
+        u32 vendor_specific:4;  /* Chipset Vendor Specific */
+        u32 bios_can_detect:1;  /* BIOS can detect the device */
+        u32 depend_on_vga:1;    /* Non-VGA output device whose power is related to
                                    the VGA device. */
-        u32 pipe_id:3;          /*For VGA multiple-head devices. */
-        u32 reserved:10;        /*Must be 0 */
-        u32 device_id_scheme:1; /*Device ID Scheme */
+        u32 pipe_id:3;          /* For VGA multiple-head devices. */
+        u32 reserved:10;        /* Must be 0 */
+        u32 device_id_scheme:1; /* Device ID Scheme */
 };
 
 struct acpi_video_enumerated_device {
@@ -174,19 +174,17 @@ struct acpi_video_device_flags {
 };
 
 struct acpi_video_device_cap {
-        u8 _ADR:1;              /*Return the unique ID */
-        u8 _BCL:1;              /*Query list of brightness control levels supported */
-        u8 _BCM:1;              /*Set the brightness level */
+        u8 _ADR:1;              /* Return the unique ID */
+        u8 _BCL:1;              /* Query list of brightness control levels supported */
+        u8 _BCM:1;              /* Set the brightness level */
         u8 _BQC:1;              /* Get current brightness level */
         u8 _BCQ:1;              /* Some buggy BIOS uses _BCQ instead of _BQC */
-        u8 _DDC:1;              /*Return the EDID for this device */
+        u8 _DDC:1;              /* Return the EDID for this device */
 };
 
 struct acpi_video_brightness_flags {
         u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
-        u8 _BCL_reversed:1;             /* _BCL package is in a reversed order*/
-        u8 _BCL_use_index:1;            /* levels in _BCL are index values */
-        u8 _BCM_use_index:1;            /* input of _BCM is an index value */
+        u8 _BCL_reversed:1;             /* _BCL package is in a reversed order */
         u8 _BQC_use_index:1;            /* _BQC returns an index value */
 };
 
@@ -231,21 +229,22 @@ static int acpi_video_get_next_level(struct acpi_video_device *device,
 static int acpi_video_switch_brightness(struct acpi_video_device *device,
                                          int event);
 
-/*backlight device sysfs support*/
+/* backlight device sysfs support */
 static int acpi_video_get_brightness(struct backlight_device *bd)
 {
         unsigned long long cur_level;
         int i;
-        struct acpi_video_device *vd =
-                (struct acpi_video_device *)bl_get_data(bd);
+        struct acpi_video_device *vd = bl_get_data(bd);
 
         if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
                 return -EINVAL;
         for (i = 2; i < vd->brightness->count; i++) {
                 if (vd->brightness->levels[i] == cur_level)
-                        /* The first two entries are special - see page 575
-                           of the ACPI spec 3.0 */
-                        return i-2;
+                        /*
+                         * The first two entries are special - see page 575
+                         * of the ACPI spec 3.0
+                         */
+                        return i - 2;
         }
         return 0;
 }
@@ -253,8 +252,7 @@ static int acpi_video_get_brightness(struct backlight_device *bd)
 static int acpi_video_set_brightness(struct backlight_device *bd)
 {
         int request_level = bd->props.brightness + 2;
-        struct acpi_video_device *vd =
-                (struct acpi_video_device *)bl_get_data(bd);
+        struct acpi_video_device *vd = bl_get_data(bd);
 
         return acpi_video_device_lcd_set_level(vd,
                                 vd->brightness->levels[request_level]);
@@ -302,11 +300,11 @@ video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long st
         struct acpi_video_device *video = acpi_driver_data(device);
         int level;
 
-        if ( state >= video->brightness->count - 2)
+        if (state >= video->brightness->count - 2)
                 return -EINVAL;
 
         state = video->brightness->count - state;
-        level = video->brightness->levels[state -1];
+        level = video->brightness->levels[state - 1];
         return acpi_video_device_lcd_set_level(video, level);
 }
 
@@ -316,9 +314,11 @@ static const struct thermal_cooling_device_ops video_cooling_ops = {
         .set_cur_state = video_set_cur_state,
 };
 
-/* --------------------------------------------------------------------------
-                               Video Management
-   -------------------------------------------------------------------------- */
+/*
+ * --------------------------------------------------------------------------
+ *                             Video Management
+ * --------------------------------------------------------------------------
+ */
 
 static int
 acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
@@ -345,7 +345,7 @@ acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
 
         return 0;
 
-      err:
+err:
         kfree(buffer.pointer);
 
         return status;
@@ -355,14 +355,10 @@ static int
 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
 {
         int status;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list args = { 1, &arg0 };
         int state;
 
-        arg0.integer.value = level;
-
-        status = acpi_evaluate_object(device->dev->handle, "_BCM",
-                                      &args, NULL);
+        status = acpi_execute_simple_method(device->dev->handle,
+                                            "_BCM", level);
         if (ACPI_FAILURE(status)) {
                 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
                 return -EIO;
@@ -546,7 +542,7 @@ acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
                                 if (device->brightness->levels[i] == *level) {
                                         device->brightness->curr = *level;
                                         return 0;
-                        }
+                                }
                         /*
                          * BQC returned an invalid level.
                          * Stop using it.
@@ -556,7 +552,8 @@ acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
                                       buf));
                         device->cap._BQC = device->cap._BCQ = 0;
                 } else {
-                        /* Fixme:
+                        /*
+                         * Fixme:
                          * should we return an error or ignore this failure?
                          * dev->brightness->curr is a cached value which stores
                          * the correct current backlight level in most cases.
@@ -615,8 +612,8 @@ acpi_video_device_EDID(struct acpi_video_device *device,
 
 /*
  *  Arg:
- *      video           : video bus device pointer
- *      bios_flag       : 
+ *      video           : video bus device pointer
+ *      bios_flag       :
  *              0.      The system BIOS should NOT automatically switch(toggle)
  *                      the active display output.
  *              1.      The system BIOS should automatically switch (toggle) the
@@ -628,9 +625,9 @@ acpi_video_device_EDID(struct acpi_video_device *device,
  *      lcd_flag        :
  *              0.      The system BIOS should automatically control the brightness level
  *                      of the LCD when the power changes from AC to DC
- *              1.      The system BIOS should NOT automatically control the brightness 
+ *              1.      The system BIOS should NOT automatically control the brightness
  *                      level of the LCD when the power changes from AC to DC.
- * Return Value:
+ *  Return Value:
  *              -EINVAL wrong arg.
  */
 
@@ -638,18 +635,15 @@ static int
 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
 {
         acpi_status status;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list args = { 1, &arg0 };
 
         if (!video->cap._DOS)
                 return 0;
 
         if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
                 return -EINVAL;
-        arg0.integer.value = (lcd_flag << 2) | bios_flag;
-        video->dos_setting = arg0.integer.value;
-        status = acpi_evaluate_object(video->device->handle, "_DOS",
-                &args, NULL);
+        video->dos_setting = (lcd_flag << 2) | bios_flag;
+        status = acpi_execute_simple_method(video->device->handle, "_DOS",
+                                            (lcd_flag << 2) | bios_flag);
         if (ACPI_FAILURE(status))
                 return -EIO;
 
@@ -717,8 +711,8 @@ static int acpi_video_bqc_quirk(struct acpi_video_device *device,
 
 
 /*
- *  Arg:        
- *      device  : video output device (LCD, CRT, ..)
+ *  Arg:
+ *      device  : video output device (LCD, CRT, ..)
  *
  *  Return Value:
  *      Maximum brightness level
@@ -806,16 +800,6 @@ acpi_video_init_brightness(struct acpi_video_device *device)
         br->count = count;
         device->brightness = br;
 
-        /* Check the input/output of _BQC/_BCL/_BCM */
-        if ((max_level < 100) && (max_level <= (count - 2)))
-                br->flags._BCL_use_index = 1;
-
-        /*
-         * _BCM is always consistent with _BCL,
-         * at least for all the laptops we have ever seen.
-         */
-        br->flags._BCM_use_index = br->flags._BCL_use_index;
-
         /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
         br->curr = level = max_level;
 
@@ -877,7 +861,7 @@ out:
  *      device  : video output device (LCD, CRT, ..)
  *
  *  Return Value:
- *      None
+ *      None
  *
  *  Find out all required AML methods defined under the output
  *  device.
@@ -885,28 +869,21 @@ out:
 
 static void acpi_video_device_find_cap(struct acpi_video_device *device)
 {
-        acpi_handle h_dummy1;
-
-        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
+        if (acpi_has_method(device->dev->handle, "_ADR"))
                 device->cap._ADR = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
+        if (acpi_has_method(device->dev->handle, "_BCL"))
                 device->cap._BCL = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
+        if (acpi_has_method(device->dev->handle, "_BCM"))
                 device->cap._BCM = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
+        if (acpi_has_method(device->dev->handle, "_BQC")) {
                 device->cap._BQC = 1;
-        else if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCQ",
-                                &h_dummy1))) {
+        } else if (acpi_has_method(device->dev->handle, "_BCQ")) {
                 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
                 device->cap._BCQ = 1;
         }
 
-        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
+        if (acpi_has_method(device->dev->handle, "_DDC"))
                 device->cap._DDC = 1;
-        }
 
         if (acpi_video_backlight_support()) {
                 struct backlight_properties props;
@@ -914,7 +891,7 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 acpi_handle acpi_parent;
                 struct device *parent = NULL;
                 int result;
-                static int count = 0;
+                static int count;
                 char *name;
 
                 result = acpi_video_init_brightness(device);
@@ -983,37 +960,29 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
 }
 
 /*
- *  Arg:        
- *      device  : video output device (VGA)
+ *  Arg:
+ *      device  : video output device (VGA)
  *
  *  Return Value:
- *      None
+ *      None
  *
  *  Find out all required AML methods defined under the video bus device.
  */
 
 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
 {
-        acpi_handle h_dummy1;
-
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_DOS"))
                 video->cap._DOS = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_DOD"))
                 video->cap._DOD = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_ROM"))
                 video->cap._ROM = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_GPD"))
                 video->cap._GPD = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_SPD"))
                 video->cap._SPD = 1;
-        }
-        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
+        if (acpi_has_method(video->device->handle, "_VPO"))
                 video->cap._VPO = 1;
-        }
 }
 
 /*
@@ -1034,7 +1003,8 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
                 return -ENODEV;
         pci_dev_put(dev);
 
-        /* Since there is no HID, CID and so on for VGA driver, we have
+        /*
+         * Since there is no HID, CID and so on for VGA driver, we have
          * to check well known required nodes.
          */
 
@@ -1064,12 +1034,14 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
         return status;
 }
 
-/* --------------------------------------------------------------------------
-                                 Driver Interface
-   -------------------------------------------------------------------------- */
+/*
+ * --------------------------------------------------------------------------
+ *                               Driver Interface
+ * --------------------------------------------------------------------------
+ */
 
 /* device interface */
-static struct acpi_video_device_attrib*
+static struct acpi_video_device_attrib *
 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
 {
         struct acpi_video_enumerated_device *ids;
@@ -1107,7 +1079,7 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
         unsigned long long device_id;
         int status, device_type;
         struct acpi_video_device *data;
-        struct acpi_video_device_attrib* attribute;
+        struct acpi_video_device_attrib *attribute;
 
         status =
             acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
@@ -1129,7 +1101,7 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
 
         attribute = acpi_video_get_device_attr(video, device_id);
 
-        if((attribute != NULL) && attribute->device_id_scheme) {
+        if (attribute && attribute->device_id_scheme) {
                 switch (attribute->display_type) {
                 case ACPI_VIDEO_DISPLAY_CRT:
                         data->flags.crt = 1;
@@ -1147,24 +1119,24 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
                         data->flags.unknown = 1;
                         break;
                 }
-                if(attribute->bios_can_detect)
+                if (attribute->bios_can_detect)
                         data->flags.bios = 1;
         } else {
                 /* Check for legacy IDs */
                 device_type = acpi_video_get_device_type(video, device_id);
                 /* Ignore bits 16 and 18-20 */
                 switch (device_type & 0xffe2ffff) {
-                        case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
-                                data->flags.crt = 1;
-                                break;
-                        case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
-                                data->flags.lcd = 1;
-                                break;
-                        case ACPI_VIDEO_DISPLAY_LEGACY_TV:
-                                data->flags.tvout = 1;
-                                break;
-                        default:
-                                data->flags.unknown = 1;
+                case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
+                        data->flags.crt = 1;
+                        break;
+                case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
+                        data->flags.lcd = 1;
+                        break;
+                case ACPI_VIDEO_DISPLAY_LEGACY_TV:
+                        data->flags.tvout = 1;
+                        break;
+                default:
+                        data->flags.unknown = 1;
                 }
         }
 
@@ -1187,12 +1159,12 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
 
 /*
  *  Arg:
- *      video   : video bus device 
+ *      video   : video bus device
  *
  *  Return:
- *      none
- *  
- *  Enumerate the video device list of the video bus, 
+ *      none
+ *
+ *  Enumerate the video device list of the video bus,
  *  bind the ids with the corresponding video devices
  *  under the video bus.
  */
@@ -1211,13 +1183,13 @@ static void acpi_video_device_rebind(struct acpi_video_bus *video)
 
 /*
  *  Arg:
- *      video   : video bus device 
- *      device  : video output device under the video 
- *              bus
+ *      video   : video bus device
+ *      device  : video output device under the video
+ *              bus
  *
  *  Return:
- *      none
- *  
+ *      none
+ *
  *  Bind the ids with the corresponding video devices
  *  under the video bus.
  */
@@ -1240,11 +1212,11 @@ acpi_video_device_bind(struct acpi_video_bus *video,
 
 /*
  *  Arg:
- *      video   : video bus device 
+ *      video   : video bus device
  *
  *  Return:
- *      < 0     : error
- *  
+ *      < 0     : error
+ *
  *  Call _DOD to enumerate all devices attached to display adapter
  *
  */
@@ -1305,7 +1277,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
         video->attached_array = active_list;
         video->attached_count = count;
 
- out:
+out:
         kfree(buffer.pointer);
         return status;
 }
@@ -1572,7 +1544,6 @@ static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
         switch (event) {
         case ACPI_VIDEO_NOTIFY_SWITCH:  /* User requested a switch,
                                          * most likely via hotkey. */
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_SWITCHVIDEOMODE;
                 break;
 
@@ -1580,20 +1551,16 @@ static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
                                          * connector. */
                 acpi_video_device_enumerate(video);
                 acpi_video_device_rebind(video);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_SWITCHVIDEOMODE;
                 break;
 
         case ACPI_VIDEO_NOTIFY_CYCLE:   /* Cycle Display output hotkey pressed. */
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_SWITCHVIDEOMODE;
                 break;
         case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:     /* Next Display output hotkey pressed. */
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_VIDEO_NEXT;
                 break;
         case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:     /* previous Display output hotkey pressed. */
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_VIDEO_PREV;
                 break;
 
@@ -1636,31 +1603,26 @@ static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
         case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:        /* Cycle brightness */
                 if (brightness_switch_enabled)
                         acpi_video_switch_brightness(video_device, event);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_BRIGHTNESS_CYCLE;
                 break;
         case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:  /* Increase brightness */
                 if (brightness_switch_enabled)
                         acpi_video_switch_brightness(video_device, event);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_BRIGHTNESSUP;
                 break;
         case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:  /* Decrease brightness */
                 if (brightness_switch_enabled)
                         acpi_video_switch_brightness(video_device, event);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_BRIGHTNESSDOWN;
                 break;
         case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
                 if (brightness_switch_enabled)
                         acpi_video_switch_brightness(video_device, event);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_BRIGHTNESS_ZERO;
                 break;
         case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:     /* display device off */
                 if (brightness_switch_enabled)
                         acpi_video_switch_brightness(video_device, event);
-                acpi_bus_generate_proc_event(device, event, 0);
                 keycode = KEY_DISPLAY_OFF;
                 break;
         default:
@@ -1760,7 +1722,7 @@ static int acpi_video_bus_add(struct acpi_device *device)
         if (!strcmp(device->pnp.bus_id, "VID")) {
                 if (instance)
                         device->pnp.bus_id[3] = '0' + instance;
-                instance ++;
+                instance++;
         }
         /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
         if (!strcmp(device->pnp.bus_id, "VGA")) {
diff --git a/drivers/acpi/video_detect.c b/drivers/acpi/video_detect.c
index c3397748ba46..940edbf2fe8f 100644
--- a/drivers/acpi/video_detect.c
+++ b/drivers/acpi/video_detect.c
@@ -53,14 +53,13 @@ acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
                           void **retyurn_value)
 {
         long *cap = context;
-        acpi_handle h_dummy;
 
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_BCM", &h_dummy)) &&
-            ACPI_SUCCESS(acpi_get_handle(handle, "_BCL", &h_dummy))) {
+        if (acpi_has_method(handle, "_BCM") &&
+            acpi_has_method(handle, "_BCL")) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight "
                                   "support\n"));
                 *cap |= ACPI_VIDEO_BACKLIGHT;
-                if (ACPI_FAILURE(acpi_get_handle(handle, "_BQC", &h_dummy)))
+                if (!acpi_has_method(handle, "_BQC"))
                         printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, "
                                 "cannot determine initial brightness\n");
                 /* We have backlight support, no need to scan further */
@@ -79,22 +78,20 @@ acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
  */
 long acpi_is_video_device(acpi_handle handle)
 {
-        acpi_handle h_dummy;
         long video_caps = 0;
 
         /* Is this device able to support video switching ? */
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_DOD", &h_dummy)) ||
-            ACPI_SUCCESS(acpi_get_handle(handle, "_DOS", &h_dummy)))
+        if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS"))
                 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
 
         /* Is this device able to retrieve a video ROM ? */
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_ROM", &h_dummy)))
+        if (acpi_has_method(handle, "_ROM"))
                 video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
 
         /* Is this device able to configure which video head to be POSTed ? */
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_VPO", &h_dummy)) &&
-            ACPI_SUCCESS(acpi_get_handle(handle, "_GPD", &h_dummy)) &&
-            ACPI_SUCCESS(acpi_get_handle(handle, "_SPD", &h_dummy)))
+        if (acpi_has_method(handle, "_VPO") &&
+            acpi_has_method(handle, "_GPD") &&
+            acpi_has_method(handle, "_SPD"))
                 video_caps |= ACPI_VIDEO_DEVICE_POSTING;
 
         /* Only check for backlight functionality if one of the above hit. */
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index cf4e7020adac..da8170dfc90f 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -947,11 +947,11 @@ static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state)
                         continue;
 
                 acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ?
-                                                ACPI_STATE_D0 : ACPI_STATE_D3);
+                                        ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
         }
 
         if (!(state.event & PM_EVENT_RESUME))
-                acpi_bus_set_power(port_handle, ACPI_STATE_D3);
+                acpi_bus_set_power(port_handle, ACPI_STATE_D3_COLD);
 }
 
 /**
diff --git a/drivers/base/core.c b/drivers/base/core.c
index c7b0925f627a..c7cfadcf6752 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -50,6 +50,28 @@ static struct kobject *dev_kobj;
 struct kobject *sysfs_dev_char_kobj;
 struct kobject *sysfs_dev_block_kobj;
 
+static DEFINE_MUTEX(device_hotplug_lock);
+
+void lock_device_hotplug(void)
+{
+        mutex_lock(&device_hotplug_lock);
+}
+
+void unlock_device_hotplug(void)
+{
+        mutex_unlock(&device_hotplug_lock);
+}
+
+int lock_device_hotplug_sysfs(void)
+{
+        if (mutex_trylock(&device_hotplug_lock))
+                return 0;
+
+        /* Avoid busy looping (5 ms of sleep should do). */
+        msleep(5);
+        return restart_syscall();
+}
+
 #ifdef CONFIG_BLOCK
 static inline int device_is_not_partition(struct device *dev)
 {
@@ -407,9 +429,9 @@ static ssize_t online_show(struct device *dev, struct device_attribute *attr,
 {
         bool val;
 
-        lock_device_hotplug();
+        device_lock(dev);
         val = !dev->offline;
-        unlock_device_hotplug();
+        device_unlock(dev);
         return sprintf(buf, "%u\n", val);
 }
 
@@ -423,7 +445,10 @@ static ssize_t online_store(struct device *dev, struct device_attribute *attr,
         if (ret < 0)
                 return ret;
 
-        lock_device_hotplug();
+        ret = lock_device_hotplug_sysfs();
+        if (ret)
+                return ret;
+
         ret = val ? device_online(dev) : device_offline(dev);
         unlock_device_hotplug();
         return ret < 0 ? ret : count;
@@ -1450,18 +1475,6 @@ int __init devices_init(void)
         return -ENOMEM;
 }
 
-static DEFINE_MUTEX(device_hotplug_lock);
-
-void lock_device_hotplug(void)
-{
-        mutex_lock(&device_hotplug_lock);
-}
-
-void unlock_device_hotplug(void)
-{
-        mutex_unlock(&device_hotplug_lock);
-}
-
 static int device_check_offline(struct device *dev, void *not_used)
 {
         int ret;
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 6bfaaca6955e..848ebbd25717 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/percpu.h>
 #include <linux/acpi.h>
+#include <linux/of.h>
 
 #include "base.h"
 
@@ -293,6 +294,7 @@ int register_cpu(struct cpu *cpu, int num)
         cpu->dev.release = cpu_device_release;
         cpu->dev.offline_disabled = !cpu->hotpluggable;
         cpu->dev.offline = !cpu_online(num);
+        cpu->dev.of_node = of_get_cpu_node(num, NULL);
 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
         cpu->dev.bus->uevent = arch_cpu_uevent;
 #endif
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 1c617623c8ae..9e59f6535c44 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -321,7 +321,9 @@ store_mem_state(struct device *dev,
         struct memory_block *mem = to_memory_block(dev);
         int ret, online_type;
 
-        lock_device_hotplug();
+        ret = lock_device_hotplug_sysfs();
+        if (ret)
+                return ret;
 
         if (!strncmp(buf, "online_kernel", min_t(int, count, 13)))
                 online_type = ONLINE_KERNEL;
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 5a9b6569dd74..9f098a82cf04 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -28,6 +28,7 @@
 #include <linux/sched.h>
 #include <linux/async.h>
 #include <linux/suspend.h>
+#include <trace/events/power.h>
 #include <linux/cpuidle.h>
 #include "../base.h"
 #include "power.h"
@@ -56,6 +57,30 @@ static pm_message_t pm_transition;
 
 static int async_error;
 
+static char *pm_verb(int event)
+{
+        switch (event) {
+        case PM_EVENT_SUSPEND:
+                return "suspend";
+        case PM_EVENT_RESUME:
+                return "resume";
+        case PM_EVENT_FREEZE:
+                return "freeze";
+        case PM_EVENT_QUIESCE:
+                return "quiesce";
+        case PM_EVENT_HIBERNATE:
+                return "hibernate";
+        case PM_EVENT_THAW:
+                return "thaw";
+        case PM_EVENT_RESTORE:
+                return "restore";
+        case PM_EVENT_RECOVER:
+                return "recover";
+        default:
+                return "(unknown PM event)";
+        }
+}
+
 /**
  * device_pm_sleep_init - Initialize system suspend-related device fields.
  * @dev: Device object being initialized.
@@ -172,16 +197,21 @@ static ktime_t initcall_debug_start(struct device *dev)
 }
 
 static void initcall_debug_report(struct device *dev, ktime_t calltime,
-                                  int error)
+                                  int error, pm_message_t state, char *info)
 {
-        ktime_t delta, rettime;
+        ktime_t rettime;
+        s64 nsecs;
+
+        rettime = ktime_get();
+        nsecs = (s64) ktime_to_ns(ktime_sub(rettime, calltime));
 
         if (pm_print_times_enabled) {
-                rettime = ktime_get();
-                delta = ktime_sub(rettime, calltime);
                 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
-                        error, (unsigned long long)ktime_to_ns(delta) >> 10);
+                        error, (unsigned long long)nsecs >> 10);
         }
+
+        trace_device_pm_report_time(dev, info, nsecs, pm_verb(state.event),
+                                    error);
 }
 
 /**
@@ -309,30 +339,6 @@ static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t stat
         return NULL;
 }
 
-static char *pm_verb(int event)
-{
-        switch (event) {
-        case PM_EVENT_SUSPEND:
-                return "suspend";
-        case PM_EVENT_RESUME:
-                return "resume";
-        case PM_EVENT_FREEZE:
-                return "freeze";
-        case PM_EVENT_QUIESCE:
-                return "quiesce";
-        case PM_EVENT_HIBERNATE:
-                return "hibernate";
-        case PM_EVENT_THAW:
-                return "thaw";
-        case PM_EVENT_RESTORE:
-                return "restore";
-        case PM_EVENT_RECOVER:
-                return "recover";
-        default:
-                return "(unknown PM event)";
-        }
-}
-
 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
 {
         dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
@@ -379,7 +385,7 @@ static int dpm_run_callback(pm_callback_t cb, struct device *dev,
         error = cb(dev);
         suspend_report_result(cb, error);
 
-        initcall_debug_report(dev, calltime, error);
+        initcall_debug_report(dev, calltime, error, state, info);
 
         return error;
 }
@@ -1027,7 +1033,8 @@ EXPORT_SYMBOL_GPL(dpm_suspend_end);
  * @cb: Suspend callback to execute.
  */
 static int legacy_suspend(struct device *dev, pm_message_t state,
-                          int (*cb)(struct device *dev, pm_message_t state))
+                          int (*cb)(struct device *dev, pm_message_t state),
+                          char *info)
 {
         int error;
         ktime_t calltime;
@@ -1037,7 +1044,7 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
         error = cb(dev, state);
         suspend_report_result(cb, error);
 
-        initcall_debug_report(dev, calltime, error);
+        initcall_debug_report(dev, calltime, error, state, info);
 
         return error;
 }
@@ -1097,7 +1104,8 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                         goto Run;
                 } else if (dev->class->suspend) {
                         pm_dev_dbg(dev, state, "legacy class ");
-                        error = legacy_suspend(dev, state, dev->class->suspend);
+                        error = legacy_suspend(dev, state, dev->class->suspend,
+                                                "legacy class ");
                         goto End;
                 }
         }
@@ -1108,7 +1116,8 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                         callback = pm_op(dev->bus->pm, state);
                 } else if (dev->bus->suspend) {
                         pm_dev_dbg(dev, state, "legacy bus ");
-                        error = legacy_suspend(dev, state, dev->bus->suspend);
+                        error = legacy_suspend(dev, state, dev->bus->suspend,
+                                                "legacy bus ");
                         goto End;
                 }
         }
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index c8ec186303db..ef89897c6043 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -460,6 +460,7 @@ int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
         srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_ADD, new_opp);
         return 0;
 }
+EXPORT_SYMBOL_GPL(opp_add);
 
 /**
  * opp_set_availability() - helper to set the availability of an opp
diff --git a/drivers/bus/arm-cci.c b/drivers/bus/arm-cci.c
index 733288967d4d..200926699778 100644
--- a/drivers/bus/arm-cci.c
+++ b/drivers/bus/arm-cci.c
@@ -122,17 +122,8 @@ EXPORT_SYMBOL_GPL(cci_ace_get_port);
 
 static void __init cci_ace_init_ports(void)
 {
-        int port, ac, cpu;
-        u64 hwid;
-        const u32 *cell;
-        struct device_node *cpun, *cpus;
-
-        cpus = of_find_node_by_path("/cpus");
-        if (WARN(!cpus, "Missing cpus node, bailing out\n"))
-                return;
-
-        if (WARN_ON(of_property_read_u32(cpus, "#address-cells", &ac)))
-                ac = of_n_addr_cells(cpus);
+        int port, cpu;
+        struct device_node *cpun;
 
         /*
          * Port index look-up speeds up the function disabling ports by CPU,
@@ -141,18 +132,13 @@ static void __init cci_ace_init_ports(void)
          * The stashed index array is initialized for all possible CPUs
          * at probe time.
          */
-        for_each_child_of_node(cpus, cpun) {
-                if (of_node_cmp(cpun->type, "cpu"))
-                        continue;
-                cell = of_get_property(cpun, "reg", NULL);
-                if (WARN(!cell, "%s: missing reg property\n", cpun->full_name))
-                        continue;
-
-                hwid = of_read_number(cell, ac);
-                cpu = get_logical_index(hwid & MPIDR_HWID_BITMASK);
+        for_each_possible_cpu(cpu) {
+                /* too early to use cpu->of_node */
+                cpun = of_get_cpu_node(cpu, NULL);
 
-                if (cpu < 0 || !cpu_possible(cpu))
+                if (WARN(!cpun, "Missing cpu device node\n"))
                         continue;
+
                 port = __cci_ace_get_port(cpun, ACE_PORT);
                 if (port < 0)
                         continue;
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index bf2349dbbf7f..7cc1fe2241fd 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -876,11 +876,6 @@ found:
         if (useinput)
                 sonypi_report_input_event(event);
 
-#ifdef CONFIG_ACPI
-        if (sonypi_acpi_device)
-                acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
-#endif
-
         kfifo_in_locked(&sonypi_device.fifo, (unsigned char *)&event,
                         sizeof(event), &sonypi_device.fifo_lock);
         kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index de4d5d93c3fd..0fa204b244bd 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -17,37 +17,47 @@ config ARM_DT_BL_CPUFREQ
           big.LITTLE platform. This gets frequency tables from DT.
 
 config ARM_EXYNOS_CPUFREQ
-        bool "SAMSUNG EXYNOS SoCs"
-        depends on ARCH_EXYNOS
+        bool
         select CPU_FREQ_TABLE
-        default y
-        help
-          This adds the CPUFreq driver common part for Samsung
-          EXYNOS SoCs.
-
-          If in doubt, say N.
 
 config ARM_EXYNOS4210_CPUFREQ
-        def_bool CPU_EXYNOS4210
+        bool "SAMSUNG EXYNOS4210"
+        depends on CPU_EXYNOS4210
+        default y
+        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS4210
           SoC (S5PV310 or S5PC210).
 
+          If in doubt, say N.
+
 config ARM_EXYNOS4X12_CPUFREQ
-        def_bool (SOC_EXYNOS4212 || SOC_EXYNOS4412)
+        bool "SAMSUNG EXYNOS4x12"
+        depends on (SOC_EXYNOS4212 || SOC_EXYNOS4412)
+        default y
+        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS4X12
           SoC (EXYNOS4212 or EXYNOS4412).
 
+          If in doubt, say N.
+
 config ARM_EXYNOS5250_CPUFREQ
-        def_bool SOC_EXYNOS5250
+        bool "SAMSUNG EXYNOS5250"
+        depends on SOC_EXYNOS5250
+        default y
+        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS5250
           SoC.
 
+          If in doubt, say N.
+
 config ARM_EXYNOS5440_CPUFREQ
-        def_bool SOC_EXYNOS5440
+        bool "SAMSUNG EXYNOS5440"
+        depends on SOC_EXYNOS5440
         depends on HAVE_CLK && PM_OPP && OF
+        default y
         select CPU_FREQ_TABLE
         help
           This adds the CPUFreq driver for Samsung EXYNOS5440
@@ -55,6 +65,8 @@ config ARM_EXYNOS5440_CPUFREQ
           different than previous exynos controllers so not using
           the common exynos framework.
 
+          If in doubt, say N.
+
 config ARM_HIGHBANK_CPUFREQ
         tristate "Calxeda Highbank-based"
         depends on ARCH_HIGHBANK
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index d345b5a7aa71..ad5866c2ada0 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -23,7 +23,7 @@ obj-$(CONFIG_GENERIC_CPUFREQ_CPU0)	+= cpufreq-cpu0.o
 # powernow-k8 can load then. ACPI is preferred to all other hardware-specific drivers.
 # speedstep-* is preferred over p4-clockmod.
 
-obj-$(CONFIG_X86_ACPI_CPUFREQ)          += acpi-cpufreq.o mperf.o
+obj-$(CONFIG_X86_ACPI_CPUFREQ)          += acpi-cpufreq.o
 obj-$(CONFIG_X86_POWERNOW_K8)           += powernow-k8.o
 obj-$(CONFIG_X86_PCC_CPUFREQ)           += pcc-cpufreq.o
 obj-$(CONFIG_X86_POWERNOW_K6)           += powernow-k6.o
diff --git a/drivers/cpufreq/acpi-cpufreq.c b/drivers/cpufreq/acpi-cpufreq.c
index 39264020b88a..a1260b4549db 100644
--- a/drivers/cpufreq/acpi-cpufreq.c
+++ b/drivers/cpufreq/acpi-cpufreq.c
@@ -45,7 +45,6 @@
 #include <asm/msr.h>
 #include <asm/processor.h>
 #include <asm/cpufeature.h>
-#include "mperf.h"
 
 MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
@@ -198,7 +197,7 @@ static ssize_t show_cpb(struct cpufreq_policy *policy, char *buf)
         return sprintf(buf, "%u\n", boost_enabled);
 }
 
-static struct freq_attr cpb = __ATTR(cpb, 0644, show_cpb, store_cpb);
+cpufreq_freq_attr_rw(cpb);
 #endif
 
 static int check_est_cpu(unsigned int cpuid)
@@ -710,7 +709,7 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
                 return blacklisted;
 #endif
 
-        data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
@@ -800,7 +799,7 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
                 goto err_unreg;
         }
 
-        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
+        data->freq_table = kmalloc(sizeof(*data->freq_table) *
                     (perf->state_count+1), GFP_KERNEL);
         if (!data->freq_table) {
                 result = -ENOMEM;
@@ -861,10 +860,6 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
         /* notify BIOS that we exist */
         acpi_processor_notify_smm(THIS_MODULE);
 
-        /* Check for APERF/MPERF support in hardware */
-        if (boot_cpu_has(X86_FEATURE_APERFMPERF))
-                acpi_cpufreq_driver.getavg = cpufreq_get_measured_perf;
-
         pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
         for (i = 0; i < perf->state_count; i++)
                 pr_debug("     %cP%d: %d MHz, %d mW, %d uS\n",
@@ -941,7 +936,6 @@ static struct cpufreq_driver acpi_cpufreq_driver = {
         .exit           = acpi_cpufreq_cpu_exit,
         .resume         = acpi_cpufreq_resume,
         .name           = "acpi-cpufreq",
-        .owner          = THIS_MODULE,
         .attr           = acpi_cpufreq_attr,
 };
 
diff --git a/drivers/cpufreq/arm_big_little_dt.c b/drivers/cpufreq/arm_big_little_dt.c
index fd9e3ea6a480..480c0bd0468d 100644
--- a/drivers/cpufreq/arm_big_little_dt.c
+++ b/drivers/cpufreq/arm_big_little_dt.c
@@ -19,12 +19,11 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <linux/cpu.h>
 #include <linux/cpufreq.h>
 #include <linux/device.h>
 #include <linux/export.h>
 #include <linux/module.h>
-#include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/opp.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
@@ -34,27 +33,13 @@
 /* get cpu node with valid operating-points */
 static struct device_node *get_cpu_node_with_valid_op(int cpu)
 {
-        struct device_node *np = NULL, *parent;
-        int count = 0;
+        struct device_node *np = of_cpu_device_node_get(cpu);
 
-        parent = of_find_node_by_path("/cpus");
-        if (!parent) {
-                pr_err("failed to find OF /cpus\n");
-                return NULL;
+        if (!of_get_property(np, "operating-points", NULL)) {
+                of_node_put(np);
+                np = NULL;
         }
 
-        for_each_child_of_node(parent, np) {
-                if (count++ != cpu)
-                        continue;
-                if (!of_get_property(np, "operating-points", NULL)) {
-                        of_node_put(np);
-                        np = NULL;
-                }
-
-                break;
-        }
-
-        of_node_put(parent);
         return np;
 }
 
@@ -63,11 +48,12 @@ static int dt_init_opp_table(struct device *cpu_dev)
         struct device_node *np;
         int ret;
 
-        np = get_cpu_node_with_valid_op(cpu_dev->id);
-        if (!np)
-                return -ENODATA;
+        np = of_node_get(cpu_dev->of_node);
+        if (!np) {
+                pr_err("failed to find cpu%d node\n", cpu_dev->id);
+                return -ENOENT;
+        }
 
-        cpu_dev->of_node = np;
         ret = of_init_opp_table(cpu_dev);
         of_node_put(np);
 
@@ -79,9 +65,11 @@ static int dt_get_transition_latency(struct device *cpu_dev)
         struct device_node *np;
         u32 transition_latency = CPUFREQ_ETERNAL;
 
-        np = get_cpu_node_with_valid_op(cpu_dev->id);
-        if (!np)
+        np = of_node_get(cpu_dev->of_node);
+        if (!np) {
+                pr_info("Failed to find cpu node. Use CPUFREQ_ETERNAL transition latency\n");
                 return CPUFREQ_ETERNAL;
+        }
 
         of_property_read_u32(np, "clock-latency", &transition_latency);
         of_node_put(np);
diff --git a/drivers/cpufreq/at32ap-cpufreq.c b/drivers/cpufreq/at32ap-cpufreq.c
index 654488723cb5..e0c38d938997 100644
--- a/drivers/cpufreq/at32ap-cpufreq.c
+++ b/drivers/cpufreq/at32ap-cpufreq.c
@@ -108,7 +108,6 @@ static int __init at32_cpufreq_driver_init(struct cpufreq_policy *policy)
 
 static struct cpufreq_driver at32_driver = {
         .name           = "at32ap",
-        .owner          = THIS_MODULE,
         .init           = at32_cpufreq_driver_init,
         .verify         = at32_verify_speed,
         .target         = at32_set_target,
diff --git a/drivers/cpufreq/blackfin-cpufreq.c b/drivers/cpufreq/blackfin-cpufreq.c
index 9cdbbd278a80..ef05978a7237 100644
--- a/drivers/cpufreq/blackfin-cpufreq.c
+++ b/drivers/cpufreq/blackfin-cpufreq.c
@@ -225,7 +225,6 @@ static struct cpufreq_driver bfin_driver = {
         .get = bfin_getfreq_khz,
         .init = __bfin_cpu_init,
         .name = "bfin cpufreq",
-        .owner = THIS_MODULE,
         .attr = bfin_freq_attr,
 };
 
diff --git a/drivers/cpufreq/cpufreq-cpu0.c b/drivers/cpufreq/cpufreq-cpu0.c
index e9dedb27deca..cbfffa91ebdd 100644
--- a/drivers/cpufreq/cpufreq-cpu0.c
+++ b/drivers/cpufreq/cpufreq-cpu0.c
@@ -69,7 +69,7 @@ static int cpu0_set_target(struct cpufreq_policy *policy,
 
         cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
-        if (cpu_reg) {
+        if (!IS_ERR(cpu_reg)) {
                 rcu_read_lock();
                 opp = opp_find_freq_ceil(cpu_dev, &freq_Hz);
                 if (IS_ERR(opp)) {
@@ -90,7 +90,7 @@ static int cpu0_set_target(struct cpufreq_policy *policy,
                  freqs.new / 1000, volt ? volt / 1000 : -1);
 
         /* scaling up?  scale voltage before frequency */
-        if (cpu_reg && freqs.new > freqs.old) {
+        if (!IS_ERR(cpu_reg) && freqs.new > freqs.old) {
                 ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
                 if (ret) {
                         pr_err("failed to scale voltage up: %d\n", ret);
@@ -102,14 +102,14 @@ static int cpu0_set_target(struct cpufreq_policy *policy,
         ret = clk_set_rate(cpu_clk, freq_exact);
         if (ret) {
                 pr_err("failed to set clock rate: %d\n", ret);
-                if (cpu_reg)
+                if (!IS_ERR(cpu_reg))
                         regulator_set_voltage_tol(cpu_reg, volt_old, tol);
                 freqs.new = freqs.old;
                 goto post_notify;
         }
 
         /* scaling down?  scale voltage after frequency */
-        if (cpu_reg && freqs.new < freqs.old) {
+        if (!IS_ERR(cpu_reg) && freqs.new < freqs.old) {
                 ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
                 if (ret) {
                         pr_err("failed to scale voltage down: %d\n", ret);
@@ -174,29 +174,17 @@ static struct cpufreq_driver cpu0_cpufreq_driver = {
 
 static int cpu0_cpufreq_probe(struct platform_device *pdev)
 {
-        struct device_node *np, *parent;
+        struct device_node *np;
         int ret;
 
-        parent = of_find_node_by_path("/cpus");
-        if (!parent) {
-                pr_err("failed to find OF /cpus\n");
-                return -ENOENT;
-        }
-
-        for_each_child_of_node(parent, np) {
-                if (of_get_property(np, "operating-points", NULL))
-                        break;
-        }
+        cpu_dev = &pdev->dev;
 
+        np = of_node_get(cpu_dev->of_node);
         if (!np) {
                 pr_err("failed to find cpu0 node\n");
-                ret = -ENOENT;
-                goto out_put_parent;
+                return -ENOENT;
         }
 
-        cpu_dev = &pdev->dev;
-        cpu_dev->of_node = np;
-
         cpu_reg = devm_regulator_get_optional(cpu_dev, "cpu0");
         if (IS_ERR(cpu_reg)) {
                 /*
@@ -210,7 +198,6 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev)
                 }
                 pr_warn("failed to get cpu0 regulator: %ld\n",
                         PTR_ERR(cpu_reg));
-                cpu_reg = NULL;
         }
 
         cpu_clk = devm_clk_get(cpu_dev, NULL);
@@ -269,15 +256,12 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev)
         }
 
         of_node_put(np);
-        of_node_put(parent);
         return 0;
 
 out_free_table:
         opp_free_cpufreq_table(cpu_dev, &freq_table);
 out_put_node:
         of_node_put(np);
-out_put_parent:
-        of_node_put(parent);
         return ret;
 }
 
diff --git a/drivers/cpufreq/cpufreq-nforce2.c b/drivers/cpufreq/cpufreq-nforce2.c
index af1542d41440..b83d45f68574 100644
--- a/drivers/cpufreq/cpufreq-nforce2.c
+++ b/drivers/cpufreq/cpufreq-nforce2.c
@@ -379,7 +379,6 @@ static struct cpufreq_driver nforce2_driver = {
         .get = nforce2_get,
         .init = nforce2_cpu_init,
         .exit = nforce2_cpu_exit,
-        .owner = THIS_MODULE,
 };
 
 #ifdef MODULE
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index f0a5e2b0eb8a..5c75e3147a60 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -17,24 +17,17 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <asm/cputime.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/notifier.h>
+#include <linux/cpu.h>
 #include <linux/cpufreq.h>
 #include <linux/delay.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <linux/tick.h>
 #include <linux/device.h>
-#include <linux/slab.h>
-#include <linux/cpu.h>
-#include <linux/completion.h>
+#include <linux/init.h>
+#include <linux/kernel_stat.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <linux/syscore_ops.h>
-
+#include <linux/tick.h>
 #include <trace/events/power.h>
 
 /**
@@ -44,8 +37,10 @@
  */
 static struct cpufreq_driver *cpufreq_driver;
 static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
+static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data_fallback);
 static DEFINE_RWLOCK(cpufreq_driver_lock);
 static DEFINE_MUTEX(cpufreq_governor_lock);
+static LIST_HEAD(cpufreq_policy_list);
 
 #ifdef CONFIG_HOTPLUG_CPU
 /* This one keeps track of the previously set governor of a removed CPU */
@@ -69,15 +64,14 @@ static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
  * - Lock should not be held across
  *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
  */
-static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
 
 #define lock_policy_rwsem(mode, cpu)                                    \
 static int lock_policy_rwsem_##mode(int cpu)                            \
 {                                                                       \
-        int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);              \
-        BUG_ON(policy_cpu == -1);                                       \
-        down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));            \
+        struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
+        BUG_ON(!policy);                                                \
+        down_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu));           \
                                                                         \
         return 0;                                                       \
 }
@@ -88,14 +82,20 @@ lock_policy_rwsem(write, cpu);
 #define unlock_policy_rwsem(mode, cpu)                                  \
 static void unlock_policy_rwsem_##mode(int cpu)                         \
 {                                                                       \
-        int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);              \
-        BUG_ON(policy_cpu == -1);                                       \
-        up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));              \
+        struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
+        BUG_ON(!policy);                                                \
+        up_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu));             \
 }
 
 unlock_policy_rwsem(read, cpu);
 unlock_policy_rwsem(write, cpu);
 
+/*
+ * rwsem to guarantee that cpufreq driver module doesn't unload during critical
+ * sections
+ */
+static DECLARE_RWSEM(cpufreq_rwsem);
+
 /* internal prototypes */
 static int __cpufreq_governor(struct cpufreq_policy *policy,
                 unsigned int event);
@@ -183,78 +183,46 @@ u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
 }
 EXPORT_SYMBOL_GPL(get_cpu_idle_time);
 
-static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs)
+struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
 {
-        struct cpufreq_policy *data;
+        struct cpufreq_policy *policy = NULL;
         unsigned long flags;
 
-        if (cpu >= nr_cpu_ids)
-                goto err_out;
+        if (cpufreq_disabled() || (cpu >= nr_cpu_ids))
+                return NULL;
+
+        if (!down_read_trylock(&cpufreq_rwsem))
+                return NULL;
 
         /* get the cpufreq driver */
         read_lock_irqsave(&cpufreq_driver_lock, flags);
 
-        if (!cpufreq_driver)
-                goto err_out_unlock;
-
-        if (!try_module_get(cpufreq_driver->owner))
-                goto err_out_unlock;
-
-        /* get the CPU */
-        data = per_cpu(cpufreq_cpu_data, cpu);
-
-        if (!data)
-                goto err_out_put_module;
-
-        if (!sysfs && !kobject_get(&data->kobj))
-                goto err_out_put_module;
+        if (cpufreq_driver) {
+                /* get the CPU */
+                policy = per_cpu(cpufreq_cpu_data, cpu);
+                if (policy)
+                        kobject_get(&policy->kobj);
+        }
 
         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
-        return data;
 
-err_out_put_module:
-        module_put(cpufreq_driver->owner);
-err_out_unlock:
-        read_unlock_irqrestore(&cpufreq_driver_lock, flags);
-err_out:
-        return NULL;
-}
-
-struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
-{
-        if (cpufreq_disabled())
-                return NULL;
+        if (!policy)
+                up_read(&cpufreq_rwsem);
 
-        return __cpufreq_cpu_get(cpu, false);
+        return policy;
 }
 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
 
-static struct cpufreq_policy *cpufreq_cpu_get_sysfs(unsigned int cpu)
-{
-        return __cpufreq_cpu_get(cpu, true);
-}
-
-static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs)
-{
-        if (!sysfs)
-                kobject_put(&data->kobj);
-        module_put(cpufreq_driver->owner);
-}
-
-void cpufreq_cpu_put(struct cpufreq_policy *data)
+void cpufreq_cpu_put(struct cpufreq_policy *policy)
 {
         if (cpufreq_disabled())
                 return;
 
-        __cpufreq_cpu_put(data, false);
+        kobject_put(&policy->kobj);
+        up_read(&cpufreq_rwsem);
 }
 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 
-static void cpufreq_cpu_put_sysfs(struct cpufreq_policy *data)
-{
-        __cpufreq_cpu_put(data, true);
-}
-
 /*********************************************************************
  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
  *********************************************************************/
@@ -459,8 +427,8 @@ show_one(scaling_min_freq, min);
 show_one(scaling_max_freq, max);
 show_one(scaling_cur_freq, cur);
 
-static int __cpufreq_set_policy(struct cpufreq_policy *data,
-                                struct cpufreq_policy *policy);
+static int __cpufreq_set_policy(struct cpufreq_policy *policy,
+                                struct cpufreq_policy *new_policy);
 
 /**
  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
@@ -699,12 +667,12 @@ static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
         struct cpufreq_policy *policy = to_policy(kobj);
         struct freq_attr *fattr = to_attr(attr);
         ssize_t ret = -EINVAL;
-        policy = cpufreq_cpu_get_sysfs(policy->cpu);
-        if (!policy)
-                goto no_policy;
+
+        if (!down_read_trylock(&cpufreq_rwsem))
+                goto exit;
 
         if (lock_policy_rwsem_read(policy->cpu) < 0)
-                goto fail;
+                goto up_read;
 
         if (fattr->show)
                 ret = fattr->show(policy, buf);
@@ -712,9 +680,10 @@ static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
                 ret = -EIO;
 
         unlock_policy_rwsem_read(policy->cpu);
-fail:
-        cpufreq_cpu_put_sysfs(policy);
-no_policy:
+
+up_read:
+        up_read(&cpufreq_rwsem);
+exit:
         return ret;
 }
 
@@ -724,12 +693,12 @@ static ssize_t store(struct kobject *kobj, struct attribute *attr,
         struct cpufreq_policy *policy = to_policy(kobj);
         struct freq_attr *fattr = to_attr(attr);
         ssize_t ret = -EINVAL;
-        policy = cpufreq_cpu_get_sysfs(policy->cpu);
-        if (!policy)
-                goto no_policy;
+
+        if (!down_read_trylock(&cpufreq_rwsem))
+                goto exit;
 
         if (lock_policy_rwsem_write(policy->cpu) < 0)
-                goto fail;
+                goto up_read;
 
         if (fattr->store)
                 ret = fattr->store(policy, buf, count);
@@ -737,9 +706,10 @@ static ssize_t store(struct kobject *kobj, struct attribute *attr,
                 ret = -EIO;
 
         unlock_policy_rwsem_write(policy->cpu);
-fail:
-        cpufreq_cpu_put_sysfs(policy);
-no_policy:
+
+up_read:
+        up_read(&cpufreq_rwsem);
+exit:
         return ret;
 }
 
@@ -805,41 +775,32 @@ void cpufreq_sysfs_remove_file(const struct attribute *attr)
 EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
 
 /* symlink affected CPUs */
-static int cpufreq_add_dev_symlink(unsigned int cpu,
-                                   struct cpufreq_policy *policy)
+static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
 {
         unsigned int j;
         int ret = 0;
 
         for_each_cpu(j, policy->cpus) {
-                struct cpufreq_policy *managed_policy;
                 struct device *cpu_dev;
 
-                if (j == cpu)
+                if (j == policy->cpu)
                         continue;
 
-                pr_debug("CPU %u already managed, adding link\n", j);
-                managed_policy = cpufreq_cpu_get(cpu);
+                pr_debug("Adding link for CPU: %u\n", j);
                 cpu_dev = get_cpu_device(j);
                 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
                                         "cpufreq");
-                if (ret) {
-                        cpufreq_cpu_put(managed_policy);
-                        return ret;
-                }
+                if (ret)
+                        break;
         }
         return ret;
 }
 
-static int cpufreq_add_dev_interface(unsigned int cpu,
-                                     struct cpufreq_policy *policy,
+static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
                                      struct device *dev)
 {
-        struct cpufreq_policy new_policy;
         struct freq_attr **drv_attr;
-        unsigned long flags;
         int ret = 0;
-        unsigned int j;
 
         /* prepare interface data */
         ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
@@ -871,18 +832,24 @@ static int cpufreq_add_dev_interface(unsigned int cpu,
                         goto err_out_kobj_put;
         }
 
-        write_lock_irqsave(&cpufreq_driver_lock, flags);
-        for_each_cpu(j, policy->cpus) {
-                per_cpu(cpufreq_cpu_data, j) = policy;
-                per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
-        }
-        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
-
-        ret = cpufreq_add_dev_symlink(cpu, policy);
+        ret = cpufreq_add_dev_symlink(policy);
         if (ret)
                 goto err_out_kobj_put;
 
-        memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
+        return ret;
+
+err_out_kobj_put:
+        kobject_put(&policy->kobj);
+        wait_for_completion(&policy->kobj_unregister);
+        return ret;
+}
+
+static void cpufreq_init_policy(struct cpufreq_policy *policy)
+{
+        struct cpufreq_policy new_policy;
+        int ret = 0;
+
+        memcpy(&new_policy, policy, sizeof(*policy));
         /* assure that the starting sequence is run in __cpufreq_set_policy */
         policy->governor = NULL;
 
@@ -896,72 +863,106 @@ static int cpufreq_add_dev_interface(unsigned int cpu,
                 if (cpufreq_driver->exit)
                         cpufreq_driver->exit(policy);
         }
-        return ret;
-
-err_out_kobj_put:
-        kobject_put(&policy->kobj);
-        wait_for_completion(&policy->kobj_unregister);
-        return ret;
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
-static int cpufreq_add_policy_cpu(unsigned int cpu, unsigned int sibling,
-                                  struct device *dev)
+static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
+                                  unsigned int cpu, struct device *dev,
+                                  bool frozen)
 {
-        struct cpufreq_policy *policy;
         int ret = 0, has_target = !!cpufreq_driver->target;
         unsigned long flags;
 
-        policy = cpufreq_cpu_get(sibling);
-        WARN_ON(!policy);
-
-        if (has_target)
-                __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+        if (has_target) {
+                ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+                if (ret) {
+                        pr_err("%s: Failed to stop governor\n", __func__);
+                        return ret;
+                }
+        }
 
-        lock_policy_rwsem_write(sibling);
+        lock_policy_rwsem_write(policy->cpu);
 
         write_lock_irqsave(&cpufreq_driver_lock, flags);
 
         cpumask_set_cpu(cpu, policy->cpus);
-        per_cpu(cpufreq_policy_cpu, cpu) = policy->cpu;
         per_cpu(cpufreq_cpu_data, cpu) = policy;
         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        unlock_policy_rwsem_write(sibling);
+        unlock_policy_rwsem_write(policy->cpu);
 
         if (has_target) {
-                __cpufreq_governor(policy, CPUFREQ_GOV_START);
-                __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
+                if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
+                        (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
+                        pr_err("%s: Failed to start governor\n", __func__);
+                        return ret;
+                }
         }
 
-        ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
-        if (ret) {
-                cpufreq_cpu_put(policy);
-                return ret;
-        }
+        /* Don't touch sysfs links during light-weight init */
+        if (!frozen)
+                ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
 
-        return 0;
+        return ret;
 }
 #endif
 
-/**
- * cpufreq_add_dev - add a CPU device
- *
- * Adds the cpufreq interface for a CPU device.
- *
- * The Oracle says: try running cpufreq registration/unregistration concurrently
- * with with cpu hotplugging and all hell will break loose. Tried to clean this
- * mess up, but more thorough testing is needed. - Mathieu
- */
-static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
+static struct cpufreq_policy *cpufreq_policy_restore(unsigned int cpu)
+{
+        struct cpufreq_policy *policy;
+        unsigned long flags;
+
+        write_lock_irqsave(&cpufreq_driver_lock, flags);
+
+        policy = per_cpu(cpufreq_cpu_data_fallback, cpu);
+
+        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+        return policy;
+}
+
+static struct cpufreq_policy *cpufreq_policy_alloc(void)
+{
+        struct cpufreq_policy *policy;
+
+        policy = kzalloc(sizeof(*policy), GFP_KERNEL);
+        if (!policy)
+                return NULL;
+
+        if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
+                goto err_free_policy;
+
+        if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
+                goto err_free_cpumask;
+
+        INIT_LIST_HEAD(&policy->policy_list);
+        return policy;
+
+err_free_cpumask:
+        free_cpumask_var(policy->cpus);
+err_free_policy:
+        kfree(policy);
+
+        return NULL;
+}
+
+static void cpufreq_policy_free(struct cpufreq_policy *policy)
+{
+        free_cpumask_var(policy->related_cpus);
+        free_cpumask_var(policy->cpus);
+        kfree(policy);
+}
+
+static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
+                             bool frozen)
 {
         unsigned int j, cpu = dev->id;
         int ret = -ENOMEM;
         struct cpufreq_policy *policy;
         unsigned long flags;
 #ifdef CONFIG_HOTPLUG_CPU
+        struct cpufreq_policy *tpolicy;
         struct cpufreq_governor *gov;
-        int sibling;
 #endif
 
         if (cpu_is_offline(cpu))
@@ -977,43 +978,38 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
                 cpufreq_cpu_put(policy);
                 return 0;
         }
+#endif
+
+        if (!down_read_trylock(&cpufreq_rwsem))
+                return 0;
 
 #ifdef CONFIG_HOTPLUG_CPU
         /* Check if this cpu was hot-unplugged earlier and has siblings */
         read_lock_irqsave(&cpufreq_driver_lock, flags);
-        for_each_online_cpu(sibling) {
-                struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
-                if (cp && cpumask_test_cpu(cpu, cp->related_cpus)) {
+        list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
+                if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
                         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                        return cpufreq_add_policy_cpu(cpu, sibling, dev);
+                        ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev, frozen);
+                        up_read(&cpufreq_rwsem);
+                        return ret;
                 }
         }
         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 #endif
-#endif
 
-        if (!try_module_get(cpufreq_driver->owner)) {
-                ret = -EINVAL;
-                goto module_out;
-        }
+        if (frozen)
+                /* Restore the saved policy when doing light-weight init */
+                policy = cpufreq_policy_restore(cpu);
+        else
+                policy = cpufreq_policy_alloc();
 
-        policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
         if (!policy)
                 goto nomem_out;
 
-        if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
-                goto err_free_policy;
-
-        if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
-                goto err_free_cpumask;
-
         policy->cpu = cpu;
         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
         cpumask_copy(policy->cpus, cpumask_of(cpu));
 
-        /* Initially set CPU itself as the policy_cpu */
-        per_cpu(cpufreq_policy_cpu, cpu) = cpu;
-
         init_completion(&policy->kobj_unregister);
         INIT_WORK(&policy->update, handle_update);
 
@@ -1050,12 +1046,26 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
         }
 #endif
 
-        ret = cpufreq_add_dev_interface(cpu, policy, dev);
-        if (ret)
-                goto err_out_unregister;
+        write_lock_irqsave(&cpufreq_driver_lock, flags);
+        for_each_cpu(j, policy->cpus)
+                per_cpu(cpufreq_cpu_data, j) = policy;
+        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+        if (!frozen) {
+                ret = cpufreq_add_dev_interface(policy, dev);
+                if (ret)
+                        goto err_out_unregister;
+        }
+
+        write_lock_irqsave(&cpufreq_driver_lock, flags);
+        list_add(&policy->policy_list, &cpufreq_policy_list);
+        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+        cpufreq_init_policy(policy);
 
         kobject_uevent(&policy->kobj, KOBJ_ADD);
-        module_put(cpufreq_driver->owner);
+        up_read(&cpufreq_rwsem);
+
         pr_debug("initialization complete\n");
 
         return 0;
@@ -1066,32 +1076,33 @@ err_out_unregister:
                 per_cpu(cpufreq_cpu_data, j) = NULL;
         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        kobject_put(&policy->kobj);
-        wait_for_completion(&policy->kobj_unregister);
-
 err_set_policy_cpu:
-        per_cpu(cpufreq_policy_cpu, cpu) = -1;
-        free_cpumask_var(policy->related_cpus);
-err_free_cpumask:
-        free_cpumask_var(policy->cpus);
-err_free_policy:
-        kfree(policy);
+        cpufreq_policy_free(policy);
 nomem_out:
-        module_put(cpufreq_driver->owner);
-module_out:
+        up_read(&cpufreq_rwsem);
+
         return ret;
 }
 
-static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
+/**
+ * cpufreq_add_dev - add a CPU device
+ *
+ * Adds the cpufreq interface for a CPU device.
+ *
+ * The Oracle says: try running cpufreq registration/unregistration concurrently
+ * with with cpu hotplugging and all hell will break loose. Tried to clean this
+ * mess up, but more thorough testing is needed. - Mathieu
+ */
+static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
 {
-        int j;
+        return __cpufreq_add_dev(dev, sif, false);
+}
 
+static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
+{
         policy->last_cpu = policy->cpu;
         policy->cpu = cpu;
 
-        for_each_cpu(j, policy->cpus)
-                per_cpu(cpufreq_policy_cpu, j) = cpu;
-
 #ifdef CONFIG_CPU_FREQ_TABLE
         cpufreq_frequency_table_update_policy_cpu(policy);
 #endif
@@ -1099,6 +1110,37 @@ static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
                         CPUFREQ_UPDATE_POLICY_CPU, policy);
 }
 
+static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
+                                           unsigned int old_cpu, bool frozen)
+{
+        struct device *cpu_dev;
+        int ret;
+
+        /* first sibling now owns the new sysfs dir */
+        cpu_dev = get_cpu_device(cpumask_first(policy->cpus));
+
+        /* Don't touch sysfs files during light-weight tear-down */
+        if (frozen)
+                return cpu_dev->id;
+
+        sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
+        ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
+        if (ret) {
+                pr_err("%s: Failed to move kobj: %d", __func__, ret);
+
+                WARN_ON(lock_policy_rwsem_write(old_cpu));
+                cpumask_set_cpu(old_cpu, policy->cpus);
+                unlock_policy_rwsem_write(old_cpu);
+
+                ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
+                                        "cpufreq");
+
+                return -EINVAL;
+        }
+
+        return cpu_dev->id;
+}
+
 /**
  * __cpufreq_remove_dev - remove a CPU device
  *
@@ -1107,111 +1149,126 @@ static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
  * This routine frees the rwsem before returning.
  */
 static int __cpufreq_remove_dev(struct device *dev,
-                struct subsys_interface *sif)
+                                struct subsys_interface *sif, bool frozen)
 {
-        unsigned int cpu = dev->id, ret, cpus;
+        unsigned int cpu = dev->id, cpus;
+        int new_cpu, ret;
         unsigned long flags;
-        struct cpufreq_policy *data;
+        struct cpufreq_policy *policy;
         struct kobject *kobj;
         struct completion *cmp;
-        struct device *cpu_dev;
 
         pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
 
         write_lock_irqsave(&cpufreq_driver_lock, flags);
 
-        data = per_cpu(cpufreq_cpu_data, cpu);
-        per_cpu(cpufreq_cpu_data, cpu) = NULL;
+        policy = per_cpu(cpufreq_cpu_data, cpu);
+
+        /* Save the policy somewhere when doing a light-weight tear-down */
+        if (frozen)
+                per_cpu(cpufreq_cpu_data_fallback, cpu) = policy;
 
         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        if (!data) {
+        if (!policy) {
                 pr_debug("%s: No cpu_data found\n", __func__);
                 return -EINVAL;
         }
 
-        if (cpufreq_driver->target)
-                __cpufreq_governor(data, CPUFREQ_GOV_STOP);
+        if (cpufreq_driver->target) {
+                ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+                if (ret) {
+                        pr_err("%s: Failed to stop governor\n", __func__);
+                        return ret;
+                }
+        }
 
 #ifdef CONFIG_HOTPLUG_CPU
         if (!cpufreq_driver->setpolicy)
                 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
-                        data->governor->name, CPUFREQ_NAME_LEN);
+                        policy->governor->name, CPUFREQ_NAME_LEN);
 #endif
 
         WARN_ON(lock_policy_rwsem_write(cpu));
-        cpus = cpumask_weight(data->cpus);
+        cpus = cpumask_weight(policy->cpus);
 
         if (cpus > 1)
-                cpumask_clear_cpu(cpu, data->cpus);
+                cpumask_clear_cpu(cpu, policy->cpus);
         unlock_policy_rwsem_write(cpu);
 
-        if (cpu != data->cpu) {
+        if (cpu != policy->cpu && !frozen) {
                 sysfs_remove_link(&dev->kobj, "cpufreq");
         } else if (cpus > 1) {
-                /* first sibling now owns the new sysfs dir */
-                cpu_dev = get_cpu_device(cpumask_first(data->cpus));
-                sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
-                ret = kobject_move(&data->kobj, &cpu_dev->kobj);
-                if (ret) {
-                        pr_err("%s: Failed to move kobj: %d", __func__, ret);
 
+                new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
+                if (new_cpu >= 0) {
                         WARN_ON(lock_policy_rwsem_write(cpu));
-                        cpumask_set_cpu(cpu, data->cpus);
-
-                        write_lock_irqsave(&cpufreq_driver_lock, flags);
-                        per_cpu(cpufreq_cpu_data, cpu) = data;
-                        write_unlock_irqrestore(&cpufreq_driver_lock, flags);
-
+                        update_policy_cpu(policy, new_cpu);
                         unlock_policy_rwsem_write(cpu);
 
-                        ret = sysfs_create_link(&cpu_dev->kobj, &data->kobj,
-                                        "cpufreq");
-                        return -EINVAL;
+                        if (!frozen) {
+                                pr_debug("%s: policy Kobject moved to cpu: %d "
+                                         "from: %d\n",__func__, new_cpu, cpu);
+                        }
                 }
-
-                WARN_ON(lock_policy_rwsem_write(cpu));
-                update_policy_cpu(data, cpu_dev->id);
-                unlock_policy_rwsem_write(cpu);
-                pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
-                                __func__, cpu_dev->id, cpu);
         }
 
         /* If cpu is last user of policy, free policy */
         if (cpus == 1) {
-                if (cpufreq_driver->target)
-                        __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
-
-                lock_policy_rwsem_read(cpu);
-                kobj = &data->kobj;
-                cmp = &data->kobj_unregister;
-                unlock_policy_rwsem_read(cpu);
-                kobject_put(kobj);
-
-                /* we need to make sure that the underlying kobj is actually
-                 * not referenced anymore by anybody before we proceed with
-                 * unloading.
-                 */
-                pr_debug("waiting for dropping of refcount\n");
-                wait_for_completion(cmp);
-                pr_debug("wait complete\n");
+                if (cpufreq_driver->target) {
+                        ret = __cpufreq_governor(policy,
+                                        CPUFREQ_GOV_POLICY_EXIT);
+                        if (ret) {
+                                pr_err("%s: Failed to exit governor\n",
+                                                __func__);
+                                return ret;
+                        }
+                }
+
+                if (!frozen) {
+                        lock_policy_rwsem_read(cpu);
+                        kobj = &policy->kobj;
+                        cmp = &policy->kobj_unregister;
+                        unlock_policy_rwsem_read(cpu);
+                        kobject_put(kobj);
+
+                        /*
+                         * We need to make sure that the underlying kobj is
+                         * actually not referenced anymore by anybody before we
+                         * proceed with unloading.
+                         */
+                        pr_debug("waiting for dropping of refcount\n");
+                        wait_for_completion(cmp);
+                        pr_debug("wait complete\n");
+                }
 
+                /*
+                 * Perform the ->exit() even during light-weight tear-down,
+                 * since this is a core component, and is essential for the
+                 * subsequent light-weight ->init() to succeed.
+                 */
                 if (cpufreq_driver->exit)
-                        cpufreq_driver->exit(data);
+                        cpufreq_driver->exit(policy);
 
-                free_cpumask_var(data->related_cpus);
-                free_cpumask_var(data->cpus);
-                kfree(data);
+                /* Remove policy from list of active policies */
+                write_lock_irqsave(&cpufreq_driver_lock, flags);
+                list_del(&policy->policy_list);
+                write_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+                if (!frozen)
+                        cpufreq_policy_free(policy);
         } else {
-                pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
-                cpufreq_cpu_put(data);
                 if (cpufreq_driver->target) {
-                        __cpufreq_governor(data, CPUFREQ_GOV_START);
-                        __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
+                        if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
+                                        (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
+                                pr_err("%s: Failed to start governor\n",
+                                                __func__);
+                                return ret;
+                        }
                 }
         }
 
-        per_cpu(cpufreq_policy_cpu, cpu) = -1;
+        per_cpu(cpufreq_cpu_data, cpu) = NULL;
         return 0;
 }
 
@@ -1223,7 +1280,7 @@ static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
         if (cpu_is_offline(cpu))
                 return 0;
 
-        retval = __cpufreq_remove_dev(dev, sif);
+        retval = __cpufreq_remove_dev(dev, sif, false);
         return retval;
 }
 
@@ -1344,10 +1401,9 @@ static unsigned int __cpufreq_get(unsigned int cpu)
 unsigned int cpufreq_get(unsigned int cpu)
 {
         unsigned int ret_freq = 0;
-        struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
 
-        if (!policy)
-                goto out;
+        if (!down_read_trylock(&cpufreq_rwsem))
+                return 0;
 
         if (unlikely(lock_policy_rwsem_read(cpu)))
                 goto out_policy;
@@ -1357,8 +1413,8 @@ unsigned int cpufreq_get(unsigned int cpu)
         unlock_policy_rwsem_read(cpu);
 
 out_policy:
-        cpufreq_cpu_put(policy);
-out:
+        up_read(&cpufreq_rwsem);
+
         return ret_freq;
 }
 EXPORT_SYMBOL(cpufreq_get);
@@ -1381,23 +1437,23 @@ static int cpufreq_bp_suspend(void)
         int ret = 0;
 
         int cpu = smp_processor_id();
-        struct cpufreq_policy *cpu_policy;
+        struct cpufreq_policy *policy;
 
         pr_debug("suspending cpu %u\n", cpu);
 
         /* If there's no policy for the boot CPU, we have nothing to do. */
-        cpu_policy = cpufreq_cpu_get(cpu);
-        if (!cpu_policy)
+        policy = cpufreq_cpu_get(cpu);
+        if (!policy)
                 return 0;
 
         if (cpufreq_driver->suspend) {
-                ret = cpufreq_driver->suspend(cpu_policy);
+                ret = cpufreq_driver->suspend(policy);
                 if (ret)
                         printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
-                                        "step on CPU %u\n", cpu_policy->cpu);
+                                        "step on CPU %u\n", policy->cpu);
         }
 
-        cpufreq_cpu_put(cpu_policy);
+        cpufreq_cpu_put(policy);
         return ret;
 }
 
@@ -1419,28 +1475,28 @@ static void cpufreq_bp_resume(void)
         int ret = 0;
 
         int cpu = smp_processor_id();
-        struct cpufreq_policy *cpu_policy;
+        struct cpufreq_policy *policy;
 
         pr_debug("resuming cpu %u\n", cpu);
 
         /* If there's no policy for the boot CPU, we have nothing to do. */
-        cpu_policy = cpufreq_cpu_get(cpu);
-        if (!cpu_policy)
+        policy = cpufreq_cpu_get(cpu);
+        if (!policy)
                 return;
 
         if (cpufreq_driver->resume) {
-                ret = cpufreq_driver->resume(cpu_policy);
+                ret = cpufreq_driver->resume(policy);
                 if (ret) {
                         printk(KERN_ERR "cpufreq: resume failed in ->resume "
-                                        "step on CPU %u\n", cpu_policy->cpu);
+                                        "step on CPU %u\n", policy->cpu);
                         goto fail;
                 }
         }
 
-        schedule_work(&cpu_policy->update);
+        schedule_work(&policy->update);
 
 fail:
-        cpufreq_cpu_put(cpu_policy);
+        cpufreq_cpu_put(policy);
 }
 
 static struct syscore_ops cpufreq_syscore_ops = {
@@ -1594,18 +1650,6 @@ fail:
 }
 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
 
-int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
-{
-        if (cpufreq_disabled())
-                return 0;
-
-        if (!cpufreq_driver->getavg)
-                return 0;
-
-        return cpufreq_driver->getavg(policy, cpu);
-}
-EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
-
 /*
  * when "event" is CPUFREQ_GOV_LIMITS
  */
@@ -1640,8 +1684,9 @@ static int __cpufreq_governor(struct cpufreq_policy *policy,
                 }
         }
 
-        if (!try_module_get(policy->governor->owner))
-                return -EINVAL;
+        if (event == CPUFREQ_GOV_POLICY_INIT)
+                if (!try_module_get(policy->governor->owner))
+                        return -EINVAL;
 
         pr_debug("__cpufreq_governor for CPU %u, event %u\n",
                                                 policy->cpu, event);
@@ -1677,11 +1722,8 @@ static int __cpufreq_governor(struct cpufreq_policy *policy,
                 mutex_unlock(&cpufreq_governor_lock);
         }
 
-        /* we keep one module reference alive for
-                        each CPU governed by this CPU */
-        if ((event != CPUFREQ_GOV_START) || ret)
-                module_put(policy->governor->owner);
-        if ((event == CPUFREQ_GOV_STOP) && !ret)
+        if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
+                        ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
                 module_put(policy->governor->owner);
 
         return ret;
@@ -1761,7 +1803,7 @@ int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
         if (!cpu_policy)
                 return -EINVAL;
 
-        memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
+        memcpy(policy, cpu_policy, sizeof(*policy));
 
         cpufreq_cpu_put(cpu_policy);
         return 0;
@@ -1772,95 +1814,94 @@ EXPORT_SYMBOL(cpufreq_get_policy);
  * data   : current policy.
  * policy : policy to be set.
  */
-static int __cpufreq_set_policy(struct cpufreq_policy *data,
-                                struct cpufreq_policy *policy)
+static int __cpufreq_set_policy(struct cpufreq_policy *policy,
+                                struct cpufreq_policy *new_policy)
 {
         int ret = 0, failed = 1;
 
-        pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
-                policy->min, policy->max);
+        pr_debug("setting new policy for CPU %u: %u - %u kHz\n", new_policy->cpu,
+                new_policy->min, new_policy->max);
 
-        memcpy(&policy->cpuinfo, &data->cpuinfo,
-                                sizeof(struct cpufreq_cpuinfo));
+        memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
 
-        if (policy->min > data->max || policy->max < data->min) {
+        if (new_policy->min > policy->max || new_policy->max < policy->min) {
                 ret = -EINVAL;
                 goto error_out;
         }
 
         /* verify the cpu speed can be set within this limit */
-        ret = cpufreq_driver->verify(policy);
+        ret = cpufreq_driver->verify(new_policy);
         if (ret)
                 goto error_out;
 
         /* adjust if necessary - all reasons */
         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
-                        CPUFREQ_ADJUST, policy);
+                        CPUFREQ_ADJUST, new_policy);
 
         /* adjust if necessary - hardware incompatibility*/
         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
-                        CPUFREQ_INCOMPATIBLE, policy);
+                        CPUFREQ_INCOMPATIBLE, new_policy);
 
         /*
          * verify the cpu speed can be set within this limit, which might be
          * different to the first one
          */
-        ret = cpufreq_driver->verify(policy);
+        ret = cpufreq_driver->verify(new_policy);
         if (ret)
                 goto error_out;
 
         /* notification of the new policy */
         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
-                        CPUFREQ_NOTIFY, policy);
+                        CPUFREQ_NOTIFY, new_policy);
 
-        data->min = policy->min;
-        data->max = policy->max;
+        policy->min = new_policy->min;
+        policy->max = new_policy->max;
 
         pr_debug("new min and max freqs are %u - %u kHz\n",
-                                        data->min, data->max);
+                                        policy->min, policy->max);
 
         if (cpufreq_driver->setpolicy) {
-                data->policy = policy->policy;
+                policy->policy = new_policy->policy;
                 pr_debug("setting range\n");
-                ret = cpufreq_driver->setpolicy(policy);
+                ret = cpufreq_driver->setpolicy(new_policy);
         } else {
-                if (policy->governor != data->governor) {
+                if (new_policy->governor != policy->governor) {
                         /* save old, working values */
-                        struct cpufreq_governor *old_gov = data->governor;
+                        struct cpufreq_governor *old_gov = policy->governor;
 
                         pr_debug("governor switch\n");
 
                         /* end old governor */
-                        if (data->governor) {
-                                __cpufreq_governor(data, CPUFREQ_GOV_STOP);
-                                unlock_policy_rwsem_write(policy->cpu);
-                                __cpufreq_governor(data,
+                        if (policy->governor) {
+                                __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+                                unlock_policy_rwsem_write(new_policy->cpu);
+                                __cpufreq_governor(policy,
                                                 CPUFREQ_GOV_POLICY_EXIT);
-                                lock_policy_rwsem_write(policy->cpu);
+                                lock_policy_rwsem_write(new_policy->cpu);
                         }
 
                         /* start new governor */
-                        data->governor = policy->governor;
-                        if (!__cpufreq_governor(data, CPUFREQ_GOV_POLICY_INIT)) {
-                                if (!__cpufreq_governor(data, CPUFREQ_GOV_START)) {
+                        policy->governor = new_policy->governor;
+                        if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
+                                if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
                                         failed = 0;
                                 } else {
-                                        unlock_policy_rwsem_write(policy->cpu);
-                                        __cpufreq_governor(data,
+                                        unlock_policy_rwsem_write(new_policy->cpu);
+                                        __cpufreq_governor(policy,
                                                         CPUFREQ_GOV_POLICY_EXIT);
-                                        lock_policy_rwsem_write(policy->cpu);
+                                        lock_policy_rwsem_write(new_policy->cpu);
                                 }
                         }
 
                         if (failed) {
                                 /* new governor failed, so re-start old one */
                                 pr_debug("starting governor %s failed\n",
-                                                        data->governor->name);
+                                                        policy->governor->name);
                                 if (old_gov) {
-                                        data->governor = old_gov;
-                                        __cpufreq_governor(data,
+                                        policy->governor = old_gov;
+                                        __cpufreq_governor(policy,
                                                         CPUFREQ_GOV_POLICY_INIT);
-                                        __cpufreq_governor(data,
+                                        __cpufreq_governor(policy,
                                                            CPUFREQ_GOV_START);
                                 }
                                 ret = -EINVAL;
@@ -1869,7 +1910,7 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
                         /* might be a policy change, too, so fall through */
                 }
                 pr_debug("governor: change or update limits\n");
-                __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
+                ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
         }
 
 error_out:
@@ -1885,11 +1926,11 @@ error_out:
  */
 int cpufreq_update_policy(unsigned int cpu)
 {
-        struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
-        struct cpufreq_policy policy;
+        struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+        struct cpufreq_policy new_policy;
         int ret;
 
-        if (!data) {
+        if (!policy) {
                 ret = -ENODEV;
                 goto no_policy;
         }
@@ -1900,34 +1941,34 @@ int cpufreq_update_policy(unsigned int cpu)
         }
 
         pr_debug("updating policy for CPU %u\n", cpu);
-        memcpy(&policy, data, sizeof(struct cpufreq_policy));
-        policy.min = data->user_policy.min;
-        policy.max = data->user_policy.max;
-        policy.policy = data->user_policy.policy;
-        policy.governor = data->user_policy.governor;
+        memcpy(&new_policy, policy, sizeof(*policy));
+        new_policy.min = policy->user_policy.min;
+        new_policy.max = policy->user_policy.max;
+        new_policy.policy = policy->user_policy.policy;
+        new_policy.governor = policy->user_policy.governor;
 
         /*
          * BIOS might change freq behind our back
          * -> ask driver for current freq and notify governors about a change
          */
         if (cpufreq_driver->get) {
-                policy.cur = cpufreq_driver->get(cpu);
-                if (!data->cur) {
+                new_policy.cur = cpufreq_driver->get(cpu);
+                if (!policy->cur) {
                         pr_debug("Driver did not initialize current freq");
-                        data->cur = policy.cur;
+                        policy->cur = new_policy.cur;
                 } else {
-                        if (data->cur != policy.cur && cpufreq_driver->target)
-                                cpufreq_out_of_sync(cpu, data->cur,
-                                                                policy.cur);
+                        if (policy->cur != new_policy.cur && cpufreq_driver->target)
+                                cpufreq_out_of_sync(cpu, policy->cur,
+                                                                new_policy.cur);
                 }
         }
 
-        ret = __cpufreq_set_policy(data, &policy);
+        ret = __cpufreq_set_policy(policy, &new_policy);
 
         unlock_policy_rwsem_write(cpu);
 
 fail:
-        cpufreq_cpu_put(data);
+        cpufreq_cpu_put(policy);
 no_policy:
         return ret;
 }
@@ -1938,21 +1979,26 @@ static int cpufreq_cpu_callback(struct notifier_block *nfb,
 {
         unsigned int cpu = (unsigned long)hcpu;
         struct device *dev;
+        bool frozen = false;
 
         dev = get_cpu_device(cpu);
         if (dev) {
-                switch (action) {
+
+                if (action & CPU_TASKS_FROZEN)
+                        frozen = true;
+
+                switch (action & ~CPU_TASKS_FROZEN) {
                 case CPU_ONLINE:
-                case CPU_ONLINE_FROZEN:
-                        cpufreq_add_dev(dev, NULL);
+                        __cpufreq_add_dev(dev, NULL, frozen);
+                        cpufreq_update_policy(cpu);
                         break;
+
                 case CPU_DOWN_PREPARE:
-                case CPU_DOWN_PREPARE_FROZEN:
-                        __cpufreq_remove_dev(dev, NULL);
+                        __cpufreq_remove_dev(dev, NULL, frozen);
                         break;
+
                 case CPU_DOWN_FAILED:
-                case CPU_DOWN_FAILED_FROZEN:
-                        cpufreq_add_dev(dev, NULL);
+                        __cpufreq_add_dev(dev, NULL, frozen);
                         break;
                 }
         }
@@ -2059,9 +2105,13 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver)
         subsys_interface_unregister(&cpufreq_interface);
         unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
 
+        down_write(&cpufreq_rwsem);
         write_lock_irqsave(&cpufreq_driver_lock, flags);
+
         cpufreq_driver = NULL;
+
         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
+        up_write(&cpufreq_rwsem);
 
         return 0;
 }
@@ -2074,10 +2124,8 @@ static int __init cpufreq_core_init(void)
         if (cpufreq_disabled())
                 return -ENODEV;
 
-        for_each_possible_cpu(cpu) {
-                per_cpu(cpufreq_policy_cpu, cpu) = -1;
+        for_each_possible_cpu(cpu)
                 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
-        }
 
         cpufreq_global_kobject = kobject_create();
         BUG_ON(!cpufreq_global_kobject);
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index f97cb3d8c5a2..f62d822048e6 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -11,19 +11,7 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/cpufreq.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/kobject.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/notifier.h>
-#include <linux/percpu-defs.h>
 #include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/types.h>
-
 #include "cpufreq_governor.h"
 
 /* Conservative governor macros */
@@ -79,8 +67,6 @@ static void cs_check_cpu(int cpu, unsigned int load)
                         return;
 
                 dbs_info->requested_freq += get_freq_target(cs_tuners, policy);
-                if (dbs_info->requested_freq > policy->max)
-                        dbs_info->requested_freq = policy->max;
 
                 __cpufreq_driver_target(policy, dbs_info->requested_freq,
                         CPUFREQ_RELATION_H);
@@ -101,8 +87,6 @@ static void cs_check_cpu(int cpu, unsigned int load)
                         return;
 
                 dbs_info->requested_freq -= get_freq_target(cs_tuners, policy);
-                if (dbs_info->requested_freq < policy->min)
-                        dbs_info->requested_freq = policy->min;
 
                 __cpufreq_driver_target(policy, dbs_info->requested_freq,
                                 CPUFREQ_RELATION_L);
@@ -329,7 +313,7 @@ static int cs_init(struct dbs_data *dbs_data)
 {
         struct cs_dbs_tuners *tuners;
 
-        tuners = kzalloc(sizeof(struct cs_dbs_tuners), GFP_KERNEL);
+        tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
         if (!tuners) {
                 pr_err("%s: kzalloc failed\n", __func__);
                 return -ENOMEM;
diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index e59afaa9da23..0806c31e5764 100644
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -16,15 +16,9 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <asm/cputime.h>
-#include <linux/cpufreq.h>
-#include <linux/cpumask.h>
 #include <linux/export.h>
 #include <linux/kernel_stat.h>
-#include <linux/mutex.h>
 #include <linux/slab.h>
-#include <linux/types.h>
-#include <linux/workqueue.h>
 
 #include "cpufreq_governor.h"
 
@@ -53,7 +47,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
 
         policy = cdbs->cur_policy;
 
-        /* Get Absolute Load (in terms of freq for ondemand gov) */
+        /* Get Absolute Load */
         for_each_cpu(j, policy->cpus) {
                 struct cpu_dbs_common_info *j_cdbs;
                 u64 cur_wall_time, cur_idle_time;
@@ -104,14 +98,6 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
 
                 load = 100 * (wall_time - idle_time) / wall_time;
 
-                if (dbs_data->cdata->governor == GOV_ONDEMAND) {
-                        int freq_avg = __cpufreq_driver_getavg(policy, j);
-                        if (freq_avg <= 0)
-                                freq_avg = policy->cur;
-
-                        load *= freq_avg;
-                }
-
                 if (load > max_load)
                         max_load = load;
         }
@@ -133,8 +119,18 @@ void gov_queue_work(struct dbs_data *dbs_data, struct cpufreq_policy *policy,
 {
         int i;
 
+        if (!policy->governor_enabled)
+                return;
+
         if (!all_cpus) {
-                __gov_queue_work(smp_processor_id(), dbs_data, delay);
+                /*
+                 * Use raw_smp_processor_id() to avoid preemptible warnings.
+                 * We know that this is only called with all_cpus == false from
+                 * works that have been queued with *_work_on() functions and
+                 * those works are canceled during CPU_DOWN_PREPARE so they
+                 * can't possibly run on any other CPU.
+                 */
+                __gov_queue_work(raw_smp_processor_id(), dbs_data, delay);
         } else {
                 for_each_cpu(i, policy->cpus)
                         __gov_queue_work(i, dbs_data, delay);
@@ -244,7 +240,7 @@ int cpufreq_governor_dbs(struct cpufreq_policy *policy,
 
                 policy->governor_data = dbs_data;
 
-                /* policy latency is in nS. Convert it to uS first */
+                /* policy latency is in ns. Convert it to us first */
                 latency = policy->cpuinfo.transition_latency / 1000;
                 if (latency == 0)
                         latency = 1;
diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h
index d5f12b4b11b8..88cd39f7b0e9 100644
--- a/drivers/cpufreq/cpufreq_governor.h
+++ b/drivers/cpufreq/cpufreq_governor.h
@@ -18,19 +18,18 @@
 #define _CPUFREQ_GOVERNOR_H
 
 #include <linux/cpufreq.h>
-#include <linux/kobject.h>
+#include <linux/kernel_stat.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
-#include <linux/workqueue.h>
-#include <linux/sysfs.h>
 
 /*
  * The polling frequency depends on the capability of the processor. Default
  * polling frequency is 1000 times the transition latency of the processor. The
- * governor will work on any processor with transition latency <= 10mS, using
+ * governor will work on any processor with transition latency <= 10ms, using
  * appropriate sampling rate.
  *
- * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
- * this governor will not work. All times here are in uS.
+ * For CPUs with transition latency > 10ms (mostly drivers with CPUFREQ_ETERNAL)
+ * this governor will not work. All times here are in us (micro seconds).
  */
 #define MIN_SAMPLING_RATE_RATIO                 (2)
 #define LATENCY_MULTIPLIER                      (1000)
@@ -163,13 +162,12 @@ struct cs_cpu_dbs_info_s {
         unsigned int enable:1;
 };
 
-/* Per policy Governers sysfs tunables */
+/* Per policy Governors sysfs tunables */
 struct od_dbs_tuners {
         unsigned int ignore_nice_load;
         unsigned int sampling_rate;
         unsigned int sampling_down_factor;
         unsigned int up_threshold;
-        unsigned int adj_up_threshold;
         unsigned int powersave_bias;
         unsigned int io_is_busy;
 };
@@ -183,7 +181,7 @@ struct cs_dbs_tuners {
         unsigned int freq_step;
 };
 
-/* Common Governer data across policies */
+/* Common Governor data across policies */
 struct dbs_data;
 struct common_dbs_data {
         /* Common across governors */
@@ -207,7 +205,7 @@ struct common_dbs_data {
         void *gov_ops;
 };
 
-/* Governer Per policy data */
+/* Governor Per policy data */
 struct dbs_data {
         struct common_dbs_data *cdata;
         unsigned int min_sampling_rate;
@@ -223,7 +221,7 @@ struct od_ops {
         void (*powersave_bias_init_cpu)(int cpu);
         unsigned int (*powersave_bias_target)(struct cpufreq_policy *policy,
                         unsigned int freq_next, unsigned int relation);
-        void (*freq_increase)(struct cpufreq_policy *p, unsigned int freq);
+        void (*freq_increase)(struct cpufreq_policy *policy, unsigned int freq);
 };
 
 struct cs_ops {
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index c087347d6688..32f26f6e17c5 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -12,28 +12,16 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <linux/cpufreq.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/kobject.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
+#include <linux/cpu.h>
 #include <linux/percpu-defs.h>
 #include <linux/slab.h>
-#include <linux/sysfs.h>
 #include <linux/tick.h>
-#include <linux/types.h>
-#include <linux/cpu.h>
-
 #include "cpufreq_governor.h"
 
 /* On-demand governor macros */
-#define DEF_FREQUENCY_DOWN_DIFFERENTIAL         (10)
 #define DEF_FREQUENCY_UP_THRESHOLD              (80)
 #define DEF_SAMPLING_DOWN_FACTOR                (1)
 #define MAX_SAMPLING_DOWN_FACTOR                (100000)
-#define MICRO_FREQUENCY_DOWN_DIFFERENTIAL       (3)
 #define MICRO_FREQUENCY_UP_THRESHOLD            (95)
 #define MICRO_FREQUENCY_MIN_SAMPLE_RATE         (10000)
 #define MIN_FREQUENCY_UP_THRESHOLD              (11)
@@ -144,31 +132,27 @@ static void ondemand_powersave_bias_init(void)
         }
 }
 
-static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq)
+static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq)
 {
-        struct dbs_data *dbs_data = p->governor_data;
+        struct dbs_data *dbs_data = policy->governor_data;
         struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 
         if (od_tuners->powersave_bias)
-                freq = od_ops.powersave_bias_target(p, freq,
+                freq = od_ops.powersave_bias_target(policy, freq,
                                 CPUFREQ_RELATION_H);
-        else if (p->cur == p->max)
+        else if (policy->cur == policy->max)
                 return;
 
-        __cpufreq_driver_target(p, freq, od_tuners->powersave_bias ?
+        __cpufreq_driver_target(policy, freq, od_tuners->powersave_bias ?
                         CPUFREQ_RELATION_L : CPUFREQ_RELATION_H);
 }
 
 /*
  * Every sampling_rate, we check, if current idle time is less than 20%
- * (default), then we try to increase frequency. Every sampling_rate, we look
- * for the lowest frequency which can sustain the load while keeping idle time
- * over 30%. If such a frequency exist, we try to decrease to this frequency.
- *
- * Any frequency increase takes it to the maximum frequency. Frequency reduction
- * happens at minimum steps of 5% (default) of current frequency
+ * (default), then we try to increase frequency. Else, we adjust the frequency
+ * proportional to load.
  */
-static void od_check_cpu(int cpu, unsigned int load_freq)
+static void od_check_cpu(int cpu, unsigned int load)
 {
         struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu);
         struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;
@@ -178,36 +162,21 @@ static void od_check_cpu(int cpu, unsigned int load_freq)
         dbs_info->freq_lo = 0;
 
         /* Check for frequency increase */
-        if (load_freq > od_tuners->up_threshold * policy->cur) {
+        if (load > od_tuners->up_threshold) {
                 /* If switching to max speed, apply sampling_down_factor */
                 if (policy->cur < policy->max)
                         dbs_info->rate_mult =
                                 od_tuners->sampling_down_factor;
                 dbs_freq_increase(policy, policy->max);
                 return;
-        }
-
-        /* Check for frequency decrease */
-        /* if we cannot reduce the frequency anymore, break out early */
-        if (policy->cur == policy->min)
-                return;
-
-        /*
-         * The optimal frequency is the frequency that is the lowest that can
-         * support the current CPU usage without triggering the up policy. To be
-         * safe, we focus 10 points under the threshold.
-         */
-        if (load_freq < od_tuners->adj_up_threshold
-                        * policy->cur) {
+        } else {
+                /* Calculate the next frequency proportional to load */
                 unsigned int freq_next;
-                freq_next = load_freq / od_tuners->adj_up_threshold;
+                freq_next = load * policy->cpuinfo.max_freq / 100;
 
                 /* No longer fully busy, reset rate_mult */
                 dbs_info->rate_mult = 1;
 
-                if (freq_next < policy->min)
-                        freq_next = policy->min;
-
                 if (!od_tuners->powersave_bias) {
                         __cpufreq_driver_target(policy, freq_next,
                                         CPUFREQ_RELATION_L);
@@ -374,9 +343,6 @@ static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
                         input < MIN_FREQUENCY_UP_THRESHOLD) {
                 return -EINVAL;
         }
-        /* Calculate the new adj_up_threshold */
-        od_tuners->adj_up_threshold += input;
-        od_tuners->adj_up_threshold -= od_tuners->up_threshold;
 
         od_tuners->up_threshold = input;
         return count;
@@ -513,7 +479,7 @@ static int od_init(struct dbs_data *dbs_data)
         u64 idle_time;
         int cpu;
 
-        tuners = kzalloc(sizeof(struct od_dbs_tuners), GFP_KERNEL);
+        tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
         if (!tuners) {
                 pr_err("%s: kzalloc failed\n", __func__);
                 return -ENOMEM;
@@ -525,8 +491,6 @@ static int od_init(struct dbs_data *dbs_data)
         if (idle_time != -1ULL) {
                 /* Idle micro accounting is supported. Use finer thresholds */
                 tuners->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD;
-                tuners->adj_up_threshold = MICRO_FREQUENCY_UP_THRESHOLD -
-                        MICRO_FREQUENCY_DOWN_DIFFERENTIAL;
                 /*
                  * In nohz/micro accounting case we set the minimum frequency
                  * not depending on HZ, but fixed (very low). The deferred
@@ -535,8 +499,6 @@ static int od_init(struct dbs_data *dbs_data)
                 dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE;
         } else {
                 tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
-                tuners->adj_up_threshold = DEF_FREQUENCY_UP_THRESHOLD -
-                        DEF_FREQUENCY_DOWN_DIFFERENTIAL;
 
                 /* For correct statistics, we need 10 ticks for each measure */
                 dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
diff --git a/drivers/cpufreq/cpufreq_performance.c b/drivers/cpufreq/cpufreq_performance.c
index 9fef7d6e4e6a..cf117deb39b1 100644
--- a/drivers/cpufreq/cpufreq_performance.c
+++ b/drivers/cpufreq/cpufreq_performance.c
@@ -12,10 +12,9 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/cpufreq.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 static int cpufreq_governor_performance(struct cpufreq_policy *policy,
                                         unsigned int event)
diff --git a/drivers/cpufreq/cpufreq_powersave.c b/drivers/cpufreq/cpufreq_powersave.c
index 32109a14f5dc..e3b874c235ea 100644
--- a/drivers/cpufreq/cpufreq_powersave.c
+++ b/drivers/cpufreq/cpufreq_powersave.c
@@ -12,10 +12,9 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/cpufreq.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 static int cpufreq_governor_powersave(struct cpufreq_policy *policy,
                                         unsigned int event)
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index d37568c5ca9c..04452f026ed0 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -9,17 +9,10 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/cpu.h>
-#include <linux/sysfs.h>
 #include <linux/cpufreq.h>
 #include <linux/module.h>
-#include <linux/jiffies.h>
-#include <linux/percpu.h>
-#include <linux/kobject.h>
-#include <linux/spinlock.h>
-#include <linux/notifier.h>
+#include <linux/slab.h>
 #include <asm/cputime.h>
 
 static spinlock_t cpufreq_stats_lock;
@@ -200,22 +193,22 @@ static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
 {
         unsigned int i, j, count = 0, ret = 0;
         struct cpufreq_stats *stat;
-        struct cpufreq_policy *data;
+        struct cpufreq_policy *current_policy;
         unsigned int alloc_size;
         unsigned int cpu = policy->cpu;
         if (per_cpu(cpufreq_stats_table, cpu))
                 return -EBUSY;
-        stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL);
+        stat = kzalloc(sizeof(*stat), GFP_KERNEL);
         if ((stat) == NULL)
                 return -ENOMEM;
 
-        data = cpufreq_cpu_get(cpu);
-        if (data == NULL) {
+        current_policy = cpufreq_cpu_get(cpu);
+        if (current_policy == NULL) {
                 ret = -EINVAL;
                 goto error_get_fail;
         }
 
-        ret = sysfs_create_group(&data->kobj, &stats_attr_group);
+        ret = sysfs_create_group(&current_policy->kobj, &stats_attr_group);
         if (ret)
                 goto error_out;
 
@@ -258,10 +251,10 @@ static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
         stat->last_time = get_jiffies_64();
         stat->last_index = freq_table_get_index(stat, policy->cur);
         spin_unlock(&cpufreq_stats_lock);
-        cpufreq_cpu_put(data);
+        cpufreq_cpu_put(current_policy);
         return 0;
 error_out:
-        cpufreq_cpu_put(data);
+        cpufreq_cpu_put(current_policy);
 error_get_fail:
         kfree(stat);
         per_cpu(cpufreq_stats_table, cpu) = NULL;
@@ -348,16 +341,10 @@ static int cpufreq_stat_cpu_callback(struct notifier_block *nfb,
         unsigned int cpu = (unsigned long)hcpu;
 
         switch (action) {
-        case CPU_ONLINE:
-        case CPU_ONLINE_FROZEN:
-                cpufreq_update_policy(cpu);
-                break;
         case CPU_DOWN_PREPARE:
-        case CPU_DOWN_PREPARE_FROZEN:
                 cpufreq_stats_free_sysfs(cpu);
                 break;
         case CPU_DEAD:
-        case CPU_DEAD_FROZEN:
                 cpufreq_stats_free_table(cpu);
                 break;
         }
@@ -390,8 +377,6 @@ static int __init cpufreq_stats_init(void)
                 return ret;
 
         register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
-        for_each_online_cpu(cpu)
-                cpufreq_update_policy(cpu);
 
         ret = cpufreq_register_notifier(&notifier_trans_block,
                                 CPUFREQ_TRANSITION_NOTIFIER);
diff --git a/drivers/cpufreq/cris-artpec3-cpufreq.c b/drivers/cpufreq/cris-artpec3-cpufreq.c
index ee142c490575..cb8276dd19ca 100644
--- a/drivers/cpufreq/cris-artpec3-cpufreq.c
+++ b/drivers/cpufreq/cris-artpec3-cpufreq.c
@@ -111,7 +111,6 @@ static struct cpufreq_driver cris_freq_driver = {
         .init   = cris_freq_cpu_init,
         .exit   = cris_freq_cpu_exit,
         .name   = "cris_freq",
-        .owner  = THIS_MODULE,
         .attr   = cris_freq_attr,
 };
 
diff --git a/drivers/cpufreq/cris-etraxfs-cpufreq.c b/drivers/cpufreq/cris-etraxfs-cpufreq.c
index 12952235d5db..72328f77dc53 100644
--- a/drivers/cpufreq/cris-etraxfs-cpufreq.c
+++ b/drivers/cpufreq/cris-etraxfs-cpufreq.c
@@ -108,7 +108,6 @@ static struct cpufreq_driver cris_freq_driver = {
         .init = cris_freq_cpu_init,
         .exit = cris_freq_cpu_exit,
         .name = "cris_freq",
-        .owner = THIS_MODULE,
         .attr = cris_freq_attr,
 };
 
diff --git a/drivers/cpufreq/e_powersaver.c b/drivers/cpufreq/e_powersaver.c
index a60efaeb4cf8..09f64cc83019 100644
--- a/drivers/cpufreq/e_powersaver.c
+++ b/drivers/cpufreq/e_powersaver.c
@@ -54,7 +54,7 @@ static struct acpi_processor_performance *eps_acpi_cpu_perf;
 /* Minimum necessary to get acpi_processor_get_bios_limit() working */
 static int eps_acpi_init(void)
 {
-        eps_acpi_cpu_perf = kzalloc(sizeof(struct acpi_processor_performance),
+        eps_acpi_cpu_perf = kzalloc(sizeof(*eps_acpi_cpu_perf),
                                       GFP_KERNEL);
         if (!eps_acpi_cpu_perf)
                 return -ENOMEM;
@@ -366,7 +366,7 @@ static int eps_cpu_init(struct cpufreq_policy *policy)
                 states = 2;
 
         /* Allocate private data and frequency table for current cpu */
-        centaur = kzalloc(sizeof(struct eps_cpu_data)
+        centaur = kzalloc(sizeof(*centaur)
                     + (states + 1) * sizeof(struct cpufreq_frequency_table),
                     GFP_KERNEL);
         if (!centaur)
@@ -436,7 +436,6 @@ static struct cpufreq_driver eps_driver = {
         .exit           = eps_cpu_exit,
         .get            = eps_get,
         .name           = "e_powersaver",
-        .owner          = THIS_MODULE,
         .attr           = eps_attr,
 };
 
diff --git a/drivers/cpufreq/elanfreq.c b/drivers/cpufreq/elanfreq.c
index 658d860344b0..823a400d98fd 100644
--- a/drivers/cpufreq/elanfreq.c
+++ b/drivers/cpufreq/elanfreq.c
@@ -274,7 +274,6 @@ static struct cpufreq_driver elanfreq_driver = {
         .init           = elanfreq_cpu_init,
         .exit           = elanfreq_cpu_exit,
         .name           = "elanfreq",
-        .owner          = THIS_MODULE,
         .attr           = elanfreq_attr,
 };
 
diff --git a/drivers/cpufreq/exynos-cpufreq.c b/drivers/cpufreq/exynos-cpufreq.c
index 0d32f02ef4d6..0fac34439e31 100644
--- a/drivers/cpufreq/exynos-cpufreq.c
+++ b/drivers/cpufreq/exynos-cpufreq.c
@@ -289,7 +289,7 @@ static int __init exynos_cpufreq_init(void)
 {
         int ret = -EINVAL;
 
-        exynos_info = kzalloc(sizeof(struct exynos_dvfs_info), GFP_KERNEL);
+        exynos_info = kzalloc(sizeof(*exynos_info), GFP_KERNEL);
         if (!exynos_info)
                 return -ENOMEM;
 
@@ -332,7 +332,6 @@ err_cpufreq:
         regulator_put(arm_regulator);
 err_vdd_arm:
         kfree(exynos_info);
-        pr_debug("%s: failed initialization\n", __func__);
         return -EINVAL;
 }
 late_initcall(exynos_cpufreq_init);
diff --git a/drivers/cpufreq/exynos-cpufreq.h b/drivers/cpufreq/exynos-cpufreq.h
index 92b852ee5ddc..7f25cee8cec2 100644
--- a/drivers/cpufreq/exynos-cpufreq.h
+++ b/drivers/cpufreq/exynos-cpufreq.h
@@ -43,6 +43,27 @@ struct exynos_dvfs_info {
         bool (*need_apll_change)(unsigned int, unsigned int);
 };
 
+#ifdef CONFIG_ARM_EXYNOS4210_CPUFREQ
 extern int exynos4210_cpufreq_init(struct exynos_dvfs_info *);
+#else
+static inline int exynos4210_cpufreq_init(struct exynos_dvfs_info *info)
+{
+        return -EOPNOTSUPP;
+}
+#endif
+#ifdef CONFIG_ARM_EXYNOS4X12_CPUFREQ
 extern int exynos4x12_cpufreq_init(struct exynos_dvfs_info *);
+#else
+static inline int exynos4x12_cpufreq_init(struct exynos_dvfs_info *info)
+{
+        return -EOPNOTSUPP;
+}
+#endif
+#ifdef CONFIG_ARM_EXYNOS5250_CPUFREQ
 extern int exynos5250_cpufreq_init(struct exynos_dvfs_info *);
+#else
+static inline int exynos5250_cpufreq_init(struct exynos_dvfs_info *info)
+{
+        return -EOPNOTSUPP;
+}
+#endif
diff --git a/drivers/cpufreq/exynos5440-cpufreq.c b/drivers/cpufreq/exynos5440-cpufreq.c
index 0c74018eda47..d514c152fd1a 100644
--- a/drivers/cpufreq/exynos5440-cpufreq.c
+++ b/drivers/cpufreq/exynos5440-cpufreq.c
@@ -238,6 +238,9 @@ static int exynos_target(struct cpufreq_policy *policy,
         freqs.old = dvfs_info->cur_frequency;
         freqs.new = freq_table[index].frequency;
 
+        if (freqs.old == freqs.new)
+                goto out;
+
         cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         /* Set the target frequency in all C0_3_PSTATE register */
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index f0d87412cc91..f111454a7aea 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -11,10 +11,8 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/cpufreq.h>
+#include <linux/module.h>
 
 /*********************************************************************
  *                     FREQUENCY TABLE HELPERS                       *
diff --git a/drivers/cpufreq/gx-suspmod.c b/drivers/cpufreq/gx-suspmod.c
index 3dfc99b9ca86..70442c7b5e71 100644
--- a/drivers/cpufreq/gx-suspmod.c
+++ b/drivers/cpufreq/gx-suspmod.c
@@ -183,7 +183,7 @@ static void gx_write_byte(int reg, int value)
  * gx_detect_chipset:
  *
  **/
-static __init struct pci_dev *gx_detect_chipset(void)
+static struct pci_dev * __init gx_detect_chipset(void)
 {
         struct pci_dev *gx_pci = NULL;
 
@@ -446,7 +446,6 @@ static struct cpufreq_driver gx_suspmod_driver = {
         .target         = cpufreq_gx_target,
         .init           = cpufreq_gx_cpu_init,
         .name           = "gx-suspmod",
-        .owner          = THIS_MODULE,
 };
 
 static int __init cpufreq_gx_init(void)
@@ -466,7 +465,7 @@ static int __init cpufreq_gx_init(void)
 
         pr_debug("geode suspend modulation available.\n");
 
-        params = kzalloc(sizeof(struct gxfreq_params), GFP_KERNEL);
+        params = kzalloc(sizeof(*params), GFP_KERNEL);
         if (params == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/cpufreq/highbank-cpufreq.c b/drivers/cpufreq/highbank-cpufreq.c
index b61b5a3fad64..794123fcf3e3 100644
--- a/drivers/cpufreq/highbank-cpufreq.c
+++ b/drivers/cpufreq/highbank-cpufreq.c
@@ -69,23 +69,17 @@ static int hb_cpufreq_driver_init(void)
         if (!of_machine_is_compatible("calxeda,highbank"))
                 return -ENODEV;
 
-        for_each_child_of_node(of_find_node_by_path("/cpus"), np)
-                if (of_get_property(np, "operating-points", NULL))
-                        break;
-
-        if (!np) {
-                pr_err("failed to find highbank cpufreq node\n");
-                return -ENOENT;
-        }
-
         cpu_dev = get_cpu_device(0);
         if (!cpu_dev) {
                 pr_err("failed to get highbank cpufreq device\n");
-                ret = -ENODEV;
-                goto out_put_node;
+                return -ENODEV;
         }
 
-        cpu_dev->of_node = np;
+        np = of_node_get(cpu_dev->of_node);
+        if (!np) {
+                pr_err("failed to find highbank cpufreq node\n");
+                return -ENOENT;
+        }
 
         cpu_clk = clk_get(cpu_dev, NULL);
         if (IS_ERR(cpu_clk)) {
diff --git a/drivers/cpufreq/ia64-acpi-cpufreq.c b/drivers/cpufreq/ia64-acpi-cpufreq.c
index 573c14ea802d..3e14f0317175 100644
--- a/drivers/cpufreq/ia64-acpi-cpufreq.c
+++ b/drivers/cpufreq/ia64-acpi-cpufreq.c
@@ -274,7 +274,7 @@ acpi_cpufreq_cpu_init (
 
         pr_debug("acpi_cpufreq_cpu_init\n");
 
-        data = kzalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
                 return (-ENOMEM);
 
@@ -304,7 +304,7 @@ acpi_cpufreq_cpu_init (
         }
 
         /* alloc freq_table */
-        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
+        data->freq_table = kmalloc(sizeof(*data->freq_table) *
                                    (data->acpi_data.state_count + 1),
                                    GFP_KERNEL);
         if (!data->freq_table) {
@@ -409,7 +409,6 @@ static struct cpufreq_driver acpi_cpufreq_driver = {
         .init           = acpi_cpufreq_cpu_init,
         .exit           = acpi_cpufreq_cpu_exit,
         .name           = "acpi-cpufreq",
-        .owner          = THIS_MODULE,
         .attr           = acpi_cpufreq_attr,
 };
 
diff --git a/drivers/cpufreq/imx6q-cpufreq.c b/drivers/cpufreq/imx6q-cpufreq.c
index e37cdaedbb5b..3e396543aea4 100644
--- a/drivers/cpufreq/imx6q-cpufreq.c
+++ b/drivers/cpufreq/imx6q-cpufreq.c
@@ -117,28 +117,11 @@ static int imx6q_set_target(struct cpufreq_policy *policy,
          *  - Reprogram pll1_sys_clk and reparent pll1_sw_clk back to it
          *  - Disable pll2_pfd2_396m_clk
          */
-        clk_prepare_enable(pll2_pfd2_396m_clk);
         clk_set_parent(step_clk, pll2_pfd2_396m_clk);
         clk_set_parent(pll1_sw_clk, step_clk);
         if (freq_hz > clk_get_rate(pll2_pfd2_396m_clk)) {
                 clk_set_rate(pll1_sys_clk, freqs.new * 1000);
-                /*
-                 * If we are leaving 396 MHz set-point, we need to enable
-                 * pll1_sys_clk and disable pll2_pfd2_396m_clk to keep
-                 * their use count correct.
-                 */
-                if (freqs.old * 1000 <= clk_get_rate(pll2_pfd2_396m_clk)) {
-                        clk_prepare_enable(pll1_sys_clk);
-                        clk_disable_unprepare(pll2_pfd2_396m_clk);
-                }
                 clk_set_parent(pll1_sw_clk, pll1_sys_clk);
-                clk_disable_unprepare(pll2_pfd2_396m_clk);
-        } else {
-                /*
-                 * Disable pll1_sys_clk if pll2_pfd2_396m_clk is sufficient
-                 * to provide the frequency.
-                 */
-                clk_disable_unprepare(pll1_sys_clk);
         }
 
         /* Ensure the arm clock divider is what we expect */
@@ -221,14 +204,12 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
 
         cpu_dev = &pdev->dev;
 
-        np = of_find_node_by_path("/cpus/cpu@0");
+        np = of_node_get(cpu_dev->of_node);
         if (!np) {
                 dev_err(cpu_dev, "failed to find cpu0 node\n");
                 return -ENOENT;
         }
 
-        cpu_dev->of_node = np;
-
         arm_clk = devm_clk_get(cpu_dev, "arm");
         pll1_sys_clk = devm_clk_get(cpu_dev, "pll1_sys");
         pll1_sw_clk = devm_clk_get(cpu_dev, "pll1_sw");
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 7cde885011ed..6efd96c196b2 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -665,7 +665,6 @@ static struct cpufreq_driver intel_pstate_driver = {
         .init           = intel_pstate_cpu_init,
         .exit           = intel_pstate_cpu_exit,
         .name           = "intel_pstate",
-        .owner          = THIS_MODULE,
 };
 
 static int __initdata no_load;
diff --git a/drivers/cpufreq/kirkwood-cpufreq.c b/drivers/cpufreq/kirkwood-cpufreq.c
index c233ea617366..ba10658a9394 100644
--- a/drivers/cpufreq/kirkwood-cpufreq.c
+++ b/drivers/cpufreq/kirkwood-cpufreq.c
@@ -14,7 +14,7 @@
 #include <linux/clk.h>
 #include <linux/clk-provider.h>
 #include <linux/cpufreq.h>
-#include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <asm/proc-fns.h>
@@ -158,7 +158,6 @@ static struct cpufreq_driver kirkwood_cpufreq_driver = {
         .init   = kirkwood_cpufreq_cpu_init,
         .exit   = kirkwood_cpufreq_cpu_exit,
         .name   = "kirkwood-cpufreq",
-        .owner  = THIS_MODULE,
         .attr   = kirkwood_cpufreq_attr,
 };
 
@@ -175,9 +174,11 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev)
         if (IS_ERR(priv.base))
                 return PTR_ERR(priv.base);
 
-        np = of_find_node_by_path("/cpus/cpu@0");
-        if (!np)
+        np = of_cpu_device_node_get(0);
+        if (!np) {
+                dev_err(&pdev->dev, "failed to get cpu device node\n");
                 return -ENODEV;
+        }
 
         priv.cpu_clk = of_clk_get_by_name(np, "cpu_clk");
         if (IS_ERR(priv.cpu_clk)) {
diff --git a/drivers/cpufreq/longhaul.c b/drivers/cpufreq/longhaul.c
index 8c49261df57d..4ada1cccb052 100644
--- a/drivers/cpufreq/longhaul.c
+++ b/drivers/cpufreq/longhaul.c
@@ -948,7 +948,6 @@ static struct cpufreq_driver longhaul_driver = {
         .init   = longhaul_cpu_init,
         .exit   = longhaul_cpu_exit,
         .name   = "longhaul",
-        .owner  = THIS_MODULE,
         .attr   = longhaul_attr,
 };
 
diff --git a/drivers/cpufreq/longrun.c b/drivers/cpufreq/longrun.c
index 0fe041d1f77f..5aa031612d53 100644
--- a/drivers/cpufreq/longrun.c
+++ b/drivers/cpufreq/longrun.c
@@ -286,7 +286,6 @@ static struct cpufreq_driver longrun_driver = {
         .get            = longrun_get,
         .init           = longrun_cpu_init,
         .name           = "longrun",
-        .owner          = THIS_MODULE,
 };
 
 static const struct x86_cpu_id longrun_ids[] = {
diff --git a/drivers/cpufreq/loongson2_cpufreq.c b/drivers/cpufreq/loongson2_cpufreq.c
index 9536852c504a..7bc3c44d34e2 100644
--- a/drivers/cpufreq/loongson2_cpufreq.c
+++ b/drivers/cpufreq/loongson2_cpufreq.c
@@ -158,7 +158,6 @@ static struct freq_attr *loongson2_table_attr[] = {
 };
 
 static struct cpufreq_driver loongson2_cpufreq_driver = {
-        .owner = THIS_MODULE,
         .name = "loongson2",
         .init = loongson2_cpufreq_cpu_init,
         .verify = loongson2_cpufreq_verify,
diff --git a/drivers/cpufreq/maple-cpufreq.c b/drivers/cpufreq/maple-cpufreq.c
index cdd62915efaf..6168d77b296d 100644
--- a/drivers/cpufreq/maple-cpufreq.c
+++ b/drivers/cpufreq/maple-cpufreq.c
@@ -24,7 +24,7 @@
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <linux/time.h>
-#include <linux/of.h>
+#include <linux/of_device.h>
 
 #define DBG(fmt...) pr_debug(fmt)
 
@@ -190,7 +190,6 @@ static int maple_cpufreq_cpu_init(struct cpufreq_policy *policy)
 
 static struct cpufreq_driver maple_cpufreq_driver = {
         .name           = "maple",
-        .owner          = THIS_MODULE,
         .flags          = CPUFREQ_CONST_LOOPS,
         .init           = maple_cpufreq_cpu_init,
         .verify         = maple_cpufreq_verify,
@@ -201,7 +200,6 @@ static struct cpufreq_driver maple_cpufreq_driver = {
 
 static int __init maple_cpufreq_init(void)
 {
-        struct device_node *cpus;
         struct device_node *cpunode;
         unsigned int psize;
         unsigned long max_freq;
@@ -217,24 +215,11 @@ static int __init maple_cpufreq_init(void)
             !of_machine_is_compatible("Momentum,Apache"))
                 return 0;
 
-        cpus = of_find_node_by_path("/cpus");
-        if (cpus == NULL) {
-                DBG("No /cpus node !\n");
-                return -ENODEV;
-        }
-
         /* Get first CPU node */
-        for (cpunode = NULL;
-             (cpunode = of_get_next_child(cpus, cpunode)) != NULL;) {
-                const u32 *reg = of_get_property(cpunode, "reg", NULL);
-                if (reg == NULL || (*reg) != 0)
-                        continue;
-                if (!strcmp(cpunode->type, "cpu"))
-                        break;
-        }
+        cpunode = of_cpu_device_node_get(0);
         if (cpunode == NULL) {
                 printk(KERN_ERR "cpufreq: Can't find any CPU 0 node\n");
-                goto bail_cpus;
+                goto bail_noprops;
         }
 
         /* Check 970FX for now */
@@ -290,14 +275,11 @@ static int __init maple_cpufreq_init(void)
         rc = cpufreq_register_driver(&maple_cpufreq_driver);
 
         of_node_put(cpunode);
-        of_node_put(cpus);
 
         return rc;
 
 bail_noprops:
         of_node_put(cpunode);
-bail_cpus:
-        of_node_put(cpus);
 
         return rc;
 }
diff --git a/drivers/cpufreq/mperf.c b/drivers/cpufreq/mperf.c
deleted file mode 100644
index 911e193018ae..000000000000
--- a/drivers/cpufreq/mperf.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <linux/kernel.h>
-#include <linux/smp.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/slab.h>
-
-#include "mperf.h"
-
-static DEFINE_PER_CPU(struct aperfmperf, acfreq_old_perf);
-
-/* Called via smp_call_function_single(), on the target CPU */
-static void read_measured_perf_ctrs(void *_cur)
-{
-        struct aperfmperf *am = _cur;
-
-        get_aperfmperf(am);
-}
-
-/*
- * Return the measured active (C0) frequency on this CPU since last call
- * to this function.
- * Input: cpu number
- * Return: Average CPU frequency in terms of max frequency (zero on error)
- *
- * We use IA32_MPERF and IA32_APERF MSRs to get the measured performance
- * over a period of time, while CPU is in C0 state.
- * IA32_MPERF counts at the rate of max advertised frequency
- * IA32_APERF counts at the rate of actual CPU frequency
- * Only IA32_APERF/IA32_MPERF ratio is architecturally defined and
- * no meaning should be associated with absolute values of these MSRs.
- */
-unsigned int cpufreq_get_measured_perf(struct cpufreq_policy *policy,
-                                        unsigned int cpu)
-{
-        struct aperfmperf perf;
-        unsigned long ratio;
-        unsigned int retval;
-
-        if (smp_call_function_single(cpu, read_measured_perf_ctrs, &perf, 1))
-                return 0;
-
-        ratio = calc_aperfmperf_ratio(&per_cpu(acfreq_old_perf, cpu), &perf);
-        per_cpu(acfreq_old_perf, cpu) = perf;
-
-        retval = (policy->cpuinfo.max_freq * ratio) >> APERFMPERF_SHIFT;
-
-        return retval;
-}
-EXPORT_SYMBOL_GPL(cpufreq_get_measured_perf);
-MODULE_LICENSE("GPL");
diff --git a/drivers/cpufreq/mperf.h b/drivers/cpufreq/mperf.h
deleted file mode 100644
index 5dbf2950dc22..000000000000
--- a/drivers/cpufreq/mperf.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
- *  (c) 2010 Advanced Micro Devices, Inc.
- *  Your use of this code is subject to the terms and conditions of the
- *  GNU general public license version 2. See "COPYING" or
- *  http://www.gnu.org/licenses/gpl.html
- */
-
-unsigned int cpufreq_get_measured_perf(struct cpufreq_policy *policy,
-                                        unsigned int cpu);
diff --git a/drivers/cpufreq/p4-clockmod.c b/drivers/cpufreq/p4-clockmod.c
index 9ee78170ff86..2f0a2a65c37f 100644
--- a/drivers/cpufreq/p4-clockmod.c
+++ b/drivers/cpufreq/p4-clockmod.c
@@ -279,7 +279,6 @@ static struct cpufreq_driver p4clockmod_driver = {
         .exit           = cpufreq_p4_cpu_exit,
         .get            = cpufreq_p4_get,
         .name           = "p4-clockmod",
-        .owner          = THIS_MODULE,
         .attr           = p4clockmod_attr,
 };
 
diff --git a/drivers/cpufreq/pasemi-cpufreq.c b/drivers/cpufreq/pasemi-cpufreq.c
index b704da404067..534e43a60d1f 100644
--- a/drivers/cpufreq/pasemi-cpufreq.c
+++ b/drivers/cpufreq/pasemi-cpufreq.c
@@ -297,7 +297,6 @@ static int pas_cpufreq_target(struct cpufreq_policy *policy,
 
 static struct cpufreq_driver pas_cpufreq_driver = {
         .name           = "pas-cpufreq",
-        .owner          = THIS_MODULE,
         .flags          = CPUFREQ_CONST_LOOPS,
         .init           = pas_cpufreq_cpu_init,
         .exit           = pas_cpufreq_cpu_exit,
diff --git a/drivers/cpufreq/pcc-cpufreq.c b/drivers/cpufreq/pcc-cpufreq.c
index 1581fcc4cf4a..d81c4e5ea0ad 100644
--- a/drivers/cpufreq/pcc-cpufreq.c
+++ b/drivers/cpufreq/pcc-cpufreq.c
@@ -587,7 +587,6 @@ static struct cpufreq_driver pcc_cpufreq_driver = {
         .init = pcc_cpufreq_cpu_init,
         .exit = pcc_cpufreq_cpu_exit,
         .name = "pcc-cpufreq",
-        .owner = THIS_MODULE,
 };
 
 static int __init pcc_cpufreq_init(void)
diff --git a/drivers/cpufreq/pmac32-cpufreq.c b/drivers/cpufreq/pmac32-cpufreq.c
index 3104fad82480..a096cd3fa23d 100644
--- a/drivers/cpufreq/pmac32-cpufreq.c
+++ b/drivers/cpufreq/pmac32-cpufreq.c
@@ -25,6 +25,7 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/hardirq.h>
+#include <linux/of_device.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/irq.h>
@@ -477,7 +478,6 @@ static struct cpufreq_driver pmac_cpufreq_driver = {
         .flags          = CPUFREQ_PM_NO_WARN,
         .attr           = pmac_cpu_freqs_attr,
         .name           = "powermac",
-        .owner          = THIS_MODULE,
 };
 
 
@@ -649,8 +649,8 @@ static int __init pmac_cpufreq_setup(void)
         if (strstr(cmd_line, "nocpufreq"))
                 return 0;
 
-        /* Assume only one CPU */
-        cpunode = of_find_node_by_type(NULL, "cpu");
+        /* Get first CPU node */
+        cpunode = of_cpu_device_node_get(0);
         if (!cpunode)
                 goto out;
 
diff --git a/drivers/cpufreq/pmac64-cpufreq.c b/drivers/cpufreq/pmac64-cpufreq.c
index 7ba423431cfe..3a51ad7e47c8 100644
--- a/drivers/cpufreq/pmac64-cpufreq.c
+++ b/drivers/cpufreq/pmac64-cpufreq.c
@@ -22,6 +22,7 @@
 #include <linux/init.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
+#include <linux/of_device.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/irq.h>
@@ -371,7 +372,6 @@ static int g5_cpufreq_cpu_init(struct cpufreq_policy *policy)
 
 static struct cpufreq_driver g5_cpufreq_driver = {
         .name           = "powermac",
-        .owner          = THIS_MODULE,
         .flags          = CPUFREQ_CONST_LOOPS,
         .init           = g5_cpufreq_cpu_init,
         .verify         = g5_cpufreq_verify,
@@ -383,9 +383,8 @@ static struct cpufreq_driver g5_cpufreq_driver = {
 
 #ifdef CONFIG_PMAC_SMU
 
-static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
+static int __init g5_neo2_cpufreq_init(struct device_node *cpunode)
 {
-        struct device_node *cpunode;
         unsigned int psize, ssize;
         unsigned long max_freq;
         char *freq_method, *volt_method;
@@ -405,20 +404,6 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         else
                 return -ENODEV;
 
-        /* Get first CPU node */
-        for (cpunode = NULL;
-             (cpunode = of_get_next_child(cpus, cpunode)) != NULL;) {
-                const u32 *reg = of_get_property(cpunode, "reg", NULL);
-                if (reg == NULL || (*reg) != 0)
-                        continue;
-                if (!strcmp(cpunode->type, "cpu"))
-                        break;
-        }
-        if (cpunode == NULL) {
-                printk(KERN_ERR "cpufreq: Can't find any CPU 0 node\n");
-                return -ENODEV;
-        }
-
         /* Check 970FX for now */
         valp = of_get_property(cpunode, "cpu-version", NULL);
         if (!valp) {
@@ -447,9 +432,8 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
                 if (!shdr)
                         goto bail_noprops;
                 g5_fvt_table = (struct smu_sdbp_fvt *)&shdr[1];
-                ssize = (shdr->len * sizeof(u32)) -
-                        sizeof(struct smu_sdbp_header);
-                g5_fvt_count = ssize / sizeof(struct smu_sdbp_fvt);
+                ssize = (shdr->len * sizeof(u32)) - sizeof(*shdr);
+                g5_fvt_count = ssize / sizeof(*g5_fvt_table);
                 g5_fvt_cur = 0;
 
                 /* Sanity checking */
@@ -537,9 +521,9 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
 #endif /* CONFIG_PMAC_SMU */
 
 
-static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
+static int __init g5_pm72_cpufreq_init(struct device_node *cpunode)
 {
-        struct device_node *cpuid = NULL, *hwclock = NULL, *cpunode = NULL;
+        struct device_node *cpuid = NULL, *hwclock = NULL;
         const u8 *eeprom = NULL;
         const u32 *valp;
         u64 max_freq, min_freq, ih, il;
@@ -548,17 +532,6 @@ static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
         DBG("cpufreq: Initializing for PowerMac7,2, PowerMac7,3 and"
             " RackMac3,1...\n");
 
-        /* Get first CPU node */
-        for (cpunode = NULL;
-             (cpunode = of_get_next_child(cpus, cpunode)) != NULL;) {
-                if (!strcmp(cpunode->type, "cpu"))
-                        break;
-        }
-        if (cpunode == NULL) {
-                printk(KERN_ERR "cpufreq: Can't find any CPU node\n");
-                return -ENODEV;
-        }
-
         /* Lookup the cpuid eeprom node */
         cpuid = of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/cpuid@a0");
         if (cpuid != NULL)
@@ -718,25 +691,25 @@ static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
 
 static int __init g5_cpufreq_init(void)
 {
-        struct device_node *cpus;
+        struct device_node *cpunode;
         int rc = 0;
 
-        cpus = of_find_node_by_path("/cpus");
-        if (cpus == NULL) {
-                DBG("No /cpus node !\n");
+        /* Get first CPU node */
+        cpunode = of_cpu_device_node_get(0);
+        if (cpunode == NULL) {
+                pr_err("cpufreq: Can't find any CPU node\n");
                 return -ENODEV;
         }
 
         if (of_machine_is_compatible("PowerMac7,2") ||
             of_machine_is_compatible("PowerMac7,3") ||
             of_machine_is_compatible("RackMac3,1"))
-                rc = g5_pm72_cpufreq_init(cpus);
+                rc = g5_pm72_cpufreq_init(cpunode);
 #ifdef CONFIG_PMAC_SMU
         else
-                rc = g5_neo2_cpufreq_init(cpus);
+                rc = g5_neo2_cpufreq_init(cpunode);
 #endif /* CONFIG_PMAC_SMU */
 
-        of_node_put(cpus);
         return rc;
 }
 
diff --git a/drivers/cpufreq/powernow-k6.c b/drivers/cpufreq/powernow-k6.c
index ea8e10382ec5..85f1c8c25ddc 100644
--- a/drivers/cpufreq/powernow-k6.c
+++ b/drivers/cpufreq/powernow-k6.c
@@ -207,7 +207,6 @@ static struct cpufreq_driver powernow_k6_driver = {
         .exit           = powernow_k6_cpu_exit,
         .get            = powernow_k6_get,
         .name           = "powernow-k6",
-        .owner          = THIS_MODULE,
         .attr           = powernow_k6_attr,
 };
 
diff --git a/drivers/cpufreq/powernow-k7.c b/drivers/cpufreq/powernow-k7.c
index 955870877935..14ce480be8ab 100644
--- a/drivers/cpufreq/powernow-k7.c
+++ b/drivers/cpufreq/powernow-k7.c
@@ -177,7 +177,7 @@ static int get_ranges(unsigned char *pst)
         unsigned int speed;
         u8 fid, vid;
 
-        powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
+        powernow_table = kzalloc((sizeof(*powernow_table) *
                                 (number_scales + 1)), GFP_KERNEL);
         if (!powernow_table)
                 return -ENOMEM;
@@ -309,8 +309,7 @@ static int powernow_acpi_init(void)
                 goto err0;
         }
 
-        acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
-                                      GFP_KERNEL);
+        acpi_processor_perf = kzalloc(sizeof(*acpi_processor_perf), GFP_KERNEL);
         if (!acpi_processor_perf) {
                 retval = -ENOMEM;
                 goto err0;
@@ -346,7 +345,7 @@ static int powernow_acpi_init(void)
                 goto err2;
         }
 
-        powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
+        powernow_table = kzalloc((sizeof(*powernow_table) *
                                 (number_scales + 1)), GFP_KERNEL);
         if (!powernow_table) {
                 retval = -ENOMEM;
@@ -497,7 +496,7 @@ static int powernow_decode_bios(int maxfid, int startvid)
                                         "relevant to this CPU).\n",
                                         psb->numpst);
 
-                        p += sizeof(struct psb_s);
+                        p += sizeof(*psb);
 
                         pst = (struct pst_s *) p;
 
@@ -510,12 +509,12 @@ static int powernow_decode_bios(int maxfid, int startvid)
                                     (maxfid == pst->maxfid) &&
                                     (startvid == pst->startvid)) {
                                         print_pst_entry(pst, j);
-                                        p = (char *)pst + sizeof(struct pst_s);
+                                        p = (char *)pst + sizeof(*pst);
                                         ret = get_ranges(p);
                                         return ret;
                                 } else {
                                         unsigned int k;
-                                        p = (char *)pst + sizeof(struct pst_s);
+                                        p = (char *)pst + sizeof(*pst);
                                         for (k = 0; k < number_scales; k++)
                                                 p += 2;
                                 }
@@ -717,7 +716,6 @@ static struct cpufreq_driver powernow_driver = {
         .init           = powernow_cpu_init,
         .exit           = powernow_cpu_exit,
         .name           = "powernow-k7",
-        .owner          = THIS_MODULE,
         .attr           = powernow_table_attr,
 };
 
diff --git a/drivers/cpufreq/powernow-k8.c b/drivers/cpufreq/powernow-k8.c
index c39d189217cb..2344a9ed17f3 100644
--- a/drivers/cpufreq/powernow-k8.c
+++ b/drivers/cpufreq/powernow-k8.c
@@ -623,7 +623,7 @@ static int fill_powernow_table(struct powernow_k8_data *data,
         if (check_pst_table(data, pst, maxvid))
                 return -EINVAL;
 
-        powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
+        powernow_table = kmalloc((sizeof(*powernow_table)
                 * (data->numps + 1)), GFP_KERNEL);
         if (!powernow_table) {
                 printk(KERN_ERR PFX "powernow_table memory alloc failure\n");
@@ -793,7 +793,7 @@ static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
         }
 
         /* fill in data->powernow_table */
-        powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
+        powernow_table = kmalloc((sizeof(*powernow_table)
                 * (data->acpi_data.state_count + 1)), GFP_KERNEL);
         if (!powernow_table) {
                 pr_debug("powernow_table memory alloc failure\n");
@@ -1106,7 +1106,7 @@ static int powernowk8_cpu_init(struct cpufreq_policy *pol)
         if (rc)
                 return -ENODEV;
 
-        data = kzalloc(sizeof(struct powernow_k8_data), GFP_KERNEL);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data) {
                 printk(KERN_ERR PFX "unable to alloc powernow_k8_data");
                 return -ENOMEM;
@@ -1240,7 +1240,6 @@ static struct cpufreq_driver cpufreq_amd64_driver = {
         .exit           = powernowk8_cpu_exit,
         .get            = powernowk8_get,
         .name           = "powernow-k8",
-        .owner          = THIS_MODULE,
         .attr           = powernow_k8_attr,
 };
 
diff --git a/drivers/cpufreq/ppc-corenet-cpufreq.c b/drivers/cpufreq/ppc-corenet-cpufreq.c
index 3cae4529f959..60e81d524ea8 100644
--- a/drivers/cpufreq/ppc-corenet-cpufreq.c
+++ b/drivers/cpufreq/ppc-corenet-cpufreq.c
@@ -300,7 +300,6 @@ static struct freq_attr *corenet_cpufreq_attr[] = {
 
 static struct cpufreq_driver ppc_corenet_cpufreq_driver = {
         .name           = "ppc_cpufreq",
-        .owner          = THIS_MODULE,
         .flags          = CPUFREQ_CONST_LOOPS,
         .init           = corenet_cpufreq_cpu_init,
         .exit           = __exit_p(corenet_cpufreq_cpu_exit),
diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c
index 5936f8d6f2cc..2e448f0bbdc5 100644
--- a/drivers/cpufreq/ppc_cbe_cpufreq.c
+++ b/drivers/cpufreq/ppc_cbe_cpufreq.c
@@ -181,7 +181,6 @@ static struct cpufreq_driver cbe_cpufreq_driver = {
         .init           = cbe_cpufreq_cpu_init,
         .exit           = cbe_cpufreq_cpu_exit,
         .name           = "cbe-cpufreq",
-        .owner          = THIS_MODULE,
         .flags          = CPUFREQ_CONST_LOOPS,
 };
 
diff --git a/drivers/cpufreq/pxa2xx-cpufreq.c b/drivers/cpufreq/pxa2xx-cpufreq.c
index fb3981ac829f..8749eaf18793 100644
--- a/drivers/cpufreq/pxa2xx-cpufreq.c
+++ b/drivers/cpufreq/pxa2xx-cpufreq.c
@@ -191,7 +191,7 @@ static int pxa_cpufreq_change_voltage(pxa_freqs_t *pxa_freq)
         return ret;
 }
 
-static __init void pxa_cpufreq_init_voltages(void)
+static void __init pxa_cpufreq_init_voltages(void)
 {
         vcc_core = regulator_get(NULL, "vcc_core");
         if (IS_ERR(vcc_core)) {
@@ -207,7 +207,7 @@ static int pxa_cpufreq_change_voltage(pxa_freqs_t *pxa_freq)
         return 0;
 }
 
-static __init void pxa_cpufreq_init_voltages(void) { }
+static void __init pxa_cpufreq_init_voltages(void) { }
 #endif
 
 static void find_freq_tables(struct cpufreq_frequency_table **freq_table,
diff --git a/drivers/cpufreq/pxa3xx-cpufreq.c b/drivers/cpufreq/pxa3xx-cpufreq.c
index 9c92ef032a9e..d26306fb00d2 100644
--- a/drivers/cpufreq/pxa3xx-cpufreq.c
+++ b/drivers/cpufreq/pxa3xx-cpufreq.c
@@ -213,10 +213,12 @@ static int pxa3xx_cpufreq_init(struct cpufreq_policy *policy)
         policy->cur = policy->min = policy->max;
 
         if (cpu_is_pxa300() || cpu_is_pxa310())
-                ret = setup_freqs_table(policy, ARRAY_AND_SIZE(pxa300_freqs));
+                ret = setup_freqs_table(policy, pxa300_freqs,
+                                        ARRAY_SIZE(pxa300_freqs));
 
         if (cpu_is_pxa320())
-                ret = setup_freqs_table(policy, ARRAY_AND_SIZE(pxa320_freqs));
+                ret = setup_freqs_table(policy, pxa320_freqs,
+                                        ARRAY_SIZE(pxa320_freqs));
 
         if (ret) {
                 pr_err("failed to setup frequency table\n");
diff --git a/drivers/cpufreq/s3c2416-cpufreq.c b/drivers/cpufreq/s3c2416-cpufreq.c
index ce5b9fca9c18..22dcb81ef9d0 100644
--- a/drivers/cpufreq/s3c2416-cpufreq.c
+++ b/drivers/cpufreq/s3c2416-cpufreq.c
@@ -524,7 +524,6 @@ static struct freq_attr *s3c2416_cpufreq_attr[] = {
 };
 
 static struct cpufreq_driver s3c2416_cpufreq_driver = {
-        .owner          = THIS_MODULE,
         .flags          = 0,
         .verify         = s3c2416_cpufreq_verify_speed,
         .target         = s3c2416_cpufreq_set_target,
diff --git a/drivers/cpufreq/s3c24xx-cpufreq.c b/drivers/cpufreq/s3c24xx-cpufreq.c
index 87781eb20d6d..b0f343fcb7ee 100644
--- a/drivers/cpufreq/s3c24xx-cpufreq.c
+++ b/drivers/cpufreq/s3c24xx-cpufreq.c
@@ -392,7 +392,7 @@ static int s3c_cpufreq_init(struct cpufreq_policy *policy)
         return 0;
 }
 
-static __init int s3c_cpufreq_initclks(void)
+static int __init s3c_cpufreq_initclks(void)
 {
         _clk_mpll = s3c_cpufreq_clk_get(NULL, "mpll");
         _clk_xtal = s3c_cpufreq_clk_get(NULL, "xtal");
@@ -522,7 +522,7 @@ int __init s3c_cpufreq_setboard(struct s3c_cpufreq_board *board)
         /* Copy the board information so that each board can make this
          * initdata. */
 
-        ours = kzalloc(sizeof(struct s3c_cpufreq_board), GFP_KERNEL);
+        ours = kzalloc(sizeof(*ours), GFP_KERNEL);
         if (ours == NULL) {
                 printk(KERN_ERR "%s: no memory\n", __func__);
                 return -ENOMEM;
@@ -615,7 +615,7 @@ static int s3c_cpufreq_build_freq(void)
         size = cpu_cur.info->calc_freqtable(&cpu_cur, NULL, 0);
         size++;
 
-        ftab = kmalloc(sizeof(struct cpufreq_frequency_table) * size, GFP_KERNEL);
+        ftab = kmalloc(sizeof(*ftab) * size, GFP_KERNEL);
         if (!ftab) {
                 printk(KERN_ERR "%s: no memory for tables\n", __func__);
                 return -ENOMEM;
@@ -691,7 +691,7 @@ int __init s3c_plltab_register(struct cpufreq_frequency_table *plls,
         struct cpufreq_frequency_table *vals;
         unsigned int size;
 
-        size = sizeof(struct cpufreq_frequency_table) * (plls_no + 1);
+        size = sizeof(*vals) * (plls_no + 1);
 
         vals = kmalloc(size, GFP_KERNEL);
         if (vals) {
diff --git a/drivers/cpufreq/s3c64xx-cpufreq.c b/drivers/cpufreq/s3c64xx-cpufreq.c
index 13bb4bae64ee..8a72b0c555f8 100644
--- a/drivers/cpufreq/s3c64xx-cpufreq.c
+++ b/drivers/cpufreq/s3c64xx-cpufreq.c
@@ -263,7 +263,6 @@ static int s3c64xx_cpufreq_driver_init(struct cpufreq_policy *policy)
 }
 
 static struct cpufreq_driver s3c64xx_cpufreq_driver = {
-        .owner          = THIS_MODULE,
         .flags          = 0,
         .verify         = s3c64xx_cpufreq_verify_speed,
         .target         = s3c64xx_cpufreq_set_target,
diff --git a/drivers/cpufreq/sc520_freq.c b/drivers/cpufreq/sc520_freq.c
index 77a210975fc4..d6f6c6f4efa7 100644
--- a/drivers/cpufreq/sc520_freq.c
+++ b/drivers/cpufreq/sc520_freq.c
@@ -147,7 +147,6 @@ static struct cpufreq_driver sc520_freq_driver = {
         .init   = sc520_freq_cpu_init,
         .exit   = sc520_freq_cpu_exit,
         .name   = "sc520_freq",
-        .owner  = THIS_MODULE,
         .attr   = sc520_freq_attr,
 };
 
diff --git a/drivers/cpufreq/sh-cpufreq.c b/drivers/cpufreq/sh-cpufreq.c
index 73adb64651e8..ffc6d24b0cfb 100644
--- a/drivers/cpufreq/sh-cpufreq.c
+++ b/drivers/cpufreq/sh-cpufreq.c
@@ -160,7 +160,6 @@ static struct freq_attr *sh_freq_attr[] = {
 };
 
 static struct cpufreq_driver sh_cpufreq_driver = {
-        .owner          = THIS_MODULE,
         .name           = "sh",
         .get            = sh_cpufreq_get,
         .target         = sh_cpufreq_target,
diff --git a/drivers/cpufreq/sparc-us2e-cpufreq.c b/drivers/cpufreq/sparc-us2e-cpufreq.c
index 93061a408773..cf5bc2ca16fa 100644
--- a/drivers/cpufreq/sparc-us2e-cpufreq.c
+++ b/drivers/cpufreq/sparc-us2e-cpufreq.c
@@ -351,12 +351,11 @@ static int __init us2e_freq_init(void)
                 struct cpufreq_driver *driver;
 
                 ret = -ENOMEM;
-                driver = kzalloc(sizeof(struct cpufreq_driver), GFP_KERNEL);
+                driver = kzalloc(sizeof(*driver), GFP_KERNEL);
                 if (!driver)
                         goto err_out;
 
-                us2e_freq_table = kzalloc(
-                        (NR_CPUS * sizeof(struct us2e_freq_percpu_info)),
+                us2e_freq_table = kzalloc((NR_CPUS * sizeof(*us2e_freq_table)),
                         GFP_KERNEL);
                 if (!us2e_freq_table)
                         goto err_out;
@@ -366,7 +365,6 @@ static int __init us2e_freq_init(void)
                 driver->target = us2e_freq_target;
                 driver->get = us2e_freq_get;
                 driver->exit = us2e_freq_cpu_exit;
-                driver->owner = THIS_MODULE,
                 strcpy(driver->name, "UltraSPARC-IIe");
 
                 cpufreq_us2e_driver = driver;
diff --git a/drivers/cpufreq/sparc-us3-cpufreq.c b/drivers/cpufreq/sparc-us3-cpufreq.c
index 880ee293d61e..ac76b489979d 100644
--- a/drivers/cpufreq/sparc-us3-cpufreq.c
+++ b/drivers/cpufreq/sparc-us3-cpufreq.c
@@ -212,12 +212,11 @@ static int __init us3_freq_init(void)
                 struct cpufreq_driver *driver;
 
                 ret = -ENOMEM;
-                driver = kzalloc(sizeof(struct cpufreq_driver), GFP_KERNEL);
+                driver = kzalloc(sizeof(*driver), GFP_KERNEL);
                 if (!driver)
                         goto err_out;
 
-                us3_freq_table = kzalloc(
-                        (NR_CPUS * sizeof(struct us3_freq_percpu_info)),
+                us3_freq_table = kzalloc((NR_CPUS * sizeof(*us3_freq_table)),
                         GFP_KERNEL);
                 if (!us3_freq_table)
                         goto err_out;
@@ -227,7 +226,6 @@ static int __init us3_freq_init(void)
                 driver->target = us3_freq_target;
                 driver->get = us3_freq_get;
                 driver->exit = us3_freq_cpu_exit;
-                driver->owner = THIS_MODULE,
                 strcpy(driver->name, "UltraSPARC-III");
 
                 cpufreq_us3_driver = driver;
diff --git a/drivers/cpufreq/spear-cpufreq.c b/drivers/cpufreq/spear-cpufreq.c
index c3efa7f2a908..19e364fa5955 100644
--- a/drivers/cpufreq/spear-cpufreq.c
+++ b/drivers/cpufreq/spear-cpufreq.c
@@ -18,7 +18,7 @@
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 
@@ -223,7 +223,7 @@ static int spear_cpufreq_driver_init(void)
         const __be32 *val;
         int cnt, i, ret;
 
-        np = of_find_node_by_path("/cpus/cpu@0");
+        np = of_cpu_device_node_get(0);
         if (!np) {
                 pr_err("No cpu node found");
                 return -ENODEV;
diff --git a/drivers/cpufreq/speedstep-centrino.c b/drivers/cpufreq/speedstep-centrino.c
index 0915e712fbdc..f897d5105842 100644
--- a/drivers/cpufreq/speedstep-centrino.c
+++ b/drivers/cpufreq/speedstep-centrino.c
@@ -575,7 +575,6 @@ static struct cpufreq_driver centrino_driver = {
         .target         = centrino_target,
         .get            = get_cur_freq,
         .attr           = centrino_attr,
-        .owner          = THIS_MODULE,
 };
 
 /*
diff --git a/drivers/cpufreq/speedstep-ich.c b/drivers/cpufreq/speedstep-ich.c
index e2e5aa971452..5355abb69afc 100644
--- a/drivers/cpufreq/speedstep-ich.c
+++ b/drivers/cpufreq/speedstep-ich.c
@@ -378,7 +378,6 @@ static struct cpufreq_driver speedstep_driver = {
         .init   = speedstep_cpu_init,
         .exit   = speedstep_cpu_exit,
         .get    = speedstep_get,
-        .owner  = THIS_MODULE,
         .attr   = speedstep_attr,
 };
 
diff --git a/drivers/cpufreq/speedstep-smi.c b/drivers/cpufreq/speedstep-smi.c
index f5a6b70ee6c0..abfba4f731eb 100644
--- a/drivers/cpufreq/speedstep-smi.c
+++ b/drivers/cpufreq/speedstep-smi.c
@@ -375,7 +375,6 @@ static struct cpufreq_driver speedstep_driver = {
         .exit           = speedstep_cpu_exit,
         .get            = speedstep_get,
         .resume         = speedstep_resume,
-        .owner          = THIS_MODULE,
         .attr           = speedstep_attr,
 };
 
diff --git a/drivers/cpufreq/tegra-cpufreq.c b/drivers/cpufreq/tegra-cpufreq.c
index cd66b85d927c..a7b876fdc1d8 100644
--- a/drivers/cpufreq/tegra-cpufreq.c
+++ b/drivers/cpufreq/tegra-cpufreq.c
@@ -255,7 +255,7 @@ static struct cpufreq_driver tegra_cpufreq_driver = {
 
 static int __init tegra_cpufreq_init(void)
 {
-        cpu_clk = clk_get_sys(NULL, "cpu");
+        cpu_clk = clk_get_sys(NULL, "cclk");
         if (IS_ERR(cpu_clk))
                 return PTR_ERR(cpu_clk);
 
@@ -263,7 +263,7 @@ static int __init tegra_cpufreq_init(void)
         if (IS_ERR(pll_x_clk))
                 return PTR_ERR(pll_x_clk);
 
-        pll_p_clk = clk_get_sys(NULL, "pll_p_cclk");
+        pll_p_clk = clk_get_sys(NULL, "pll_p");
         if (IS_ERR(pll_p_clk))
                 return PTR_ERR(pll_p_clk);
 
diff --git a/drivers/cpufreq/unicore2-cpufreq.c b/drivers/cpufreq/unicore2-cpufreq.c
index 12fc904d7dab..b225f04d8ae5 100644
--- a/drivers/cpufreq/unicore2-cpufreq.c
+++ b/drivers/cpufreq/unicore2-cpufreq.c
@@ -24,7 +24,7 @@ static struct cpufreq_driver ucv2_driver;
 /* make sure that only the "userspace" governor is run
  * -- anything else wouldn't make sense on this platform, anyway.
  */
-int ucv2_verify_speed(struct cpufreq_policy *policy)
+static int ucv2_verify_speed(struct cpufreq_policy *policy)
 {
         if (policy->cpu)
                 return -EINVAL;
diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
index 0e2cd5cab4d0..b3fb81d7cf04 100644
--- a/drivers/cpuidle/Kconfig
+++ b/drivers/cpuidle/Kconfig
@@ -1,5 +1,6 @@
+menu "CPU Idle"
 
-menuconfig CPU_IDLE
+config CPU_IDLE
         bool "CPU idle PM support"
         default y if ACPI || PPC_PSERIES
         select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE)
@@ -29,20 +30,13 @@ config CPU_IDLE_GOV_MENU
         bool "Menu governor (for tickless system)"
         default y
 
-config CPU_IDLE_CALXEDA
-        bool "CPU Idle Driver for Calxeda processors"
-        depends on ARCH_HIGHBANK
-        select ARM_CPU_SUSPEND
-        help
-          Select this to enable cpuidle on Calxeda processors.
-
-config CPU_IDLE_ZYNQ
-        bool "CPU Idle Driver for Xilinx Zynq processors"
-        depends on ARCH_ZYNQ
-        help
-          Select this to enable cpuidle on Xilinx Zynq processors.
+menu "ARM CPU Idle Drivers"
+depends on ARM
+source "drivers/cpuidle/Kconfig.arm"
+endmenu
 
 endif
 
 config ARCH_NEEDS_CPU_IDLE_COUPLED
         def_bool n
+endmenu
diff --git a/drivers/cpuidle/Kconfig.arm b/drivers/cpuidle/Kconfig.arm
new file mode 100644
index 000000000000..b3302193c15a
--- /dev/null
+++ b/drivers/cpuidle/Kconfig.arm
@@ -0,0 +1,29 @@
+#
+# ARM CPU Idle drivers
+#
+
+config ARM_HIGHBANK_CPUIDLE
+        bool "CPU Idle Driver for Calxeda processors"
+        depends on ARCH_HIGHBANK
+        select ARM_CPU_SUSPEND
+        help
+          Select this to enable cpuidle on Calxeda processors.
+
+config ARM_KIRKWOOD_CPUIDLE
+        bool "CPU Idle Driver for Marvell Kirkwood SoCs"
+        depends on ARCH_KIRKWOOD
+        help
+          This adds the CPU Idle driver for Marvell Kirkwood SoCs.
+
+config ARM_ZYNQ_CPUIDLE
+        bool "CPU Idle Driver for Xilinx Zynq processors"
+        depends on ARCH_ZYNQ
+        help
+          Select this to enable cpuidle on Xilinx Zynq processors.
+
+config ARM_U8500_CPUIDLE
+        bool "Cpu Idle Driver for the ST-E u8500 processors"
+        depends on ARCH_U8500
+        help
+          Select this to enable cpuidle for ST-E u8500 processors
+
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
index 8767a7b3eb91..0b9d200c7e45 100644
--- a/drivers/cpuidle/Makefile
+++ b/drivers/cpuidle/Makefile
@@ -5,6 +5,9 @@
 obj-y += cpuidle.o driver.o governor.o sysfs.o governors/
 obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
 
-obj-$(CONFIG_CPU_IDLE_CALXEDA) += cpuidle-calxeda.o
-obj-$(CONFIG_ARCH_KIRKWOOD) += cpuidle-kirkwood.o
-obj-$(CONFIG_CPU_IDLE_ZYNQ) += cpuidle-zynq.o
+##################################################################################
+# ARM SoC drivers
+obj-$(CONFIG_ARM_HIGHBANK_CPUIDLE)      += cpuidle-calxeda.o
+obj-$(CONFIG_ARM_KIRKWOOD_CPUIDLE)      += cpuidle-kirkwood.o
+obj-$(CONFIG_ARM_ZYNQ_CPUIDLE)          += cpuidle-zynq.o
+obj-$(CONFIG_ARM_U8500_CPUIDLE)         += cpuidle-ux500.o
diff --git a/drivers/cpuidle/coupled.c b/drivers/cpuidle/coupled.c
index 2a297f86dbad..f8a86364c6b6 100644
--- a/drivers/cpuidle/coupled.c
+++ b/drivers/cpuidle/coupled.c
@@ -106,6 +106,7 @@ struct cpuidle_coupled {
         cpumask_t coupled_cpus;
         int requested_state[NR_CPUS];
         atomic_t ready_waiting_counts;
+        atomic_t abort_barrier;
         int online_count;
         int refcnt;
         int prevent;
@@ -122,12 +123,19 @@ static DEFINE_MUTEX(cpuidle_coupled_lock);
 static DEFINE_PER_CPU(struct call_single_data, cpuidle_coupled_poke_cb);
 
 /*
- * The cpuidle_coupled_poked_mask mask is used to avoid calling
+ * The cpuidle_coupled_poke_pending mask is used to avoid calling
  * __smp_call_function_single with the per cpu call_single_data struct already
  * in use.  This prevents a deadlock where two cpus are waiting for each others
  * call_single_data struct to be available
  */
-static cpumask_t cpuidle_coupled_poked_mask;
+static cpumask_t cpuidle_coupled_poke_pending;
+
+/*
+ * The cpuidle_coupled_poked mask is used to ensure that each cpu has been poked
+ * once to minimize entering the ready loop with a poke pending, which would
+ * require aborting and retrying.
+ */
+static cpumask_t cpuidle_coupled_poked;
 
 /**
  * cpuidle_coupled_parallel_barrier - synchronize all online coupled cpus
@@ -291,10 +299,11 @@ static inline int cpuidle_coupled_get_state(struct cpuidle_device *dev,
         return state;
 }
 
-static void cpuidle_coupled_poked(void *info)
+static void cpuidle_coupled_handle_poke(void *info)
 {
         int cpu = (unsigned long)info;
-        cpumask_clear_cpu(cpu, &cpuidle_coupled_poked_mask);
+        cpumask_set_cpu(cpu, &cpuidle_coupled_poked);
+        cpumask_clear_cpu(cpu, &cpuidle_coupled_poke_pending);
 }
 
 /**
@@ -313,7 +322,7 @@ static void cpuidle_coupled_poke(int cpu)
 {
         struct call_single_data *csd = &per_cpu(cpuidle_coupled_poke_cb, cpu);
 
-        if (!cpumask_test_and_set_cpu(cpu, &cpuidle_coupled_poked_mask))
+        if (!cpumask_test_and_set_cpu(cpu, &cpuidle_coupled_poke_pending))
                 __smp_call_function_single(cpu, csd, 0);
 }
 
@@ -340,30 +349,19 @@ static void cpuidle_coupled_poke_others(int this_cpu,
  * @coupled: the struct coupled that contains the current cpu
  * @next_state: the index in drv->states of the requested state for this cpu
  *
- * Updates the requested idle state for the specified cpuidle device,
- * poking all coupled cpus out of idle if necessary to let them see the new
- * state.
+ * Updates the requested idle state for the specified cpuidle device.
+ * Returns the number of waiting cpus.
  */
-static void cpuidle_coupled_set_waiting(int cpu,
+static int cpuidle_coupled_set_waiting(int cpu,
                 struct cpuidle_coupled *coupled, int next_state)
 {
-        int w;
-
         coupled->requested_state[cpu] = next_state;
 
         /*
-         * If this is the last cpu to enter the waiting state, poke
-         * all the other cpus out of their waiting state so they can
-         * enter a deeper state.  This can race with one of the cpus
-         * exiting the waiting state due to an interrupt and
-         * decrementing waiting_count, see comment below.
-         *
          * The atomic_inc_return provides a write barrier to order the write
          * to requested_state with the later write that increments ready_count.
          */
-        w = atomic_inc_return(&coupled->ready_waiting_counts) & WAITING_MASK;
-        if (w == coupled->online_count)
-                cpuidle_coupled_poke_others(cpu, coupled);
+        return atomic_inc_return(&coupled->ready_waiting_counts) & WAITING_MASK;
 }
 
 /**
@@ -410,19 +408,33 @@ static void cpuidle_coupled_set_done(int cpu, struct cpuidle_coupled *coupled)
  * been processed and the poke bit has been cleared.
  *
  * Other interrupts may also be processed while interrupts are enabled, so
- * need_resched() must be tested after turning interrupts off again to make sure
+ * need_resched() must be tested after this function returns to make sure
  * the interrupt didn't schedule work that should take the cpu out of idle.
  *
- * Returns 0 if need_resched was false, -EINTR if need_resched was true.
+ * Returns 0 if no poke was pending, 1 if a poke was cleared.
  */
 static int cpuidle_coupled_clear_pokes(int cpu)
 {
+        if (!cpumask_test_cpu(cpu, &cpuidle_coupled_poke_pending))
+                return 0;
+
         local_irq_enable();
-        while (cpumask_test_cpu(cpu, &cpuidle_coupled_poked_mask))
+        while (cpumask_test_cpu(cpu, &cpuidle_coupled_poke_pending))
                 cpu_relax();
         local_irq_disable();
 
-        return need_resched() ? -EINTR : 0;
+        return 1;
+}
+
+static bool cpuidle_coupled_any_pokes_pending(struct cpuidle_coupled *coupled)
+{
+        cpumask_t cpus;
+        int ret;
+
+        cpumask_and(&cpus, cpu_online_mask, &coupled->coupled_cpus);
+        ret = cpumask_and(&cpus, &cpuidle_coupled_poke_pending, &cpus);
+
+        return ret;
 }
 
 /**
@@ -449,31 +461,56 @@ int cpuidle_enter_state_coupled(struct cpuidle_device *dev,
 {
         int entered_state = -1;
         struct cpuidle_coupled *coupled = dev->coupled;
+        int w;
 
         if (!coupled)
                 return -EINVAL;
 
         while (coupled->prevent) {
-                if (cpuidle_coupled_clear_pokes(dev->cpu)) {
+                cpuidle_coupled_clear_pokes(dev->cpu);
+                if (need_resched()) {
                         local_irq_enable();
                         return entered_state;
                 }
                 entered_state = cpuidle_enter_state(dev, drv,
                         dev->safe_state_index);
+                local_irq_disable();
         }
 
         /* Read barrier ensures online_count is read after prevent is cleared */
         smp_rmb();
 
-        cpuidle_coupled_set_waiting(dev->cpu, coupled, next_state);
+reset:
+        cpumask_clear_cpu(dev->cpu, &cpuidle_coupled_poked);
+
+        w = cpuidle_coupled_set_waiting(dev->cpu, coupled, next_state);
+        /*
+         * If this is the last cpu to enter the waiting state, poke
+         * all the other cpus out of their waiting state so they can
+         * enter a deeper state.  This can race with one of the cpus
+         * exiting the waiting state due to an interrupt and
+         * decrementing waiting_count, see comment below.
+         */
+        if (w == coupled->online_count) {
+                cpumask_set_cpu(dev->cpu, &cpuidle_coupled_poked);
+                cpuidle_coupled_poke_others(dev->cpu, coupled);
+        }
 
 retry:
         /*
          * Wait for all coupled cpus to be idle, using the deepest state
-         * allowed for a single cpu.
+         * allowed for a single cpu.  If this was not the poking cpu, wait
+         * for at least one poke before leaving to avoid a race where
+         * two cpus could arrive at the waiting loop at the same time,
+         * but the first of the two to arrive could skip the loop without
+         * processing the pokes from the last to arrive.
          */
-        while (!cpuidle_coupled_cpus_waiting(coupled)) {
-                if (cpuidle_coupled_clear_pokes(dev->cpu)) {
+        while (!cpuidle_coupled_cpus_waiting(coupled) ||
+                        !cpumask_test_cpu(dev->cpu, &cpuidle_coupled_poked)) {
+                if (cpuidle_coupled_clear_pokes(dev->cpu))
+                        continue;
+
+                if (need_resched()) {
                         cpuidle_coupled_set_not_waiting(dev->cpu, coupled);
                         goto out;
                 }
@@ -485,14 +522,22 @@ retry:
 
                 entered_state = cpuidle_enter_state(dev, drv,
                         dev->safe_state_index);
+                local_irq_disable();
         }
 
-        if (cpuidle_coupled_clear_pokes(dev->cpu)) {
+        cpuidle_coupled_clear_pokes(dev->cpu);
+        if (need_resched()) {
                 cpuidle_coupled_set_not_waiting(dev->cpu, coupled);
                 goto out;
         }
 
         /*
+         * Make sure final poke status for this cpu is visible before setting
+         * cpu as ready.
+         */
+        smp_wmb();
+
+        /*
          * All coupled cpus are probably idle.  There is a small chance that
          * one of the other cpus just became active.  Increment the ready count,
          * and spin until all coupled cpus have incremented the counter. Once a
@@ -511,6 +556,28 @@ retry:
                 cpu_relax();
         }
 
+        /*
+         * Make sure read of all cpus ready is done before reading pending pokes
+         */
+        smp_rmb();
+
+        /*
+         * There is a small chance that a cpu left and reentered idle after this
+         * cpu saw that all cpus were waiting.  The cpu that reentered idle will
+         * have sent this cpu a poke, which will still be pending after the
+         * ready loop.  The pending interrupt may be lost by the interrupt
+         * controller when entering the deep idle state.  It's not possible to
+         * clear a pending interrupt without turning interrupts on and handling
+         * it, and it's too late to turn on interrupts here, so reset the
+         * coupled idle state of all cpus and retry.
+         */
+        if (cpuidle_coupled_any_pokes_pending(coupled)) {
+                cpuidle_coupled_set_done(dev->cpu, coupled);
+                /* Wait for all cpus to see the pending pokes */
+                cpuidle_coupled_parallel_barrier(dev, &coupled->abort_barrier);
+                goto reset;
+        }
+
         /* all cpus have acked the coupled state */
         next_state = cpuidle_coupled_get_state(dev, coupled);
 
@@ -596,7 +663,7 @@ have_coupled:
         coupled->refcnt++;
 
         csd = &per_cpu(cpuidle_coupled_poke_cb, dev->cpu);
-        csd->func = cpuidle_coupled_poked;
+        csd->func = cpuidle_coupled_handle_poke;
         csd->info = (void *)(unsigned long)dev->cpu;
 
         return 0;
diff --git a/drivers/cpuidle/cpuidle-calxeda.c b/drivers/cpuidle/cpuidle-calxeda.c
index 0e6e408c0a63..346058479572 100644
--- a/drivers/cpuidle/cpuidle-calxeda.c
+++ b/drivers/cpuidle/cpuidle-calxeda.c
@@ -35,7 +35,7 @@
 #include <asm/cp15.h>
 
 extern void highbank_set_cpu_jump(int cpu, void *jump_addr);
-extern void *scu_base_addr;
+extern void __iomem *scu_base_addr;
 
 static noinline void calxeda_idle_restore(void)
 {
diff --git a/drivers/cpuidle/cpuidle-kirkwood.c b/drivers/cpuidle/cpuidle-kirkwood.c
index 521b0a7fdd89..41ba843251b8 100644
--- a/drivers/cpuidle/cpuidle-kirkwood.c
+++ b/drivers/cpuidle/cpuidle-kirkwood.c
@@ -60,9 +60,6 @@ static int kirkwood_cpuidle_probe(struct platform_device *pdev)
         struct resource *res;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL)
-                return -EINVAL;
-
         ddr_operation_base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(ddr_operation_base))
                 return PTR_ERR(ddr_operation_base);
@@ -70,7 +67,7 @@ static int kirkwood_cpuidle_probe(struct platform_device *pdev)
         return cpuidle_register(&kirkwood_idle_driver, NULL);
 }
 
-int kirkwood_cpuidle_remove(struct platform_device *pdev)
+static int kirkwood_cpuidle_remove(struct platform_device *pdev)
 {
         cpuidle_unregister(&kirkwood_idle_driver);
         return 0;
diff --git a/drivers/cpuidle/cpuidle-ux500.c b/drivers/cpuidle/cpuidle-ux500.c
new file mode 100644
index 000000000000..e0564652af35
--- /dev/null
+++ b/drivers/cpuidle/cpuidle-ux500.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2012 Linaro : Daniel Lezcano <daniel.lezcano@linaro.org> (IBM)
+ *
+ * Based on the work of Rickard Andersson <rickard.andersson@stericsson.com>
+ * and Jonas Aaberg <jonas.aberg@stericsson.com>.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/cpuidle.h>
+#include <linux/spinlock.h>
+#include <linux/atomic.h>
+#include <linux/smp.h>
+#include <linux/mfd/dbx500-prcmu.h>
+#include <linux/platform_data/arm-ux500-pm.h>
+#include <linux/platform_device.h>
+
+#include <asm/cpuidle.h>
+#include <asm/proc-fns.h>
+
+static atomic_t master = ATOMIC_INIT(0);
+static DEFINE_SPINLOCK(master_lock);
+
+static inline int ux500_enter_idle(struct cpuidle_device *dev,
+                                   struct cpuidle_driver *drv, int index)
+{
+        int this_cpu = smp_processor_id();
+        bool recouple = false;
+
+        if (atomic_inc_return(&master) == num_online_cpus()) {
+
+                /* With this lock, we prevent the other cpu to exit and enter
+                 * this function again and become the master */
+                if (!spin_trylock(&master_lock))
+                        goto wfi;
+
+                /* decouple the gic from the A9 cores */
+                if (prcmu_gic_decouple()) {
+                        spin_unlock(&master_lock);
+                        goto out;
+                }
+
+                /* If an error occur, we will have to recouple the gic
+                 * manually */
+                recouple = true;
+
+                /* At this state, as the gic is decoupled, if the other
+                 * cpu is in WFI, we have the guarantee it won't be wake
+                 * up, so we can safely go to retention */
+                if (!prcmu_is_cpu_in_wfi(this_cpu ? 0 : 1))
+                        goto out;
+
+                /* The prcmu will be in charge of watching the interrupts
+                 * and wake up the cpus */
+                if (prcmu_copy_gic_settings())
+                        goto out;
+
+                /* Check in the meantime an interrupt did
+                 * not occur on the gic ... */
+                if (prcmu_gic_pending_irq())
+                        goto out;
+
+                /* ... and the prcmu */
+                if (prcmu_pending_irq())
+                        goto out;
+
+                /* Go to the retention state, the prcmu will wait for the
+                 * cpu to go WFI and this is what happens after exiting this
+                 * 'master' critical section */
+                if (prcmu_set_power_state(PRCMU_AP_IDLE, true, true))
+                        goto out;
+
+                /* When we switch to retention, the prcmu is in charge
+                 * of recoupling the gic automatically */
+                recouple = false;
+
+                spin_unlock(&master_lock);
+        }
+wfi:
+        cpu_do_idle();
+out:
+        atomic_dec(&master);
+
+        if (recouple) {
+                prcmu_gic_recouple();
+                spin_unlock(&master_lock);
+        }
+
+        return index;
+}
+
+static struct cpuidle_driver ux500_idle_driver = {
+        .name = "ux500_idle",
+        .owner = THIS_MODULE,
+        .states = {
+                ARM_CPUIDLE_WFI_STATE,
+                {
+                        .enter            = ux500_enter_idle,
+                        .exit_latency     = 70,
+                        .target_residency = 260,
+                        .flags            = CPUIDLE_FLAG_TIME_VALID |
+                                            CPUIDLE_FLAG_TIMER_STOP,
+                        .name             = "ApIdle",
+                        .desc             = "ARM Retention",
+                },
+        },
+        .safe_state_index = 0,
+        .state_count = 2,
+};
+
+static int __init dbx500_cpuidle_probe(struct platform_device *pdev)
+{
+        /* Configure wake up reasons */
+        prcmu_enable_wakeups(PRCMU_WAKEUP(ARM) | PRCMU_WAKEUP(RTC) |
+                             PRCMU_WAKEUP(ABB));
+
+        return cpuidle_register(&ux500_idle_driver, NULL);
+}
+
+static struct platform_driver dbx500_cpuidle_plat_driver = {
+        .driver = {
+                .name = "cpuidle-dbx500",
+                .owner = THIS_MODULE,
+        },
+        .probe = dbx500_cpuidle_probe,
+};
+
+module_platform_driver(dbx500_cpuidle_plat_driver);
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index fdc432f18022..d75040ddd2b3 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -42,8 +42,6 @@ void disable_cpuidle(void)
         off = 1;
 }
 
-static int __cpuidle_register_device(struct cpuidle_device *dev);
-
 /**
  * cpuidle_play_dead - cpu off-lining
  *
@@ -278,7 +276,7 @@ static void poll_idle_init(struct cpuidle_driver *drv) {}
  */
 int cpuidle_enable_device(struct cpuidle_device *dev)
 {
-        int ret, i;
+        int ret;
         struct cpuidle_driver *drv;
 
         if (!dev)
@@ -292,15 +290,12 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
         if (!drv || !cpuidle_curr_governor)
                 return -EIO;
 
+        if (!dev->registered)
+                return -EINVAL;
+
         if (!dev->state_count)
                 dev->state_count = drv->state_count;
 
-        if (dev->registered == 0) {
-                ret = __cpuidle_register_device(dev);
-                if (ret)
-                        return ret;
-        }
-
         poll_idle_init(drv);
 
         ret = cpuidle_add_device_sysfs(dev);
@@ -311,12 +306,6 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
             (ret = cpuidle_curr_governor->enable(drv, dev)))
                 goto fail_sysfs;
 
-        for (i = 0; i < dev->state_count; i++) {
-                dev->states_usage[i].usage = 0;
-                dev->states_usage[i].time = 0;
-        }
-        dev->last_residency = 0;
-
         smp_wmb();
 
         dev->enabled = 1;
@@ -360,6 +349,23 @@ void cpuidle_disable_device(struct cpuidle_device *dev)
 
 EXPORT_SYMBOL_GPL(cpuidle_disable_device);
 
+static void __cpuidle_unregister_device(struct cpuidle_device *dev)
+{
+        struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
+
+        list_del(&dev->device_list);
+        per_cpu(cpuidle_devices, dev->cpu) = NULL;
+        module_put(drv->owner);
+}
+
+static int __cpuidle_device_init(struct cpuidle_device *dev)
+{
+        memset(dev->states_usage, 0, sizeof(dev->states_usage));
+        dev->last_residency = 0;
+
+        return 0;
+}
+
 /**
  * __cpuidle_register_device - internal register function called before register
  * and enable routines
@@ -377,24 +383,15 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
 
         per_cpu(cpuidle_devices, dev->cpu) = dev;
         list_add(&dev->device_list, &cpuidle_detected_devices);
-        ret = cpuidle_add_sysfs(dev);
-        if (ret)
-                goto err_sysfs;
 
         ret = cpuidle_coupled_register_device(dev);
-        if (ret)
-                goto err_coupled;
+        if (ret) {
+                __cpuidle_unregister_device(dev);
+                return ret;
+        }
 
         dev->registered = 1;
         return 0;
-
-err_coupled:
-        cpuidle_remove_sysfs(dev);
-err_sysfs:
-        list_del(&dev->device_list);
-        per_cpu(cpuidle_devices, dev->cpu) = NULL;
-        module_put(drv->owner);
-        return ret;
 }
 
 /**
@@ -403,25 +400,44 @@ err_sysfs:
  */
 int cpuidle_register_device(struct cpuidle_device *dev)
 {
-        int ret;
+        int ret = -EBUSY;
 
         if (!dev)
                 return -EINVAL;
 
         mutex_lock(&cpuidle_lock);
 
-        if ((ret = __cpuidle_register_device(dev))) {
-                mutex_unlock(&cpuidle_lock);
-                return ret;
-        }
+        if (dev->registered)
+                goto out_unlock;
+
+        ret = __cpuidle_device_init(dev);
+        if (ret)
+                goto out_unlock;
+
+        ret = __cpuidle_register_device(dev);
+        if (ret)
+                goto out_unlock;
+
+        ret = cpuidle_add_sysfs(dev);
+        if (ret)
+                goto out_unregister;
+
+        ret = cpuidle_enable_device(dev);
+        if (ret)
+                goto out_sysfs;
 
-        cpuidle_enable_device(dev);
         cpuidle_install_idle_handler();
 
+out_unlock:
         mutex_unlock(&cpuidle_lock);
 
-        return 0;
+        return ret;
 
+out_sysfs:
+        cpuidle_remove_sysfs(dev);
+out_unregister:
+        __cpuidle_unregister_device(dev);
+        goto out_unlock;
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_register_device);
@@ -432,8 +448,6 @@ EXPORT_SYMBOL_GPL(cpuidle_register_device);
  */
 void cpuidle_unregister_device(struct cpuidle_device *dev)
 {
-        struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
-
         if (dev->registered == 0)
                 return;
 
@@ -442,14 +456,12 @@ void cpuidle_unregister_device(struct cpuidle_device *dev)
         cpuidle_disable_device(dev);
 
         cpuidle_remove_sysfs(dev);
-        list_del(&dev->device_list);
-        per_cpu(cpuidle_devices, dev->cpu) = NULL;
+
+        __cpuidle_unregister_device(dev);
 
         cpuidle_coupled_unregister_device(dev);
 
         cpuidle_resume_and_unlock();
-
-        module_put(drv->owner);
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_unregister_device);
diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
index 9b784051ec12..9f08e8cce1af 100644
--- a/drivers/cpuidle/governors/ladder.c
+++ b/drivers/cpuidle/governors/ladder.c
@@ -192,14 +192,4 @@ static int __init init_ladder(void)
         return cpuidle_register_governor(&ladder_governor);
 }
 
-/**
- * exit_ladder - exits the governor
- */
-static void __exit exit_ladder(void)
-{
-        cpuidle_unregister_governor(&ladder_governor);
-}
-
-MODULE_LICENSE("GPL");
-module_init(init_ladder);
-module_exit(exit_ladder);
+postcore_initcall(init_ladder);
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index bc580b67a652..cf7f2f0e4ef5 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -21,6 +21,15 @@
 #include <linux/math64.h>
 #include <linux/module.h>
 
+/*
+ * Please note when changing the tuning values:
+ * If (MAX_INTERESTING-1) * RESOLUTION > UINT_MAX, the result of
+ * a scaling operation multiplication may overflow on 32 bit platforms.
+ * In that case, #define RESOLUTION as ULL to get 64 bit result:
+ * #define RESOLUTION 1024ULL
+ *
+ * The default values do not overflow.
+ */
 #define BUCKETS 12
 #define INTERVALS 8
 #define RESOLUTION 1024
@@ -114,11 +123,11 @@ struct menu_device {
         int             needs_update;
 
         unsigned int    expected_us;
-        u64             predicted_us;
+        unsigned int    predicted_us;
         unsigned int    exit_us;
         unsigned int    bucket;
-        u64             correction_factor[BUCKETS];
-        u32             intervals[INTERVALS];
+        unsigned int    correction_factor[BUCKETS];
+        unsigned int    intervals[INTERVALS];
         int             interval_ptr;
 };
 
@@ -199,16 +208,20 @@ static u64 div_round64(u64 dividend, u32 divisor)
  */
 static void get_typical_interval(struct menu_device *data)
 {
-        int i = 0, divisor = 0;
-        uint64_t max = 0, avg = 0, stddev = 0;
-        int64_t thresh = LLONG_MAX; /* Discard outliers above this value. */
+        int i, divisor;
+        unsigned int max, thresh;
+        uint64_t avg, stddev;
+
+        thresh = UINT_MAX; /* Discard outliers above this value */
 
 again:
 
-        /* first calculate average and standard deviation of the past */
-        max = avg = divisor = stddev = 0;
+        /* First calculate the average of past intervals */
+        max = 0;
+        avg = 0;
+        divisor = 0;
         for (i = 0; i < INTERVALS; i++) {
-                int64_t value = data->intervals[i];
+                unsigned int value = data->intervals[i];
                 if (value <= thresh) {
                         avg += value;
                         divisor++;
@@ -218,15 +231,38 @@ again:
         }
         do_div(avg, divisor);
 
+        /* Then try to determine standard deviation */
+        stddev = 0;
         for (i = 0; i < INTERVALS; i++) {
-                int64_t value = data->intervals[i];
+                unsigned int value = data->intervals[i];
                 if (value <= thresh) {
                         int64_t diff = value - avg;
                         stddev += diff * diff;
                 }
         }
         do_div(stddev, divisor);
-        stddev = int_sqrt(stddev);
+        /*
+         * The typical interval is obtained when standard deviation is small
+         * or standard deviation is small compared to the average interval.
+         *
+         * int_sqrt() formal parameter type is unsigned long. When the
+         * greatest difference to an outlier exceeds ~65 ms * sqrt(divisor)
+         * the resulting squared standard deviation exceeds the input domain
+         * of int_sqrt on platforms where unsigned long is 32 bits in size.
+         * In such case reject the candidate average.
+         *
+         * Use this result only if there is no timer to wake us up sooner.
+         */
+        if (likely(stddev <= ULONG_MAX)) {
+                stddev = int_sqrt(stddev);
+                if (((avg > stddev * 6) && (divisor * 4 >= INTERVALS * 3))
+                                                        || stddev <= 20) {
+                        if (data->expected_us > avg)
+                                data->predicted_us = avg;
+                        return;
+                }
+        }
+
         /*
          * If we have outliers to the upside in our distribution, discard
          * those by setting the threshold to exclude these outliers, then
@@ -235,20 +271,12 @@ again:
          *
          * This can deal with workloads that have long pauses interspersed
          * with sporadic activity with a bunch of short pauses.
-         *
-         * The typical interval is obtained when standard deviation is small
-         * or standard deviation is small compared to the average interval.
          */
-        if (((avg > stddev * 6) && (divisor * 4 >= INTERVALS * 3))
-                                                        || stddev <= 20) {
-                data->predicted_us = avg;
+        if ((divisor * 4) <= INTERVALS * 3)
                 return;
 
-        } else if ((divisor * 4) > INTERVALS * 3) {
-                /* Exclude the max interval */
-                thresh = max - 1;
-                goto again;
-        }
+        thresh = max - 1;
+        goto again;
 }
 
 /**
@@ -293,8 +321,13 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
         if (data->correction_factor[data->bucket] == 0)
                 data->correction_factor[data->bucket] = RESOLUTION * DECAY;
 
-        /* Make sure to round up for half microseconds */
-        data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket],
+        /*
+         * Force the result of multiplication to be 64 bits even if both
+         * operands are 32 bits.
+         * Make sure to round up for half microseconds.
+         */
+        data->predicted_us = div_round64((uint64_t)data->expected_us *
+                                         data->correction_factor[data->bucket],
                                          RESOLUTION * DECAY);
 
         get_typical_interval(data);
@@ -360,7 +393,7 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
         unsigned int last_idle_us = cpuidle_get_last_residency(dev);
         struct cpuidle_state *target = &drv->states[last_idx];
         unsigned int measured_us;
-        u64 new_factor;
+        unsigned int new_factor;
 
         /*
          * Ugh, this idle state doesn't support residency measurements, so we
@@ -381,10 +414,9 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
                 measured_us -= data->exit_us;
 
 
-        /* update our correction ratio */
-
-        new_factor = data->correction_factor[data->bucket]
-                        * (DECAY - 1) / DECAY;
+        /* Update our correction ratio */
+        new_factor = data->correction_factor[data->bucket];
+        new_factor -= new_factor / DECAY;
 
         if (data->expected_us > 0 && measured_us < MAX_INTERESTING)
                 new_factor += RESOLUTION * measured_us / data->expected_us;
@@ -397,9 +429,11 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
 
         /*
          * We don't want 0 as factor; we always want at least
-         * a tiny bit of estimated time.
+         * a tiny bit of estimated time. Fortunately, due to rounding,
+         * new_factor will stay nonzero regardless of measured_us values
+         * and the compiler can eliminate this test as long as DECAY > 1.
          */
-        if (new_factor == 0)
+        if (DECAY == 1 && unlikely(new_factor == 0))
                 new_factor = 1;
 
         data->correction_factor[data->bucket] = new_factor;
@@ -442,14 +476,4 @@ static int __init init_menu(void)
         return cpuidle_register_governor(&menu_governor);
 }
 
-/**
- * exit_menu - exits the governor
- */
-static void __exit exit_menu(void)
-{
-        cpuidle_unregister_governor(&menu_governor);
-}
-
-MODULE_LICENSE("GPL");
-module_init(init_menu);
-module_exit(exit_menu);
+postcore_initcall(init_menu);
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 428754af6236..8739cc05228c 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -11,8 +11,10 @@
 #include <linux/sysfs.h>
 #include <linux/slab.h>
 #include <linux/cpu.h>
+#include <linux/completion.h>
 #include <linux/capability.h>
 #include <linux/device.h>
+#include <linux/kobject.h>
 
 #include "cpuidle.h"
 
@@ -33,7 +35,8 @@ static ssize_t show_available_governors(struct device *dev,
 
         mutex_lock(&cpuidle_lock);
         list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
-                if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
+                if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
+                                    CPUIDLE_NAME_LEN - 2))
                         goto out;
                 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
         }
@@ -166,13 +169,28 @@ struct cpuidle_attr {
 #define define_one_rw(_name, show, store) \
         static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
 
-#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
 #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
-static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
+
+struct cpuidle_device_kobj {
+        struct cpuidle_device *dev;
+        struct completion kobj_unregister;
+        struct kobject kobj;
+};
+
+static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
+{
+        struct cpuidle_device_kobj *kdev =
+                container_of(kobj, struct cpuidle_device_kobj, kobj);
+
+        return kdev->dev;
+}
+
+static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
+                            char *buf)
 {
         int ret = -EIO;
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
-        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+        struct cpuidle_device *dev = to_cpuidle_device(kobj);
+        struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
 
         if (cattr->show) {
                 mutex_lock(&cpuidle_lock);
@@ -182,12 +200,12 @@ static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char
         return ret;
 }
 
-static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
-                     const char * buf, size_t count)
+static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
+                             const char *buf, size_t count)
 {
         int ret = -EIO;
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
-        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+        struct cpuidle_device *dev = to_cpuidle_device(kobj);
+        struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
 
         if (cattr->store) {
                 mutex_lock(&cpuidle_lock);
@@ -204,9 +222,10 @@ static const struct sysfs_ops cpuidle_sysfs_ops = {
 
 static void cpuidle_sysfs_release(struct kobject *kobj)
 {
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+        struct cpuidle_device_kobj *kdev =
+                container_of(kobj, struct cpuidle_device_kobj, kobj);
 
-        complete(&dev->kobj_unregister);
+        complete(&kdev->kobj_unregister);
 }
 
 static struct kobj_type ktype_cpuidle = {
@@ -237,8 +256,8 @@ static ssize_t show_state_##_name(struct cpuidle_state *state, \
 
 #define define_store_state_ull_function(_name) \
 static ssize_t store_state_##_name(struct cpuidle_state *state, \
-                struct cpuidle_state_usage *state_usage, \
-                const char *buf, size_t size) \
+                                   struct cpuidle_state_usage *state_usage, \
+                                   const char *buf, size_t size)        \
 { \
         unsigned long long value; \
         int err; \
@@ -256,14 +275,16 @@ static ssize_t store_state_##_name(struct cpuidle_state *state, \
 
 #define define_show_state_ull_function(_name) \
 static ssize_t show_state_##_name(struct cpuidle_state *state, \
-                        struct cpuidle_state_usage *state_usage, char *buf) \
+                                  struct cpuidle_state_usage *state_usage, \
+                                  char *buf)                            \
 { \
         return sprintf(buf, "%llu\n", state_usage->_name);\
 }
 
 #define define_show_state_str_function(_name) \
 static ssize_t show_state_##_name(struct cpuidle_state *state, \
-                        struct cpuidle_state_usage *state_usage, char *buf) \
+                                  struct cpuidle_state_usage *state_usage, \
+                                  char *buf)                            \
 { \
         if (state->_name[0] == '\0')\
                 return sprintf(buf, "<null>\n");\
@@ -309,8 +330,9 @@ struct cpuidle_state_kobj {
 #define kobj_to_state(k) (kobj_to_state_obj(k)->state)
 #define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
 #define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
-static ssize_t cpuidle_state_show(struct kobject * kobj,
-        struct attribute * attr ,char * buf)
+
+static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
+                                  char * buf)
 {
         int ret = -EIO;
         struct cpuidle_state *state = kobj_to_state(kobj);
@@ -323,8 +345,8 @@ static ssize_t cpuidle_state_show(struct kobject * kobj,
         return ret;
 }
 
-static ssize_t cpuidle_state_store(struct kobject *kobj,
-        struct attribute *attr, const char *buf, size_t size)
+static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
+                                   const char *buf, size_t size)
 {
         int ret = -EIO;
         struct cpuidle_state *state = kobj_to_state(kobj);
@@ -371,6 +393,7 @@ static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
 {
         int i, ret = -ENOMEM;
         struct cpuidle_state_kobj *kobj;
+        struct cpuidle_device_kobj *kdev = device->kobj_dev;
         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
 
         /* state statistics */
@@ -383,7 +406,7 @@ static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
                 init_completion(&kobj->kobj_unregister);
 
                 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
-                                           &device->kobj, "state%d", i);
+                                           &kdev->kobj, "state%d", i);
                 if (ret) {
                         kfree(kobj);
                         goto error_state;
@@ -449,8 +472,8 @@ static void cpuidle_driver_sysfs_release(struct kobject *kobj)
         complete(&driver_kobj->kobj_unregister);
 }
 
-static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute * attr,
-                                   char * buf)
+static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
+                                   char *buf)
 {
         int ret = -EIO;
         struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
@@ -500,6 +523,7 @@ static struct kobj_type ktype_driver_cpuidle = {
 static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
 {
         struct cpuidle_driver_kobj *kdrv;
+        struct cpuidle_device_kobj *kdev = dev->kobj_dev;
         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
         int ret;
 
@@ -511,7 +535,7 @@ static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
         init_completion(&kdrv->kobj_unregister);
 
         ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
-                                   &dev->kobj, "driver");
+                                   &kdev->kobj, "driver");
         if (ret) {
                 kfree(kdrv);
                 return ret;
@@ -580,16 +604,28 @@ void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
  */
 int cpuidle_add_sysfs(struct cpuidle_device *dev)
 {
+        struct cpuidle_device_kobj *kdev;
         struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
         int error;
 
-        init_completion(&dev->kobj_unregister);
+        kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
+        if (!kdev)
+                return -ENOMEM;
+        kdev->dev = dev;
+        dev->kobj_dev = kdev;
 
-        error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
-                                     "cpuidle");
-        if (!error)
-                kobject_uevent(&dev->kobj, KOBJ_ADD);
-        return error;
+        init_completion(&kdev->kobj_unregister);
+
+        error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
+                                   "cpuidle");
+        if (error) {
+                kfree(kdev);
+                return error;
+        }
+
+        kobject_uevent(&kdev->kobj, KOBJ_ADD);
+
+        return 0;
 }
 
 /**
@@ -598,6 +634,9 @@ int cpuidle_add_sysfs(struct cpuidle_device *dev)
  */
 void cpuidle_remove_sysfs(struct cpuidle_device *dev)
 {
-        kobject_put(&dev->kobj);
-        wait_for_completion(&dev->kobj_unregister);
+        struct cpuidle_device_kobj *kdev = dev->kobj_dev;
+
+        kobject_put(&kdev->kobj);
+        wait_for_completion(&kdev->kobj_unregister);
+        kfree(kdev);
 }
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index f1a6796b165c..140c8ef50529 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -520,11 +520,12 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
         ide_port_for_each_present_dev(i, drive, hwif) {
                 if (drive->acpidata->obj_handle)
                         acpi_bus_set_power(drive->acpidata->obj_handle,
-                                           on ? ACPI_STATE_D0 : ACPI_STATE_D3);
+                                on ? ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
         }
 
         if (!on)
-                acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D3);
+                acpi_bus_set_power(hwif->acpidata->obj_handle,
+                                   ACPI_STATE_D3_COLD);
 }
 
 /**
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 3c157faee645..0d68eb1a5ec5 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -3094,6 +3094,10 @@ static struct mfd_cell db8500_prcmu_devs[] = {
                 .pdata_size = sizeof(db8500_cpufreq_table),
         },
         {
+                .name = "cpuidle-dbx500",
+                .of_compatible = "stericsson,cpuidle-dbx500",
+        },
+        {
                 .name = "db8500-thermal",
                 .num_resources = ARRAY_SIZE(db8500_thsens_resources),
                 .resources = db8500_thsens_resources,
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 1c3c79c79742..e486e416d5a0 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -18,6 +18,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 #include <linux/ctype.h>
+#include <linux/cpu.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/spinlock.h>
@@ -231,6 +232,100 @@ const void *of_get_property(const struct device_node *np, const char *name,
 }
 EXPORT_SYMBOL(of_get_property);
 
+/*
+ * arch_match_cpu_phys_id - Match the given logical CPU and physical id
+ *
+ * @cpu: logical cpu index of a core/thread
+ * @phys_id: physical identifier of a core/thread
+ *
+ * CPU logical to physical index mapping is architecture specific.
+ * However this __weak function provides a default match of physical
+ * id to logical cpu index. phys_id provided here is usually values read
+ * from the device tree which must match the hardware internal registers.
+ *
+ * Returns true if the physical identifier and the logical cpu index
+ * correspond to the same core/thread, false otherwise.
+ */
+bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
+{
+        return (u32)phys_id == cpu;
+}
+
+/**
+ * Checks if the given "prop_name" property holds the physical id of the
+ * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
+ * NULL, local thread number within the core is returned in it.
+ */
+static bool __of_find_n_match_cpu_property(struct device_node *cpun,
+                        const char *prop_name, int cpu, unsigned int *thread)
+{
+        const __be32 *cell;
+        int ac, prop_len, tid;
+        u64 hwid;
+
+        ac = of_n_addr_cells(cpun);
+        cell = of_get_property(cpun, prop_name, &prop_len);
+        if (!cell)
+                return false;
+        prop_len /= sizeof(*cell);
+        for (tid = 0; tid < prop_len; tid++) {
+                hwid = of_read_number(cell, ac);
+                if (arch_match_cpu_phys_id(cpu, hwid)) {
+                        if (thread)
+                                *thread = tid;
+                        return true;
+                }
+                cell += ac;
+        }
+        return false;
+}
+
+/**
+ * of_get_cpu_node - Get device node associated with the given logical CPU
+ *
+ * @cpu: CPU number(logical index) for which device node is required
+ * @thread: if not NULL, local thread number within the physical core is
+ *          returned
+ *
+ * The main purpose of this function is to retrieve the device node for the
+ * given logical CPU index. It should be used to initialize the of_node in
+ * cpu device. Once of_node in cpu device is populated, all the further
+ * references can use that instead.
+ *
+ * CPU logical to physical index mapping is architecture specific and is built
+ * before booting secondary cores. This function uses arch_match_cpu_phys_id
+ * which can be overridden by architecture specific implementation.
+ *
+ * Returns a node pointer for the logical cpu if found, else NULL.
+ */
+struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
+{
+        struct device_node *cpun, *cpus;
+
+        cpus = of_find_node_by_path("/cpus");
+        if (!cpus) {
+                pr_warn("Missing cpus node, bailing out\n");
+                return NULL;
+        }
+
+        for_each_child_of_node(cpus, cpun) {
+                if (of_node_cmp(cpun->type, "cpu"))
+                        continue;
+                /* Check for non-standard "ibm,ppc-interrupt-server#s" property
+                 * for thread ids on PowerPC. If it doesn't exist fallback to
+                 * standard "reg" property.
+                 */
+                if (IS_ENABLED(CONFIG_PPC) &&
+                        __of_find_n_match_cpu_property(cpun,
+                                "ibm,ppc-interrupt-server#s", cpu, thread))
+                        return cpun;
+                if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
+                        return cpun;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(of_get_cpu_node);
+
 /** Checks if the given "compat" string matches one of the strings in
  * the device's "compatible" property
  */
diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index 6fdd49c6f0b9..f4e028924667 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -49,6 +49,7 @@
 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
+struct acpiphp_context;
 struct acpiphp_bridge;
 struct acpiphp_slot;
 
@@ -59,6 +60,7 @@ struct slot {
         struct hotplug_slot     *hotplug_slot;
         struct acpiphp_slot     *acpi_slot;
         struct hotplug_slot_info info;
+        unsigned int sun;       /* ACPI _SUN (Slot User Number) value */
 };
 
 static inline const char *slot_name(struct slot *slot)
@@ -75,15 +77,11 @@ struct acpiphp_bridge {
         struct list_head list;
         struct list_head slots;
         struct kref ref;
-        acpi_handle handle;
 
-        /* Ejectable PCI-to-PCI bridge (PCI bridge and PCI function) */
-        struct acpiphp_func *func;
+        struct acpiphp_context *context;
 
         int nr_slots;
 
-        u32 flags;
-
         /* This bus (host bridge) or Secondary bus (PCI-to-PCI bridge) */
         struct pci_bus *pci_bus;
 
@@ -99,15 +97,13 @@ struct acpiphp_bridge {
  */
 struct acpiphp_slot {
         struct list_head node;
-        struct acpiphp_bridge *bridge;  /* parent */
+        struct pci_bus *bus;
         struct list_head funcs;         /* one slot may have different
                                            objects (i.e. for each function) */
         struct slot *slot;
         struct mutex crit_sect;
 
         u8              device;         /* pci device# */
-
-        unsigned long long sun;         /* ACPI _SUN (slot unique number) */
         u32             flags;          /* see below */
 };
 
@@ -119,16 +115,32 @@ struct acpiphp_slot {
  * typically 8 objects per slot (i.e. for each PCI function)
  */
 struct acpiphp_func {
-        struct acpiphp_slot *slot;      /* parent */
+        struct acpiphp_bridge *parent;
+        struct acpiphp_slot *slot;
 
         struct list_head sibling;
-        struct notifier_block nb;
-        acpi_handle     handle;
 
         u8              function;       /* pci function# */
         u32             flags;          /* see below */
 };
 
+struct acpiphp_context {
+        acpi_handle handle;
+        struct acpiphp_func func;
+        struct acpiphp_bridge *bridge;
+        unsigned int refcount;
+};
+
+static inline struct acpiphp_context *func_to_context(struct acpiphp_func *func)
+{
+        return container_of(func, struct acpiphp_context, func);
+}
+
+static inline acpi_handle func_to_handle(struct acpiphp_func *func)
+{
+        return func_to_context(func)->handle;
+}
+
 /*
  * struct acpiphp_attention_info - device specific attention registration
  *
@@ -142,45 +154,32 @@ struct acpiphp_attention_info
         struct module *owner;
 };
 
-/* PCI bus bridge HID */
-#define ACPI_PCI_HOST_HID               "PNP0A03"
-
 /* ACPI _STA method value (ignore bit 4; battery present) */
 #define ACPI_STA_ALL                    (0x0000000f)
 
-/* bridge flags */
-#define BRIDGE_HAS_EJ0          (0x00000001)
-
 /* slot flags */
 
-#define SLOT_POWEREDON          (0x00000001)
-#define SLOT_ENABLED            (0x00000002)
-#define SLOT_MULTIFUNCTION      (0x00000004)
+#define SLOT_ENABLED            (0x00000001)
 
 /* function flags */
 
 #define FUNC_HAS_STA            (0x00000001)
 #define FUNC_HAS_EJ0            (0x00000002)
-#define FUNC_HAS_PS0            (0x00000010)
-#define FUNC_HAS_PS1            (0x00000020)
-#define FUNC_HAS_PS2            (0x00000040)
-#define FUNC_HAS_PS3            (0x00000080)
-#define FUNC_HAS_DCK            (0x00000100)
+#define FUNC_HAS_DCK            (0x00000004)
 
 /* function prototypes */
 
 /* acpiphp_core.c */
 int acpiphp_register_attention(struct acpiphp_attention_info*info);
 int acpiphp_unregister_attention(struct acpiphp_attention_info *info);
-int acpiphp_register_hotplug_slot(struct acpiphp_slot *slot);
+int acpiphp_register_hotplug_slot(struct acpiphp_slot *slot, unsigned int sun);
 void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *slot);
 
 /* acpiphp_glue.c */
 typedef int (*acpiphp_callback)(struct acpiphp_slot *slot, void *data);
 
 int acpiphp_enable_slot(struct acpiphp_slot *slot);
-int acpiphp_disable_slot(struct acpiphp_slot *slot);
-int acpiphp_eject_slot(struct acpiphp_slot *slot);
+int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot);
 u8 acpiphp_get_power_status(struct acpiphp_slot *slot);
 u8 acpiphp_get_attention_status(struct acpiphp_slot *slot);
 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot);
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index ca8127950fcd..bf2203ef1308 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -155,15 +155,11 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
 static int disable_slot(struct hotplug_slot *hotplug_slot)
 {
         struct slot *slot = hotplug_slot->private;
-        int retval;
 
         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 
         /* disable the specified slot */
-        retval = acpiphp_disable_slot(slot->acpi_slot);
-        if (!retval)
-                retval = acpiphp_eject_slot(slot->acpi_slot);
-        return retval;
+        return acpiphp_disable_and_eject_slot(slot->acpi_slot);
 }
 
 
@@ -290,7 +286,8 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
 }
 
 /* callback routine to initialize 'struct slot' for each slot */
-int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
+int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot,
+                                  unsigned int sun)
 {
         struct slot *slot;
         int retval = -ENOMEM;
@@ -317,12 +314,11 @@ int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
         slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
 
         acpiphp_slot->slot = slot;
-        snprintf(name, SLOT_NAME_SIZE, "%llu", slot->acpi_slot->sun);
+        slot->sun = sun;
+        snprintf(name, SLOT_NAME_SIZE, "%u", sun);
 
-        retval = pci_hp_register(slot->hotplug_slot,
-                                        acpiphp_slot->bridge->pci_bus,
-                                        acpiphp_slot->device,
-                                        name);
+        retval = pci_hp_register(slot->hotplug_slot, acpiphp_slot->bus,
+                                 acpiphp_slot->device, name);
         if (retval == -EBUSY)
                 goto error_hpslot;
         if (retval) {
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 59df8575a48c..8054ddcdaed0 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -46,6 +46,7 @@
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
 #include <linux/pci-acpi.h>
+#include <linux/pm_runtime.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
@@ -55,28 +56,82 @@
 
 static LIST_HEAD(bridge_list);
 static DEFINE_MUTEX(bridge_mutex);
+static DEFINE_MUTEX(acpiphp_context_lock);
 
 #define MY_NAME "acpiphp_glue"
 
-static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
+static void handle_hotplug_event(acpi_handle handle, u32 type, void *data);
 static void acpiphp_sanitize_bus(struct pci_bus *bus);
 static void acpiphp_set_hpp_values(struct pci_bus *bus);
-static void hotplug_event_func(acpi_handle handle, u32 type, void *context);
-static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context);
+static void hotplug_event(acpi_handle handle, u32 type, void *data);
 static void free_bridge(struct kref *kref);
 
-/* callback routine to check for the existence of a pci dock device */
-static acpi_status
-is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
+static void acpiphp_context_handler(acpi_handle handle, void *context)
 {
-        int *count = (int *)context;
+        /* Intentionally empty. */
+}
 
-        if (is_dock_device(handle)) {
-                (*count)++;
-                return AE_CTRL_TERMINATE;
-        } else {
-                return AE_OK;
+/**
+ * acpiphp_init_context - Create hotplug context and grab a reference to it.
+ * @handle: ACPI object handle to create the context for.
+ *
+ * Call under acpiphp_context_lock.
+ */
+static struct acpiphp_context *acpiphp_init_context(acpi_handle handle)
+{
+        struct acpiphp_context *context;
+        acpi_status status;
+
+        context = kzalloc(sizeof(*context), GFP_KERNEL);
+        if (!context)
+                return NULL;
+
+        context->handle = handle;
+        context->refcount = 1;
+        status = acpi_attach_data(handle, acpiphp_context_handler, context);
+        if (ACPI_FAILURE(status)) {
+                kfree(context);
+                return NULL;
         }
+        return context;
+}
+
+/**
+ * acpiphp_get_context - Get hotplug context and grab a reference to it.
+ * @handle: ACPI object handle to get the context for.
+ *
+ * Call under acpiphp_context_lock.
+ */
+static struct acpiphp_context *acpiphp_get_context(acpi_handle handle)
+{
+        struct acpiphp_context *context = NULL;
+        acpi_status status;
+        void *data;
+
+        status = acpi_get_data(handle, acpiphp_context_handler, &data);
+        if (ACPI_SUCCESS(status)) {
+                context = data;
+                context->refcount++;
+        }
+        return context;
+}
+
+/**
+ * acpiphp_put_context - Drop a reference to ACPI hotplug context.
+ * @handle: ACPI object handle to put the context for.
+ *
+ * The context object is removed if there are no more references to it.
+ *
+ * Call under acpiphp_context_lock.
+ */
+static void acpiphp_put_context(struct acpiphp_context *context)
+{
+        if (--context->refcount)
+                return;
+
+        WARN_ON(context->bridge);
+        acpi_detach_data(context->handle, acpiphp_context_handler);
+        kfree(context);
 }
 
 static inline void get_bridge(struct acpiphp_bridge *bridge)
@@ -91,25 +146,36 @@ static inline void put_bridge(struct acpiphp_bridge *bridge)
 
 static void free_bridge(struct kref *kref)
 {
+        struct acpiphp_context *context;
         struct acpiphp_bridge *bridge;
         struct acpiphp_slot *slot, *next;
         struct acpiphp_func *func, *tmp;
 
+        mutex_lock(&acpiphp_context_lock);
+
         bridge = container_of(kref, struct acpiphp_bridge, ref);
 
         list_for_each_entry_safe(slot, next, &bridge->slots, node) {
-                list_for_each_entry_safe(func, tmp, &slot->funcs, sibling) {
-                        kfree(func);
-                }
+                list_for_each_entry_safe(func, tmp, &slot->funcs, sibling)
+                        acpiphp_put_context(func_to_context(func));
+
                 kfree(slot);
         }
 
-        /* Release reference acquired by acpiphp_bridge_handle_to_function() */
-        if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func)
-                put_bridge(bridge->func->slot->bridge);
+        context = bridge->context;
+        /* Root bridges will not have hotplug context. */
+        if (context) {
+                /* Release the reference taken by acpiphp_enumerate_slots(). */
+                put_bridge(context->func.parent);
+                context->bridge = NULL;
+                acpiphp_put_context(context);
+        }
+
         put_device(&bridge->pci_bus->dev);
         pci_dev_put(bridge->pci_dev);
         kfree(bridge);
+
+        mutex_unlock(&acpiphp_context_lock);
 }
 
 /*
@@ -119,15 +185,14 @@ static void free_bridge(struct kref *kref)
  * TBD - figure out a way to only call fixups for
  * systems that require them.
  */
-static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
-        void *v)
+static void post_dock_fixups(acpi_handle not_used, u32 event, void *data)
 {
-        struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb);
-        struct pci_bus *bus = func->slot->bridge->pci_bus;
+        struct acpiphp_context *context = data;
+        struct pci_bus *bus = context->func.slot->bus;
         u32 buses;
 
         if (!bus->self)
-                return  NOTIFY_OK;
+                return;
 
         /* fixup bad _DCK function that rewrites
          * secondary bridge on slot
@@ -143,12 +208,12 @@ static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
                         | ((unsigned int)(bus->busn_res.end) << 16);
                 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
         }
-        return NOTIFY_OK;
 }
 
 
 static const struct acpi_dock_ops acpiphp_dock_ops = {
-        .handler = hotplug_event_func,
+        .fixup = post_dock_fixups,
+        .handler = hotplug_event,
 };
 
 /* Check whether the PCI device is managed by native PCIe hotplug driver */
@@ -182,129 +247,118 @@ static bool device_is_managed_by_native_pciehp(struct pci_dev *pdev)
 
 static void acpiphp_dock_init(void *data)
 {
-        struct acpiphp_func *func = data;
+        struct acpiphp_context *context = data;
 
-        get_bridge(func->slot->bridge);
+        get_bridge(context->func.parent);
 }
 
 static void acpiphp_dock_release(void *data)
 {
-        struct acpiphp_func *func = data;
+        struct acpiphp_context *context = data;
 
-        put_bridge(func->slot->bridge);
+        put_bridge(context->func.parent);
 }
 
 /* callback routine to register each ACPI PCI slot object */
-static acpi_status
-register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
+static acpi_status register_slot(acpi_handle handle, u32 lvl, void *data,
+                                 void **rv)
 {
-        struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context;
+        struct acpiphp_bridge *bridge = data;
+        struct acpiphp_context *context;
         struct acpiphp_slot *slot;
         struct acpiphp_func *newfunc;
-        acpi_handle tmp;
         acpi_status status = AE_OK;
-        unsigned long long adr, sun;
-        int device, function, retval, found = 0;
+        unsigned long long adr;
+        int device, function;
         struct pci_bus *pbus = bridge->pci_bus;
-        struct pci_dev *pdev;
+        struct pci_dev *pdev = bridge->pci_dev;
         u32 val;
 
-        if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle))
+        if (pdev && device_is_managed_by_native_pciehp(pdev))
                 return AE_OK;
 
         status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
         if (ACPI_FAILURE(status)) {
-                warn("can't evaluate _ADR (%#x)\n", status);
+                acpi_handle_warn(handle, "can't evaluate _ADR (%#x)\n", status);
                 return AE_OK;
         }
 
         device = (adr >> 16) & 0xffff;
         function = adr & 0xffff;
 
-        pdev = bridge->pci_dev;
-        if (pdev && device_is_managed_by_native_pciehp(pdev))
-                return AE_OK;
-
-        newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
-        if (!newfunc)
-                return AE_NO_MEMORY;
-
-        newfunc->handle = handle;
+        mutex_lock(&acpiphp_context_lock);
+        context = acpiphp_init_context(handle);
+        if (!context) {
+                mutex_unlock(&acpiphp_context_lock);
+                acpi_handle_err(handle, "No hotplug context\n");
+                return AE_NOT_EXIST;
+        }
+        newfunc = &context->func;
         newfunc->function = function;
+        newfunc->parent = bridge;
+        mutex_unlock(&acpiphp_context_lock);
 
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
+        if (acpi_has_method(handle, "_EJ0"))
                 newfunc->flags = FUNC_HAS_EJ0;
 
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
+        if (acpi_has_method(handle, "_STA"))
                 newfunc->flags |= FUNC_HAS_STA;
 
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp)))
-                newfunc->flags |= FUNC_HAS_PS0;
-
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp)))
-                newfunc->flags |= FUNC_HAS_PS3;
-
-        if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp)))
+        if (acpi_has_method(handle, "_DCK"))
                 newfunc->flags |= FUNC_HAS_DCK;
 
-        status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
-        if (ACPI_FAILURE(status)) {
-                /*
-                 * use the count of the number of slots we've found
-                 * for the number of the slot
-                 */
-                sun = bridge->nr_slots+1;
-        }
-
         /* search for objects that share the same slot */
         list_for_each_entry(slot, &bridge->slots, node)
-                if (slot->device == device) {
-                        if (slot->sun != sun)
-                                warn("sibling found, but _SUN doesn't match!\n");
-                        found = 1;
-                        break;
-                }
+                if (slot->device == device)
+                        goto slot_found;
 
-        if (!found) {
-                slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
-                if (!slot) {
-                        kfree(newfunc);
-                        return AE_NO_MEMORY;
-                }
+        slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
+        if (!slot) {
+                status = AE_NO_MEMORY;
+                goto err;
+        }
 
-                slot->bridge = bridge;
-                slot->device = device;
-                slot->sun = sun;
-                INIT_LIST_HEAD(&slot->funcs);
-                mutex_init(&slot->crit_sect);
+        slot->bus = bridge->pci_bus;
+        slot->device = device;
+        INIT_LIST_HEAD(&slot->funcs);
+        mutex_init(&slot->crit_sect);
+
+        list_add_tail(&slot->node, &bridge->slots);
+
+        /* Register slots for ejectable funtions only. */
+        if (acpi_pci_check_ejectable(pbus, handle)  || is_dock_device(handle)) {
+                unsigned long long sun;
+                int retval;
 
-                mutex_lock(&bridge_mutex);
-                list_add_tail(&slot->node, &bridge->slots);
-                mutex_unlock(&bridge_mutex);
                 bridge->nr_slots++;
+                status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
+                if (ACPI_FAILURE(status))
+                        sun = bridge->nr_slots;
 
                 dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
-                    slot->sun, pci_domain_nr(pbus), pbus->number, device);
-                retval = acpiphp_register_hotplug_slot(slot);
+                    sun, pci_domain_nr(pbus), pbus->number, device);
+
+                retval = acpiphp_register_hotplug_slot(slot, sun);
                 if (retval) {
+                        slot->slot = NULL;
+                        bridge->nr_slots--;
                         if (retval == -EBUSY)
                                 warn("Slot %llu already registered by another "
-                                        "hotplug driver\n", slot->sun);
+                                        "hotplug driver\n", sun);
                         else
                                 warn("acpiphp_register_hotplug_slot failed "
                                         "(err code = 0x%x)\n", retval);
-                        goto err_exit;
                 }
+                /* Even if the slot registration fails, we can still use it. */
         }
 
+ slot_found:
         newfunc->slot = slot;
-        mutex_lock(&bridge_mutex);
         list_add_tail(&newfunc->sibling, &slot->funcs);
-        mutex_unlock(&bridge_mutex);
 
         if (pci_bus_read_dev_vendor_id(pbus, PCI_DEVFN(device, function),
                                        &val, 60*1000))
-                slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
+                slot->flags |= SLOT_ENABLED;
 
         if (is_dock_device(handle)) {
                 /* we don't want to call this device's _EJ0
@@ -313,136 +367,46 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
                  */
                 newfunc->flags &= ~FUNC_HAS_EJ0;
                 if (register_hotplug_dock_device(handle,
-                        &acpiphp_dock_ops, newfunc,
+                        &acpiphp_dock_ops, context,
                         acpiphp_dock_init, acpiphp_dock_release))
                         dbg("failed to register dock device\n");
-
-                /* we need to be notified when dock events happen
-                 * outside of the hotplug operation, since we may
-                 * need to do fixups before we can hotplug.
-                 */
-                newfunc->nb.notifier_call = post_dock_fixups;
-                if (register_dock_notifier(&newfunc->nb))
-                        dbg("failed to register a dock notifier");
         }
 
         /* install notify handler */
         if (!(newfunc->flags & FUNC_HAS_DCK)) {
-                status = acpi_install_notify_handler(handle,
-                                             ACPI_SYSTEM_NOTIFY,
-                                             handle_hotplug_event_func,
-                                             newfunc);
-
+                status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
+                                                     handle_hotplug_event,
+                                                     context);
                 if (ACPI_FAILURE(status))
-                        err("failed to register interrupt notify handler\n");
-        } else
-                status = AE_OK;
-
-        return status;
-
- err_exit:
-        bridge->nr_slots--;
-        mutex_lock(&bridge_mutex);
-        list_del(&slot->node);
-        mutex_unlock(&bridge_mutex);
-        kfree(slot);
-        kfree(newfunc);
-
-        return AE_OK;
-}
-
-
-/* see if it's worth looking at this bridge */
-static int detect_ejectable_slots(acpi_handle handle)
-{
-        int found = acpi_pci_detect_ejectable(handle);
-        if (!found) {
-                acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
-                                    is_pci_dock_device, NULL, (void *)&found, NULL);
-        }
-        return found;
-}
-
-/* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */
-static void init_bridge_misc(struct acpiphp_bridge *bridge)
-{
-        acpi_status status;
-
-        /* must be added to the list prior to calling register_slot */
-        mutex_lock(&bridge_mutex);
-        list_add(&bridge->list, &bridge_list);
-        mutex_unlock(&bridge_mutex);
-
-        /* register all slot objects under this bridge */
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1,
-                                     register_slot, NULL, bridge, NULL);
-        if (ACPI_FAILURE(status)) {
-                mutex_lock(&bridge_mutex);
-                list_del(&bridge->list);
-                mutex_unlock(&bridge_mutex);
-                return;
+                        acpi_handle_err(handle,
+                                        "failed to install notify handler\n");
         }
 
-        /* install notify handler for P2P bridges */
-        if (!pci_is_root_bus(bridge->pci_bus)) {
-                if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
-                        status = acpi_remove_notify_handler(bridge->func->handle,
-                                                ACPI_SYSTEM_NOTIFY,
-                                                handle_hotplug_event_func);
-                        if (ACPI_FAILURE(status))
-                                err("failed to remove notify handler\n");
-                }
-                status = acpi_install_notify_handler(bridge->handle,
-                                             ACPI_SYSTEM_NOTIFY,
-                                             handle_hotplug_event_bridge,
-                                             bridge);
-
-                if (ACPI_FAILURE(status)) {
-                        err("failed to register interrupt notify handler\n");
-                }
-        }
-}
-
-
-/* find acpiphp_func from acpiphp_bridge */
-static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle)
-{
-        struct acpiphp_bridge *bridge;
-        struct acpiphp_slot *slot;
-        struct acpiphp_func *func = NULL;
-
-        mutex_lock(&bridge_mutex);
-        list_for_each_entry(bridge, &bridge_list, list) {
-                list_for_each_entry(slot, &bridge->slots, node) {
-                        list_for_each_entry(func, &slot->funcs, sibling) {
-                                if (func->handle == handle) {
-                                        get_bridge(func->slot->bridge);
-                                        mutex_unlock(&bridge_mutex);
-                                        return func;
-                                }
-                        }
-                }
-        }
-        mutex_unlock(&bridge_mutex);
+        return AE_OK;
 
-        return NULL;
+ err:
+        mutex_lock(&acpiphp_context_lock);
+        acpiphp_put_context(context);
+        mutex_unlock(&acpiphp_context_lock);
+        return status;
 }
 
-
 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle)
 {
-        struct acpiphp_bridge *bridge;
-
-        mutex_lock(&bridge_mutex);
-        list_for_each_entry(bridge, &bridge_list, list)
-                if (bridge->handle == handle) {
+        struct acpiphp_context *context;
+        struct acpiphp_bridge *bridge = NULL;
+
+        mutex_lock(&acpiphp_context_lock);
+        context = acpiphp_get_context(handle);
+        if (context) {
+                bridge = context->bridge;
+                if (bridge)
                         get_bridge(bridge);
-                        mutex_unlock(&bridge_mutex);
-                        return bridge;
-                }
-        mutex_unlock(&bridge_mutex);
 
-        return NULL;
+                acpiphp_put_context(context);
+        }
+        mutex_unlock(&acpiphp_context_lock);
+        return bridge;
 }
 
 static void cleanup_bridge(struct acpiphp_bridge *bridge)
@@ -450,40 +414,24 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
         struct acpiphp_slot *slot;
         struct acpiphp_func *func;
         acpi_status status;
-        acpi_handle handle = bridge->handle;
-
-        if (!pci_is_root_bus(bridge->pci_bus)) {
-                status = acpi_remove_notify_handler(handle,
-                                            ACPI_SYSTEM_NOTIFY,
-                                            handle_hotplug_event_bridge);
-                if (ACPI_FAILURE(status))
-                        err("failed to remove notify handler\n");
-        }
-
-        if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
-                status = acpi_install_notify_handler(bridge->func->handle,
-                                                ACPI_SYSTEM_NOTIFY,
-                                                handle_hotplug_event_func,
-                                                bridge->func);
-                if (ACPI_FAILURE(status))
-                        err("failed to install interrupt notify handler\n");
-        }
 
         list_for_each_entry(slot, &bridge->slots, node) {
                 list_for_each_entry(func, &slot->funcs, sibling) {
-                        if (is_dock_device(func->handle)) {
-                                unregister_hotplug_dock_device(func->handle);
-                                unregister_dock_notifier(&func->nb);
-                        }
+                        acpi_handle handle = func_to_handle(func);
+
+                        if (is_dock_device(handle))
+                                unregister_hotplug_dock_device(handle);
+
                         if (!(func->flags & FUNC_HAS_DCK)) {
-                                status = acpi_remove_notify_handler(func->handle,
-                                                ACPI_SYSTEM_NOTIFY,
-                                                handle_hotplug_event_func);
+                                status = acpi_remove_notify_handler(handle,
+                                                        ACPI_SYSTEM_NOTIFY,
+                                                        handle_hotplug_event);
                                 if (ACPI_FAILURE(status))
                                         err("failed to remove notify handler\n");
                         }
                 }
-                acpiphp_unregister_hotplug_slot(slot);
+                if (slot->slot)
+                        acpiphp_unregister_hotplug_slot(slot);
         }
 
         mutex_lock(&bridge_mutex);
@@ -491,71 +439,6 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
         mutex_unlock(&bridge_mutex);
 }
 
-static int power_on_slot(struct acpiphp_slot *slot)
-{
-        acpi_status status;
-        struct acpiphp_func *func;
-        int retval = 0;
-
-        /* if already enabled, just skip */
-        if (slot->flags & SLOT_POWEREDON)
-                goto err_exit;
-
-        list_for_each_entry(func, &slot->funcs, sibling) {
-                if (func->flags & FUNC_HAS_PS0) {
-                        dbg("%s: executing _PS0\n", __func__);
-                        status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL);
-                        if (ACPI_FAILURE(status)) {
-                                warn("%s: _PS0 failed\n", __func__);
-                                retval = -1;
-                                goto err_exit;
-                        } else
-                                break;
-                }
-        }
-
-        /* TBD: evaluate _STA to check if the slot is enabled */
-
-        slot->flags |= SLOT_POWEREDON;
-
- err_exit:
-        return retval;
-}
-
-
-static int power_off_slot(struct acpiphp_slot *slot)
-{
-        acpi_status status;
-        struct acpiphp_func *func;
-
-        int retval = 0;
-
-        /* if already disabled, just skip */
-        if ((slot->flags & SLOT_POWEREDON) == 0)
-                goto err_exit;
-
-        list_for_each_entry(func, &slot->funcs, sibling) {
-                if (func->flags & FUNC_HAS_PS3) {
-                        status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL);
-                        if (ACPI_FAILURE(status)) {
-                                warn("%s: _PS3 failed\n", __func__);
-                                retval = -1;
-                                goto err_exit;
-                        } else
-                                break;
-                }
-        }
-
-        /* TBD: evaluate _STA to check if the slot is disabled */
-
-        slot->flags &= (~SLOT_POWEREDON);
-
- err_exit:
-        return retval;
-}
-
-
-
 /**
  * acpiphp_max_busnr - return the highest reserved bus number under the given bus.
  * @bus: bus to start search with
@@ -583,52 +466,32 @@ static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
         return max;
 }
 
-
 /**
- * acpiphp_bus_add - add a new bus to acpi subsystem
- * @func: acpiphp_func of the bridge
+ * acpiphp_bus_trim - Trim device objects in an ACPI namespace subtree.
+ * @handle: ACPI device object handle to start from.
  */
-static int acpiphp_bus_add(struct acpiphp_func *func)
+static void acpiphp_bus_trim(acpi_handle handle)
 {
-        struct acpi_device *device;
-        int ret_val;
-
-        if (!acpi_bus_get_device(func->handle, &device)) {
-                dbg("bus exists... trim\n");
-                /* this shouldn't be in here, so remove
-                 * the bus then re-add it...
-                 */
-                acpi_bus_trim(device);
-        }
-
-        ret_val = acpi_bus_scan(func->handle);
-        if (!ret_val)
-                ret_val = acpi_bus_get_device(func->handle, &device);
-
-        if (ret_val)
-                dbg("error adding bus, %x\n", -ret_val);
+        struct acpi_device *adev = NULL;
 
-        return ret_val;
+        acpi_bus_get_device(handle, &adev);
+        if (adev)
+                acpi_bus_trim(adev);
 }
 
-
 /**
- * acpiphp_bus_trim - trim a bus from acpi subsystem
- * @handle: handle to acpi namespace
+ * acpiphp_bus_add - Scan ACPI namespace subtree.
+ * @handle: ACPI object handle to start the scan from.
  */
-static int acpiphp_bus_trim(acpi_handle handle)
+static void acpiphp_bus_add(acpi_handle handle)
 {
-        struct acpi_device *device;
-        int retval;
-
-        retval = acpi_bus_get_device(handle, &device);
-        if (retval) {
-                dbg("acpi_device not found\n");
-                return retval;
-        }
+        struct acpi_device *adev = NULL;
 
-        acpi_bus_trim(device);
-        return 0;
+        acpiphp_bus_trim(handle);
+        acpi_bus_scan(handle);
+        acpi_bus_get_device(handle, &adev);
+        if (adev)
+                acpi_device_set_power(adev, ACPI_STATE_D0);
 }
 
 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
@@ -645,7 +508,8 @@ static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
                 params[1].type = ACPI_TYPE_INTEGER;
                 params[1].integer.value = 1;
                 /* _REG is optional, we don't care about if there is failure */
-                acpi_evaluate_object(func->handle, "_REG", &arg_list, NULL);
+                acpi_evaluate_object(func_to_handle(func), "_REG", &arg_list,
+                                     NULL);
         }
 }
 
@@ -653,59 +517,44 @@ static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev)
 {
         struct acpiphp_func *func;
 
-        if (!dev->subordinate)
-                return;
-
         /* quirk, or pcie could set it already */
         if (dev->is_hotplug_bridge)
                 return;
 
-        if (PCI_SLOT(dev->devfn) != slot->device)
-                return;
-
         list_for_each_entry(func, &slot->funcs, sibling) {
                 if (PCI_FUNC(dev->devfn) == func->function) {
-                        /* check if this bridge has ejectable slots */
-                        if ((detect_ejectable_slots(func->handle) > 0))
-                                dev->is_hotplug_bridge = 1;
+                        dev->is_hotplug_bridge = 1;
                         break;
                 }
         }
 }
 
 /**
- * enable_device - enable, configure a slot
+ * enable_slot - enable, configure a slot
  * @slot: slot to be enabled
  *
  * This function should be called per *physical slot*,
  * not per each slot object in ACPI namespace.
  */
-static int __ref enable_device(struct acpiphp_slot *slot)
+static void __ref enable_slot(struct acpiphp_slot *slot)
 {
         struct pci_dev *dev;
-        struct pci_bus *bus = slot->bridge->pci_bus;
+        struct pci_bus *bus = slot->bus;
         struct acpiphp_func *func;
-        int num, max, pass;
+        int max, pass;
         LIST_HEAD(add_list);
 
-        if (slot->flags & SLOT_ENABLED)
-                goto err_exit;
-
         list_for_each_entry(func, &slot->funcs, sibling)
-                acpiphp_bus_add(func);
+                acpiphp_bus_add(func_to_handle(func));
 
-        num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
-        if (num == 0) {
-                /* Maybe only part of funcs are added. */
-                dbg("No new device found\n");
-                goto err_exit;
-        }
+        pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
 
         max = acpiphp_max_busnr(bus);
         for (pass = 0; pass < 2; pass++) {
                 list_for_each_entry(dev, &bus->devices, bus_list) {
                         if (PCI_SLOT(dev->devfn) != slot->device)
                                 continue;
+
                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
                                 max = pci_scan_bridge(bus, dev, max, pass);
@@ -744,16 +593,12 @@ static int __ref enable_device(struct acpiphp_slot *slot)
                         continue;
                 }
         }
-
-
- err_exit:
-        return 0;
 }
 
 /* return first device in slot, acquiring a reference on it */
 static struct pci_dev *dev_in_slot(struct acpiphp_slot *slot)
 {
-        struct pci_bus *bus = slot->bridge->pci_bus;
+        struct pci_bus *bus = slot->bus;
         struct pci_dev *dev;
         struct pci_dev *ret = NULL;
 
@@ -769,16 +614,16 @@ static struct pci_dev *dev_in_slot(struct acpiphp_slot *slot)
 }
 
 /**
- * disable_device - disable a slot
+ * disable_slot - disable a slot
  * @slot: ACPI PHP slot
  */
-static int disable_device(struct acpiphp_slot *slot)
+static void disable_slot(struct acpiphp_slot *slot)
 {
         struct acpiphp_func *func;
         struct pci_dev *pdev;
 
         /*
-         * enable_device() enumerates all functions in this device via
+         * enable_slot() enumerates all functions in this device via
          * pci_scan_slot(), whether they have associated ACPI hotplug
          * methods (_EJ0, etc.) or not.  Therefore, we remove all functions
          * here.
@@ -788,13 +633,10 @@ static int disable_device(struct acpiphp_slot *slot)
                 pci_dev_put(pdev);
         }
 
-        list_for_each_entry(func, &slot->funcs, sibling) {
-                acpiphp_bus_trim(func->handle);
-        }
+        list_for_each_entry(func, &slot->funcs, sibling)
+                acpiphp_bus_trim(func_to_handle(func));
 
         slot->flags &= (~SLOT_ENABLED);
-
-        return 0;
 }
 
 
@@ -812,18 +654,21 @@ static int disable_device(struct acpiphp_slot *slot)
  */
 static unsigned int get_slot_status(struct acpiphp_slot *slot)
 {
-        acpi_status status;
         unsigned long long sta = 0;
-        u32 dvid;
         struct acpiphp_func *func;
 
         list_for_each_entry(func, &slot->funcs, sibling) {
                 if (func->flags & FUNC_HAS_STA) {
-                        status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta);
+                        acpi_status status;
+
+                        status = acpi_evaluate_integer(func_to_handle(func),
+                                                       "_STA", NULL, &sta);
                         if (ACPI_SUCCESS(status) && sta)
                                 break;
                 } else {
-                        pci_bus_read_config_dword(slot->bridge->pci_bus,
+                        u32 dvid;
+
+                        pci_bus_read_config_dword(slot->bus,
                                                   PCI_DEVFN(slot->device,
                                                             func->function),
                                                   PCI_VENDOR_ID, &dvid);
@@ -838,34 +683,42 @@ static unsigned int get_slot_status(struct acpiphp_slot *slot)
 }
 
 /**
- * acpiphp_eject_slot - physically eject the slot
- * @slot: ACPI PHP slot
+ * trim_stale_devices - remove PCI devices that are not responding.
+ * @dev: PCI device to start walking the hierarchy from.
  */
-int acpiphp_eject_slot(struct acpiphp_slot *slot)
+static void trim_stale_devices(struct pci_dev *dev)
 {
-        acpi_status status;
-        struct acpiphp_func *func;
-        struct acpi_object_list arg_list;
-        union acpi_object arg;
+        acpi_handle handle = ACPI_HANDLE(&dev->dev);
+        struct pci_bus *bus = dev->subordinate;
+        bool alive = false;
 
-        list_for_each_entry(func, &slot->funcs, sibling) {
-                /* We don't want to call _EJ0 on non-existing functions. */
-                if ((func->flags & FUNC_HAS_EJ0)) {
-                        /* _EJ0 method take one argument */
-                        arg_list.count = 1;
-                        arg_list.pointer = &arg;
-                        arg.type = ACPI_TYPE_INTEGER;
-                        arg.integer.value = 1;
-
-                        status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL);
-                        if (ACPI_FAILURE(status)) {
-                                warn("%s: _EJ0 failed\n", __func__);
-                                return -1;
-                        } else
-                                break;
-                }
+        if (handle) {
+                acpi_status status;
+                unsigned long long sta;
+
+                status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
+                alive = ACPI_SUCCESS(status) && sta == ACPI_STA_ALL;
+        }
+        if (!alive) {
+                u32 v;
+
+                /* Check if the device responds. */
+                alive = pci_bus_read_dev_vendor_id(dev->bus, dev->devfn, &v, 0);
+        }
+        if (!alive) {
+                pci_stop_and_remove_bus_device(dev);
+                if (handle)
+                        acpiphp_bus_trim(handle);
+        } else if (bus) {
+                struct pci_dev *child, *tmp;
+
+                /* The device is a bridge. so check the bus below it. */
+                pm_runtime_get_sync(&dev->dev);
+                list_for_each_entry_safe(child, tmp, &bus->devices, bus_list)
+                        trim_stale_devices(child);
+
+                pm_runtime_put(&dev->dev);
         }
-        return 0;
 }
 
 /**
@@ -875,43 +728,30 @@ int acpiphp_eject_slot(struct acpiphp_slot *slot)
  * Iterate over all slots under this bridge and make sure that if a
  * card is present they are enabled, and if not they are disabled.
  */
-static int acpiphp_check_bridge(struct acpiphp_bridge *bridge)
+static void acpiphp_check_bridge(struct acpiphp_bridge *bridge)
 {
         struct acpiphp_slot *slot;
-        int retval = 0;
-        int enabled, disabled;
-
-        enabled = disabled = 0;
 
         list_for_each_entry(slot, &bridge->slots, node) {
-                unsigned int status = get_slot_status(slot);
-                if (slot->flags & SLOT_ENABLED) {
-                        if (status == ACPI_STA_ALL)
-                                continue;
-                        retval = acpiphp_disable_slot(slot);
-                        if (retval) {
-                                err("Error occurred in disabling\n");
-                                goto err_exit;
-                        } else {
-                                acpiphp_eject_slot(slot);
-                        }
-                        disabled++;
+                struct pci_bus *bus = slot->bus;
+                struct pci_dev *dev, *tmp;
+
+                mutex_lock(&slot->crit_sect);
+                /* wake up all functions */
+                if (get_slot_status(slot) == ACPI_STA_ALL) {
+                        /* remove stale devices if any */
+                        list_for_each_entry_safe(dev, tmp, &bus->devices,
+                                                 bus_list)
+                                if (PCI_SLOT(dev->devfn) == slot->device)
+                                        trim_stale_devices(dev);
+
+                        /* configure all functions */
+                        enable_slot(slot);
                 } else {
-                        if (status != ACPI_STA_ALL)
-                                continue;
-                        retval = acpiphp_enable_slot(slot);
-                        if (retval) {
-                                err("Error occurred in enabling\n");
-                                goto err_exit;
-                        }
-                        enabled++;
+                        disable_slot(slot);
                 }
+                mutex_unlock(&slot->crit_sect);
         }
-
-        dbg("%s: %d enabled, %d disabled\n", __func__, enabled, disabled);
-
- err_exit:
-        return retval;
 }
 
 static void acpiphp_set_hpp_values(struct pci_bus *bus)
@@ -950,25 +790,6 @@ static void acpiphp_sanitize_bus(struct pci_bus *bus)
  * ACPI event handlers
  */
 
-static acpi_status
-check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
-{
-        struct acpiphp_bridge *bridge;
-        char objname[64];
-        struct acpi_buffer buffer = { .length = sizeof(objname),
-                                      .pointer = objname };
-
-        bridge = acpiphp_handle_to_bridge(handle);
-        if (bridge) {
-                acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
-                dbg("%s: re-enumerating slots under %s\n",
-                        __func__, objname);
-                acpiphp_check_bridge(bridge);
-                put_bridge(bridge);
-        }
-        return AE_OK ;
-}
-
 void acpiphp_check_host_bridge(acpi_handle handle)
 {
         struct acpiphp_bridge *bridge;
@@ -978,27 +799,23 @@ void acpiphp_check_host_bridge(acpi_handle handle)
                 acpiphp_check_bridge(bridge);
                 put_bridge(bridge);
         }
-
-        acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
-                ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL, NULL);
 }
 
-static void _handle_hotplug_event_bridge(struct work_struct *work)
+static void hotplug_event(acpi_handle handle, u32 type, void *data)
 {
+        struct acpiphp_context *context = data;
+        struct acpiphp_func *func = &context->func;
         struct acpiphp_bridge *bridge;
         char objname[64];
         struct acpi_buffer buffer = { .length = sizeof(objname),
                                       .pointer = objname };
-        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;
-        bridge = (struct acpiphp_bridge *)hp_work->context;
+        mutex_lock(&acpiphp_context_lock);
+        bridge = context->bridge;
+        if (bridge)
+                get_bridge(bridge);
 
-        acpi_scan_lock_acquire();
+        mutex_unlock(&acpiphp_context_lock);
 
         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
 
@@ -1007,188 +824,129 @@ static void _handle_hotplug_event_bridge(struct work_struct *work)
                 /* bus re-enumerate */
                 dbg("%s: Bus check notify on %s\n", __func__, objname);
                 dbg("%s: re-enumerating slots under %s\n", __func__, objname);
-                acpiphp_check_bridge(bridge);
-                acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
-                        ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL, NULL);
+                if (bridge) {
+                        acpiphp_check_bridge(bridge);
+                } else {
+                        struct acpiphp_slot *slot = func->slot;
+
+                        mutex_lock(&slot->crit_sect);
+                        enable_slot(slot);
+                        mutex_unlock(&slot->crit_sect);
+                }
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK:
                 /* device check */
                 dbg("%s: Device check notify on %s\n", __func__, objname);
-                acpiphp_check_bridge(bridge);
-                break;
+                if (bridge)
+                        acpiphp_check_bridge(bridge);
+                else
+                        acpiphp_check_bridge(func->parent);
 
-        case ACPI_NOTIFY_DEVICE_WAKE:
-                /* wake event */
-                dbg("%s: Device wake notify on %s\n", __func__, objname);
                 break;
 
         case ACPI_NOTIFY_EJECT_REQUEST:
                 /* request device eject */
                 dbg("%s: Device eject notify on %s\n", __func__, objname);
-                if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) {
-                        struct acpiphp_slot *slot;
-                        slot = bridge->func->slot;
-                        if (!acpiphp_disable_slot(slot))
-                                acpiphp_eject_slot(slot);
-                }
+                acpiphp_disable_and_eject_slot(func->slot);
                 break;
+        }
 
-        case ACPI_NOTIFY_FREQUENCY_MISMATCH:
-                printk(KERN_ERR "Device %s cannot be configured due"
-                                " to a frequency mismatch\n", objname);
-                break;
+        if (bridge)
+                put_bridge(bridge);
+}
 
-        case ACPI_NOTIFY_BUS_MODE_MISMATCH:
-                printk(KERN_ERR "Device %s cannot be configured due"
-                                " to a bus mode mismatch\n", objname);
-                break;
+static void hotplug_event_work(struct work_struct *work)
+{
+        struct acpiphp_context *context;
+        struct acpi_hp_work *hp_work;
 
-        case ACPI_NOTIFY_POWER_FAULT:
-                printk(KERN_ERR "Device %s has suffered a power fault\n",
-                                objname);
-                break;
+        hp_work = container_of(work, struct acpi_hp_work, work);
+        context = hp_work->context;
+        acpi_scan_lock_acquire();
 
-        default:
-                warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
-                break;
-        }
+        hotplug_event(hp_work->handle, hp_work->type, context);
 
         acpi_scan_lock_release();
-        kfree(hp_work); /* allocated in handle_hotplug_event_bridge */
-        put_bridge(bridge);
+        kfree(hp_work); /* allocated in handle_hotplug_event() */
+        put_bridge(context->func.parent);
 }
 
 /**
- * handle_hotplug_event_bridge - handle ACPI event on bridges
+ * handle_hotplug_event - handle ACPI hotplug event
  * @handle: Notify()'ed acpi_handle
  * @type: Notify code
- * @context: pointer to acpiphp_bridge structure
+ * @data: pointer to acpiphp_context structure
  *
- * Handles ACPI event notification on {host,p2p} bridges.
+ * Handles ACPI event notification on slots.
  */
-static void handle_hotplug_event_bridge(acpi_handle handle, u32 type,
-                                        void *context)
+static void handle_hotplug_event(acpi_handle handle, u32 type, void *data)
 {
-        struct acpiphp_bridge *bridge = context;
-
-        /*
-         * Currently the code adds all hotplug events to the kacpid_wq
-         * queue when it should add hotplug events to the kacpi_hotplug_wq.
-         * The proper way to fix this is to reorganize the code so that
-         * drivers (dock, etc.) do not call acpi_os_execute(), etc.
-         * For now just re-add this work to the kacpi_hotplug_wq so we
-         * don't deadlock on hotplug actions.
-         */
-        get_bridge(bridge);
-        alloc_acpi_hp_work(handle, type, context, _handle_hotplug_event_bridge);
-}
-
-static void hotplug_event_func(acpi_handle handle, u32 type, void *context)
-{
-        struct acpiphp_func *func = context;
-        char objname[64];
-        struct acpi_buffer buffer = { .length = sizeof(objname),
-                                      .pointer = objname };
-
-        acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
+        struct acpiphp_context *context;
 
         switch (type) {
         case ACPI_NOTIFY_BUS_CHECK:
-                /* bus re-enumerate */
-                dbg("%s: Bus check notify on %s\n", __func__, objname);
-                acpiphp_enable_slot(func->slot);
-                break;
-
         case ACPI_NOTIFY_DEVICE_CHECK:
-                /* device check : re-enumerate from parent bus */
-                dbg("%s: Device check notify on %s\n", __func__, objname);
-                acpiphp_check_bridge(func->slot->bridge);
-                break;
-
-        case ACPI_NOTIFY_DEVICE_WAKE:
-                /* wake event */
-                dbg("%s: Device wake notify on %s\n", __func__, objname);
-                break;
-
         case ACPI_NOTIFY_EJECT_REQUEST:
-                /* request device eject */
-                dbg("%s: Device eject notify on %s\n", __func__, objname);
-                if (!(acpiphp_disable_slot(func->slot)))
-                        acpiphp_eject_slot(func->slot);
                 break;
 
-        default:
-                warn("notify_handler: unknown event type 0x%x for %s\n", type, objname);
-                break;
-        }
-}
-
-static void _handle_hotplug_event_func(struct work_struct *work)
-{
-        struct acpi_hp_work *hp_work;
-        struct acpiphp_func *func;
+        case ACPI_NOTIFY_DEVICE_WAKE:
+                return;
 
-        hp_work = container_of(work, struct acpi_hp_work, work);
-        func = hp_work->context;
-        acpi_scan_lock_acquire();
+        case ACPI_NOTIFY_FREQUENCY_MISMATCH:
+                acpi_handle_err(handle, "Device cannot be configured due "
+                                "to a frequency mismatch\n");
+                return;
 
-        hotplug_event_func(hp_work->handle, hp_work->type, func);
+        case ACPI_NOTIFY_BUS_MODE_MISMATCH:
+                acpi_handle_err(handle, "Device cannot be configured due "
+                                "to a bus mode mismatch\n");
+                return;
 
-        acpi_scan_lock_release();
-        kfree(hp_work); /* allocated in handle_hotplug_event_func */
-        put_bridge(func->slot->bridge);
-}
+        case ACPI_NOTIFY_POWER_FAULT:
+                acpi_handle_err(handle, "Device has suffered a power fault\n");
+                return;
 
-/**
- * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots)
- * @handle: Notify()'ed acpi_handle
- * @type: Notify code
- * @context: pointer to acpiphp_func structure
- *
- * Handles ACPI event notification on slots.
- */
-static void handle_hotplug_event_func(acpi_handle handle, u32 type,
-                                      void *context)
-{
-        struct acpiphp_func *func = context;
+        default:
+                acpi_handle_warn(handle, "Unsupported event type 0x%x\n", type);
+                return;
+        }
 
-        /*
-         * Currently the code adds all hotplug events to the kacpid_wq
-         * queue when it should add hotplug events to the kacpi_hotplug_wq.
-         * The proper way to fix this is to reorganize the code so that
-         * drivers (dock, etc.) do not call acpi_os_execute(), etc.
-         * For now just re-add this work to the kacpi_hotplug_wq so we
-         * don't deadlock on hotplug actions.
-         */
-        get_bridge(func->slot->bridge);
-        alloc_acpi_hp_work(handle, type, context, _handle_hotplug_event_func);
+        mutex_lock(&acpiphp_context_lock);
+        context = acpiphp_get_context(handle);
+        if (context) {
+                get_bridge(context->func.parent);
+                acpiphp_put_context(context);
+                alloc_acpi_hp_work(handle, type, context, hotplug_event_work);
+        }
+        mutex_unlock(&acpiphp_context_lock);
 }
 
 /*
  * Create hotplug slots for the PCI bus.
  * It should always return 0 to avoid skipping following notifiers.
  */
-void acpiphp_enumerate_slots(struct pci_bus *bus, acpi_handle handle)
+void acpiphp_enumerate_slots(struct pci_bus *bus)
 {
-        acpi_handle dummy_handle;
         struct acpiphp_bridge *bridge;
+        acpi_handle handle;
+        acpi_status status;
 
         if (acpiphp_disabled)
                 return;
 
-        if (detect_ejectable_slots(handle) <= 0)
+        handle = ACPI_HANDLE(bus->bridge);
+        if (!handle)
                 return;
 
         bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
-        if (bridge == NULL) {
-                err("out of memory\n");
+        if (!bridge) {
+                acpi_handle_err(handle, "No memory for bridge object\n");
                 return;
         }
 
         INIT_LIST_HEAD(&bridge->slots);
         kref_init(&bridge->ref);
-        bridge->handle = handle;
         bridge->pci_dev = pci_dev_get(bus->self);
         bridge->pci_bus = bus;
 
@@ -1199,31 +957,62 @@ void acpiphp_enumerate_slots(struct pci_bus *bus, acpi_handle handle)
          */
         get_device(&bus->dev);
 
-        if (!pci_is_root_bus(bridge->pci_bus) &&
-            ACPI_SUCCESS(acpi_get_handle(bridge->handle,
-                                        "_EJ0", &dummy_handle))) {
-                dbg("found ejectable p2p bridge\n");
-                bridge->flags |= BRIDGE_HAS_EJ0;
-                bridge->func = acpiphp_bridge_handle_to_function(handle);
+        if (!pci_is_root_bus(bridge->pci_bus)) {
+                struct acpiphp_context *context;
+
+                /*
+                 * This bridge should have been registered as a hotplug function
+                 * under its parent, so the context has to be there.  If not, we
+                 * are in deep goo.
+                 */
+                mutex_lock(&acpiphp_context_lock);
+                context = acpiphp_get_context(handle);
+                if (WARN_ON(!context)) {
+                        mutex_unlock(&acpiphp_context_lock);
+                        put_device(&bus->dev);
+                        kfree(bridge);
+                        return;
+                }
+                bridge->context = context;
+                context->bridge = bridge;
+                /* Get a reference to the parent bridge. */
+                get_bridge(context->func.parent);
+                mutex_unlock(&acpiphp_context_lock);
         }
 
-        init_bridge_misc(bridge);
+        /* must be added to the list prior to calling register_slot */
+        mutex_lock(&bridge_mutex);
+        list_add(&bridge->list, &bridge_list);
+        mutex_unlock(&bridge_mutex);
+
+        /* register all slot objects under this bridge */
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
+                                     register_slot, NULL, bridge, NULL);
+        if (ACPI_FAILURE(status)) {
+                acpi_handle_err(handle, "failed to register slots\n");
+                cleanup_bridge(bridge);
+                put_bridge(bridge);
+        }
 }
 
 /* Destroy hotplug slots associated with the PCI bus */
 void acpiphp_remove_slots(struct pci_bus *bus)
 {
-        struct acpiphp_bridge *bridge, *tmp;
+        struct acpiphp_bridge *bridge;
 
         if (acpiphp_disabled)
                 return;
 
-        list_for_each_entry_safe(bridge, tmp, &bridge_list, list)
+        mutex_lock(&bridge_mutex);
+        list_for_each_entry(bridge, &bridge_list, list)
                 if (bridge->pci_bus == bus) {
+                        mutex_unlock(&bridge_mutex);
                         cleanup_bridge(bridge);
                         put_bridge(bridge);
-                        break;
+                        return;
                 }
+
+        mutex_unlock(&bridge_mutex);
 }
 
 /**
@@ -1232,51 +1021,39 @@ void acpiphp_remove_slots(struct pci_bus *bus)
  */
 int acpiphp_enable_slot(struct acpiphp_slot *slot)
 {
-        int retval;
-
         mutex_lock(&slot->crit_sect);
+        /* configure all functions */
+        if (!(slot->flags & SLOT_ENABLED))
+                enable_slot(slot);
 
-        /* wake up all functions */
-        retval = power_on_slot(slot);
-        if (retval)
-                goto err_exit;
-
-        if (get_slot_status(slot) == ACPI_STA_ALL) {
-                /* configure all functions */
-                retval = enable_device(slot);
-                if (retval)
-                        power_off_slot(slot);
-        } else {
-                dbg("%s: Slot status is not ACPI_STA_ALL\n", __func__);
-                power_off_slot(slot);
-        }
-
- err_exit:
         mutex_unlock(&slot->crit_sect);
-        return retval;
+        return 0;
 }
 
 /**
- * acpiphp_disable_slot - power off slot
+ * acpiphp_disable_and_eject_slot - power off and eject slot
  * @slot: ACPI PHP slot
  */
-int acpiphp_disable_slot(struct acpiphp_slot *slot)
+int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
 {
+        struct acpiphp_func *func;
         int retval = 0;
 
         mutex_lock(&slot->crit_sect);
 
         /* unconfigure all functions */
-        retval = disable_device(slot);
-        if (retval)
-                goto err_exit;
+        disable_slot(slot);
+
+        list_for_each_entry(func, &slot->funcs, sibling)
+                if (func->flags & FUNC_HAS_EJ0) {
+                        acpi_handle handle = func_to_handle(func);
 
-        /* power off all functions */
-        retval = power_off_slot(slot);
-        if (retval)
-                goto err_exit;
+                        if (ACPI_FAILURE(acpi_evaluate_ej0(handle)))
+                                acpi_handle_err(handle, "_EJ0 failed\n");
+
+                        break;
+                }
 
- err_exit:
         mutex_unlock(&slot->crit_sect);
         return retval;
 }
@@ -1288,7 +1065,7 @@ int acpiphp_disable_slot(struct acpiphp_slot *slot)
  */
 u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
 {
-        return (slot->flags & SLOT_POWEREDON);
+        return (slot->flags & SLOT_ENABLED);
 }
 
 
@@ -1298,11 +1075,7 @@ u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
  */
 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
 {
-        unsigned int sta;
-
-        sta = get_slot_status(slot);
-
-        return (sta & ACPI_STA_DEVICE_UI) ? 0 : 1;
+        return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI);
 }
 
 
@@ -1312,9 +1085,5 @@ u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
  */
 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot)
 {
-        unsigned int sta;
-
-        sta = get_slot_status(slot);
-
-        return (sta == 0) ? 0 : 1;
+        return !!get_slot_status(slot);
 }
diff --git a/drivers/pci/hotplug/acpiphp_ibm.c b/drivers/pci/hotplug/acpiphp_ibm.c
index c35e8ad6db01..2f5786c8522c 100644
--- a/drivers/pci/hotplug/acpiphp_ibm.c
+++ b/drivers/pci/hotplug/acpiphp_ibm.c
@@ -66,7 +66,7 @@ do {							\
 #define IBM_HARDWARE_ID1 "IBM37D0"
 #define IBM_HARDWARE_ID2 "IBM37D4"
 
-#define hpslot_to_sun(A) (((struct slot *)((A)->private))->acpi_slot->sun)
+#define hpslot_to_sun(A) (((struct slot *)((A)->private))->sun)
 
 /* union apci_descriptor - allows access to the
  * various device descriptors that are embedded in the
@@ -270,7 +270,6 @@ static void ibm_handle_events(acpi_handle handle, u32 event, void *context)
 
         if (subevent == 0x80) {
                 dbg("%s: generationg bus event\n", __func__);
-                acpi_bus_generate_proc_event(note->device, note->event, detail);
                 acpi_bus_generate_netlink_event(note->device->pnp.device_class,
                                                   dev_name(&note->device->dev),
                                                   note->event, detail);
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 01e264fb50e0..7c29ee4ed0ae 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -210,7 +210,7 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
         }
 
         if (!error)
-                dev_info(&dev->dev, "power state changed by ACPI to %s\n",
+                dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
                          acpi_power_state_string(state_conv[state]));
 
         return error;
@@ -290,24 +290,16 @@ static struct pci_platform_pm_ops acpi_pci_platform_pm = {
 
 void acpi_pci_add_bus(struct pci_bus *bus)
 {
-        acpi_handle handle = NULL;
-
-        if (bus->bridge)
-                handle = ACPI_HANDLE(bus->bridge);
-        if (acpi_pci_disabled || handle == NULL)
+        if (acpi_pci_disabled || !bus->bridge)
                 return;
 
-        acpi_pci_slot_enumerate(bus, handle);
-        acpiphp_enumerate_slots(bus, handle);
+        acpi_pci_slot_enumerate(bus);
+        acpiphp_enumerate_slots(bus);
 }
 
 void acpi_pci_remove_bus(struct pci_bus *bus)
 {
-        /*
-         * bus->bridge->acpi_node.handle has already been reset to NULL
-         * when acpi_pci_remove_bus() is called, so don't check ACPI handle.
-         */
-        if (acpi_pci_disabled)
+        if (acpi_pci_disabled || !bus->bridge)
                 return;
 
         acpiphp_remove_slots(bus);
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index 8e268da6fdbd..0e9c169b42f8 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -1543,7 +1543,6 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
 
         /* TODO Find a better way to handle events count. */
         count = asus->event_count[event % 128]++;
-        acpi_bus_generate_proc_event(asus->device, event, count);
         acpi_bus_generate_netlink_event(asus->device->pnp.device_class,
                                         dev_name(&asus->device->dev), event,
                                         count);
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 5d26e70bed6c..a6afd4108beb 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -1269,7 +1269,6 @@ static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
         if (event > ACPI_MAX_SYS_NOTIFY)
                 return;
         count = eeepc->event_count[event % 128]++;
-        acpi_bus_generate_proc_event(device, event, count);
         acpi_bus_generate_netlink_event(device->pnp.device_class,
                                         dev_name(&device->dev), event,
                                         count);
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 1c9386e7c58c..52b8a97efde1 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -773,8 +773,6 @@ static void acpi_fujitsu_notify(struct acpi_device *device, u32 event)
                                 else
                                         set_lcd_level(newb);
                         }
-                        acpi_bus_generate_proc_event(fujitsu->dev,
-                                ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS, 0);
                         keycode = KEY_BRIGHTNESSUP;
                 } else if (oldb > newb) {
                         if (disable_brightness_adjust != 1) {
@@ -783,8 +781,6 @@ static void acpi_fujitsu_notify(struct acpi_device *device, u32 event)
                                 else
                                         set_lcd_level(newb);
                         }
-                        acpi_bus_generate_proc_event(fujitsu->dev,
-                                ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS, 0);
                         keycode = KEY_BRIGHTNESSDOWN;
                 }
                 break;
diff --git a/drivers/platform/x86/panasonic-laptop.c b/drivers/platform/x86/panasonic-laptop.c
index 4add9a31bf60..984253da365d 100644
--- a/drivers/platform/x86/panasonic-laptop.c
+++ b/drivers/platform/x86/panasonic-laptop.c
@@ -464,9 +464,6 @@ static void acpi_pcc_generate_keyinput(struct pcc_acpi *pcc)
                                  "error getting hotkey status\n"));
                 return;
         }
-
-        acpi_bus_generate_proc_event(pcc->device, HKEY_NOTIFY, result);
-
         if (!sparse_keymap_report_event(hotk_input_dev,
                                         result & 0xf, result & 0x80, false))
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 3a1b6bf326a8..d3fd52036fd6 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -1275,9 +1275,6 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                 ev_type = HOTKEY;
                 sony_laptop_report_input_event(real_ev);
         }
-
-        acpi_bus_generate_proc_event(sony_nc_acpi_device, ev_type, real_ev);
-
         acpi_bus_generate_netlink_event(sony_nc_acpi_device->pnp.device_class,
                         dev_name(&sony_nc_acpi_device->dev), ev_type, real_ev);
 }
@@ -4246,7 +4243,6 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id)
 
 found:
         sony_laptop_report_input_event(device_event);
-        acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event);
         sonypi_compat_report_event(device_event);
         return IRQ_HANDLED;
 }
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 54d31c0a9840..be67e5e28d18 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -2022,8 +2022,6 @@ static u32 hotkey_driver_mask;		/* events needed by the driver */
 static u32 hotkey_user_mask;            /* events visible to userspace */
 static u32 hotkey_acpi_mask;            /* events enabled in firmware */
 
-static unsigned int hotkey_report_mode;
-
 static u16 *hotkey_keycode_map;
 
 static struct attribute_set *hotkey_dev_attributes;
@@ -2282,10 +2280,6 @@ static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
 static void tpacpi_hotkey_send_key(unsigned int scancode)
 {
         tpacpi_input_send_key_masked(scancode);
-        if (hotkey_report_mode < 2) {
-                acpi_bus_generate_proc_event(ibm_hotkey_acpidriver.device,
-                                0x80, TP_HKEY_EV_HOTKEY_BASE + scancode);
-        }
 }
 
 static void hotkey_read_nvram(struct tp_nvram_state *n, const u32 m)
@@ -2882,18 +2876,6 @@ static void hotkey_tablet_mode_notify_change(void)
                              "hotkey_tablet_mode");
 }
 
-/* sysfs hotkey report_mode -------------------------------------------- */
-static ssize_t hotkey_report_mode_show(struct device *dev,
-                           struct device_attribute *attr,
-                           char *buf)
-{
-        return snprintf(buf, PAGE_SIZE, "%d\n",
-                (hotkey_report_mode != 0) ? hotkey_report_mode : 1);
-}
-
-static struct device_attribute dev_attr_hotkey_report_mode =
-        __ATTR(hotkey_report_mode, S_IRUGO, hotkey_report_mode_show, NULL);
-
 /* sysfs wakeup reason (pollable) -------------------------------------- */
 static ssize_t hotkey_wakeup_reason_show(struct device *dev,
                            struct device_attribute *attr,
@@ -2935,7 +2917,6 @@ static struct attribute *hotkey_attributes[] __initdata = {
         &dev_attr_hotkey_enable.attr,
         &dev_attr_hotkey_bios_enabled.attr,
         &dev_attr_hotkey_bios_mask.attr,
-        &dev_attr_hotkey_report_mode.attr,
         &dev_attr_hotkey_wakeup_reason.attr,
         &dev_attr_hotkey_wakeup_hotunplug_complete.attr,
         &dev_attr_hotkey_mask.attr,
@@ -3439,11 +3420,6 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
                 hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask);
 
-        dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
-                        "legacy ibm/hotkey event reporting over procfs %s\n",
-                        (hotkey_report_mode < 2) ?
-                                "enabled" : "disabled");
-
         tpacpi_inputdev->open = &hotkey_inputdev_open;
         tpacpi_inputdev->close = &hotkey_inputdev_close;
 
@@ -3737,13 +3713,6 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                                   "event happened to %s\n", TPACPI_MAIL);
                 }
 
-                /* Legacy events */
-                if (!ignore_acpi_ev &&
-                    (send_acpi_ev || hotkey_report_mode < 2)) {
-                        acpi_bus_generate_proc_event(ibm->acpi->device,
-                                                     event, hkey);
-                }
-
                 /* netlink events */
                 if (!ignore_acpi_ev && send_acpi_ev) {
                         acpi_bus_generate_netlink_event(
@@ -8840,11 +8809,6 @@ module_param(brightness_enable, uint, 0444);
 MODULE_PARM_DESC(brightness_enable,
                  "Enables backlight control when 1, disables when 0");
 
-module_param(hotkey_report_mode, uint, 0444);
-MODULE_PARM_DESC(hotkey_report_mode,
-                 "used for backwards compatibility with userspace, "
-                 "see documentation");
-
 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
 module_param_named(volume_mode, volume_mode, uint, 0444);
 MODULE_PARM_DESC(volume_mode,
@@ -8975,10 +8939,6 @@ static int __init thinkpad_acpi_module_init(void)
 
         tpacpi_lifecycle = TPACPI_LIFE_INIT;
 
-        /* Parameter checking */
-        if (hotkey_report_mode > 2)
-                return -EINVAL;
-
         /* Driver-level probe */
 
         ret = get_thinkpad_model_data(&thinkpad_id);
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index 00e94032531a..12adb43a0693 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -154,7 +154,7 @@ static int pnp_bus_match(struct device *dev, struct device_driver *drv)
         return 1;
 }
 
-static int pnp_bus_suspend(struct device *dev, pm_message_t state)
+static int __pnp_bus_suspend(struct device *dev, pm_message_t state)
 {
         struct pnp_dev *pnp_dev = to_pnp_dev(dev);
         struct pnp_driver *pnp_drv = pnp_dev->driver;
@@ -180,6 +180,16 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
+static int pnp_bus_suspend(struct device *dev)
+{
+        return __pnp_bus_suspend(dev, PMSG_SUSPEND);
+}
+
+static int pnp_bus_freeze(struct device *dev)
+{
+        return __pnp_bus_suspend(dev, PMSG_FREEZE);
+}
+
 static int pnp_bus_resume(struct device *dev)
 {
         struct pnp_dev *pnp_dev = to_pnp_dev(dev);
@@ -210,14 +220,19 @@ static int pnp_bus_resume(struct device *dev)
         return 0;
 }
 
+static const struct dev_pm_ops pnp_bus_dev_pm_ops = {
+        .suspend = pnp_bus_suspend,
+        .freeze = pnp_bus_freeze,
+        .resume = pnp_bus_resume,
+};
+
 struct bus_type pnp_bus_type = {
         .name    = "pnp",
         .match   = pnp_bus_match,
         .probe   = pnp_device_probe,
         .remove  = pnp_device_remove,
         .shutdown = pnp_device_shutdown,
-        .suspend = pnp_bus_suspend,
-        .resume  = pnp_bus_resume,
+        .pm      = &pnp_bus_dev_pm_ops,
         .dev_attrs = pnp_interface_attrs,
 };
 
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index 55cd459a3908..34049b0b4c73 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -131,7 +131,7 @@ static int pnpacpi_disable_resources(struct pnp_dev *dev)
         /* acpi_unregister_gsi(pnp_irq(dev, 0)); */
         ret = 0;
         if (acpi_bus_power_manageable(handle))
-                acpi_bus_set_power(handle, ACPI_STATE_D3);
+                acpi_bus_set_power(handle, ACPI_STATE_D3_COLD);
                 /* continue even if acpi_bus_set_power() fails */
         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DIS", NULL, NULL)))
                 ret = -ENODEV;
@@ -174,10 +174,10 @@ static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
 
         if (acpi_bus_power_manageable(handle)) {
                 int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL,
-                                                             ACPI_STATE_D3);
+                                                        ACPI_STATE_D3_COLD);
                 if (power_state < 0)
                         power_state = (state.event == PM_EVENT_ON) ?
-                                        ACPI_STATE_D0 : ACPI_STATE_D3;
+                                        ACPI_STATE_D0 : ACPI_STATE_D3_COLD;
 
                 /*
                  * acpi_bus_set_power() often fails (keyboard port can't be
diff --git a/drivers/xen/acpi.c b/drivers/xen/acpi.c
index 119d42a2bf57..90307c0b630c 100644
--- a/drivers/xen/acpi.c
+++ b/drivers/xen/acpi.c
@@ -35,28 +35,43 @@
 #include <asm/xen/hypercall.h>
 #include <asm/xen/hypervisor.h>
 
-int xen_acpi_notify_hypervisor_state(u8 sleep_state,
-                                     u32 pm1a_cnt, u32 pm1b_cnt)
+static int xen_acpi_notify_hypervisor_state(u8 sleep_state,
+                                            u32 val_a, u32 val_b,
+                                            bool extended)
 {
+        unsigned int bits = extended ? 8 : 16;
+
         struct xen_platform_op op = {
                 .cmd = XENPF_enter_acpi_sleep,
                 .interface_version = XENPF_INTERFACE_VERSION,
-                .u = {
-                        .enter_acpi_sleep = {
-                                .pm1a_cnt_val = (u16)pm1a_cnt,
-                                .pm1b_cnt_val = (u16)pm1b_cnt,
-                                .sleep_state = sleep_state,
-                        },
+                .u.enter_acpi_sleep = {
+                        .val_a = (u16)val_a,
+                        .val_b = (u16)val_b,
+                        .sleep_state = sleep_state,
+                        .flags = extended ? XENPF_ACPI_SLEEP_EXTENDED : 0,
                 },
         };
 
-        if ((pm1a_cnt & 0xffff0000) || (pm1b_cnt & 0xffff0000)) {
-                WARN(1, "Using more than 16bits of PM1A/B 0x%x/0x%x!"
-                     "Email xen-devel@lists.xensource.com  Thank you.\n", \
-                     pm1a_cnt, pm1b_cnt);
+        if (WARN((val_a & (~0 << bits)) || (val_b & (~0 << bits)),
+                 "Using more than %u bits of sleep control values %#x/%#x!"
+                 "Email xen-devel@lists.xen.org - Thank you.\n", \
+                 bits, val_a, val_b))
                 return -1;
-        }
 
         HYPERVISOR_dom0_op(&op);
         return 1;
 }
+
+int xen_acpi_notify_hypervisor_sleep(u8 sleep_state,
+                                     u32 pm1a_cnt, u32 pm1b_cnt)
+{
+        return xen_acpi_notify_hypervisor_state(sleep_state, pm1a_cnt,
+                                                pm1b_cnt, false);
+}
+
+int xen_acpi_notify_hypervisor_extended_sleep(u8 sleep_state,
+                                     u32 val_a, u32 val_b)
+{
+        return xen_acpi_notify_hypervisor_state(sleep_state, val_a,
+                                                val_b, true);
+}