26 files changed, 479 insertions, 211 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 408b45168aba..f1372de4ce79 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -43,50 +43,30 @@ menuconfig ACPI
 if ACPI
 
 config ACPI_SLEEP
-        bool "Sleep States"
-        depends on X86 && (!SMP || SUSPEND_SMP)
-        default y
-        ---help---
-          This option adds support for ACPI suspend states. 
-
-          With this option, you will be able to put the system "to sleep". 
-          Sleep states are low power states for the system and devices. All
-          of the system operating state is saved to either memory or disk
-          (depending on the state), to allow the system to resume operation
-          quickly at your request.
-
-          Although this option sounds really nifty, barely any of the device
-          drivers have been converted to the new driver model and hence few
-          have proper power management support. 
-
-          This option is not recommended for anyone except those doing driver
-          power management development.
-
-config ACPI_SLEEP_PROC_FS
         bool
-        depends on ACPI_SLEEP && PROC_FS
+        depends on PM_SLEEP
         default y
 
-config ACPI_SLEEP_PROC_SLEEP
-        bool "/proc/acpi/sleep (deprecated)"
-        depends on ACPI_SLEEP_PROC_FS
-        default n
-        ---help---
-          Create /proc/acpi/sleep
-          Deprecated by /sys/power/state
-
 config ACPI_PROCFS
-        bool "Procfs interface (deprecated)"
-        default y
+        bool "Deprecated /proc/acpi files"
+        depends on PROC_FS
         ---help---
-          The Procfs interface for ACPI is made optional for backward compatibility.
-          As the same functions are duplicated in the sysfs interface
-          and this proc interface will be removed some time later,
-          it's marked as deprecated.
-          ( /proc/acpi/debug_layer && debug_level are deprecated by
-            /sys/module/acpi/parameters/debug_layer && debug_level.
-            /proc/acpi/info is deprecated by
-            /sys/module/acpi/parameters/acpica_version )
+          For backwards compatibility, this option allows
+          depricated /proc/acpi/ files to exist, even when
+          they have been replaced by functions in /sys.
+          The deprecated files (and their replacements) include:
+
+          /proc/acpi/sleep (/sys/power/state)
+          /proc/acpi/info (/sys/modules/acpi/parameters/acpica_version)
+          /proc/acpi/dsdt (/sys/firmware/acpi/tables/DSDT)
+          /proc/acpi/fadt (/sys/firmware/acpi/tables/FACP)
+          /proc/acpi/debug_layer (/sys/module/acpi/parameters/debug_layer)
+          /proc/acpi/debug_level (/sys/module/acpi/parameters/debug_level)
+
+          This option has no effect on /proc/acpi/ files
+          and functions which do not yet exist in /sys.
+
+          Say N to delete /proc/acpi/ files that have moved to /sys/
 
 config ACPI_AC
         tristate "AC Adapter"
diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 37c7dc4f9fe5..d8b35093527a 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -34,7 +34,6 @@
 
 #define ACPI_AC_COMPONENT               0x00020000
 #define ACPI_AC_CLASS                   "ac_adapter"
-#define ACPI_AC_HID                     "ACPI0003"
 #define ACPI_AC_DEVICE_NAME             "AC Adapter"
 #define ACPI_AC_FILE_STATE              "state"
 #define ACPI_AC_NOTIFY_STATUS           0x80
@@ -56,10 +55,16 @@ static int acpi_ac_add(struct acpi_device *device);
 static int acpi_ac_remove(struct acpi_device *device, int type);
 static int acpi_ac_open_fs(struct inode *inode, struct file *file);
 
+const static struct acpi_device_id ac_device_ids[] = {
+        {"ACPI0003", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, ac_device_ids);
+
 static struct acpi_driver acpi_ac_driver = {
         .name = "ac",
         .class = ACPI_AC_CLASS,
-        .ids = ACPI_AC_HID,
+        .ids = ac_device_ids,
         .ops = {
                 .add = acpi_ac_add,
                 .remove = acpi_ac_remove,
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index e65628a03085..5f1127ad5a95 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -53,10 +53,16 @@ static int acpi_memory_device_add(struct acpi_device *device);
 static int acpi_memory_device_remove(struct acpi_device *device, int type);
 static int acpi_memory_device_start(struct acpi_device *device);
 
+static const struct acpi_device_id memory_device_ids[] = {
+        {ACPI_MEMORY_DEVICE_HID, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, memory_device_ids);
+
 static struct acpi_driver acpi_memory_device_driver = {
         .name = "acpi_memhotplug",
         .class = ACPI_MEMORY_DEVICE_CLASS,
-        .ids = ACPI_MEMORY_DEVICE_HID,
+        .ids = memory_device_ids,
         .ops = {
                 .add = acpi_memory_device_add,
                 .remove = acpi_memory_device_remove,
diff --git a/drivers/acpi/asus_acpi.c b/drivers/acpi/asus_acpi.c
index 3cd79caad70c..9c4bd220c44f 100644
--- a/drivers/acpi/asus_acpi.c
+++ b/drivers/acpi/asus_acpi.c
@@ -56,7 +56,6 @@
 #define ACPI_HOTK_NAME          "Asus Laptop ACPI Extras Driver"
 #define ACPI_HOTK_CLASS         "hotkey"
 #define ACPI_HOTK_DEVICE_NAME   "Hotkey"
-#define ACPI_HOTK_HID           "ATK0100"
 
 /*
  * Some events we use, same for all Asus
@@ -426,14 +425,20 @@ static struct acpi_table_header *asus_info;
 static struct asus_hotk *hotk;
 
 /*
- * The hotkey driver declaration
+ * The hotkey driver and autoloading declaration
  */
 static int asus_hotk_add(struct acpi_device *device);
 static int asus_hotk_remove(struct acpi_device *device, int type);
+static const struct acpi_device_id asus_device_ids[] = {
+        {"ATK0100", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, asus_device_ids);
+
 static struct acpi_driver asus_hotk_driver = {
         .name = "asus_acpi",
         .class = ACPI_HOTK_CLASS,
-        .ids = ACPI_HOTK_HID,
+        .ids = asus_device_ids,
         .ops = {
                 .add = asus_hotk_add,
                 .remove = asus_hotk_remove,
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index cad932de383d..81651032791b 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -41,7 +41,6 @@
 
 #define ACPI_BATTERY_COMPONENT          0x00040000
 #define ACPI_BATTERY_CLASS              "battery"
-#define ACPI_BATTERY_HID                "PNP0C0A"
 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
 #define ACPI_BATTERY_NOTIFY_INFO        0x81
@@ -74,10 +73,16 @@ static int acpi_battery_add(struct acpi_device *device);
 static int acpi_battery_remove(struct acpi_device *device, int type);
 static int acpi_battery_resume(struct acpi_device *device);
 
+static const struct acpi_device_id battery_device_ids[] = {
+        {"PNP0C0A", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, battery_device_ids);
+
 static struct acpi_driver acpi_battery_driver = {
         .name = "battery",
         .class = ACPI_BATTERY_CLASS,
-        .ids = ACPI_BATTERY_HID,
+        .ids = battery_device_ids,
         .ops = {
                 .add = acpi_battery_add,
                 .resume = acpi_battery_resume,
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index cb4110b50cd0..540581338ef5 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -66,6 +66,16 @@ MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION("ACPI Button Driver");
 MODULE_LICENSE("GPL");
 
+static const struct acpi_device_id button_device_ids[] = {
+        {ACPI_BUTTON_HID_LID,    0},
+        {ACPI_BUTTON_HID_SLEEP,  0},
+        {ACPI_BUTTON_HID_SLEEPF, 0},
+        {ACPI_BUTTON_HID_POWER,  0},
+        {ACPI_BUTTON_HID_POWERF, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, button_device_ids);
+
 static int acpi_button_add(struct acpi_device *device);
 static int acpi_button_remove(struct acpi_device *device, int type);
 static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
@@ -74,7 +84,7 @@ static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
 static struct acpi_driver acpi_button_driver = {
         .name = "button",
         .class = ACPI_BUTTON_CLASS,
-        .ids = "button_power,button_sleep,PNP0C0D,PNP0C0C,PNP0C0E",
+        .ids = button_device_ids,
         .ops = {
                 .add = acpi_button_add,
                 .remove = acpi_button_remove,
diff --git a/drivers/acpi/container.c b/drivers/acpi/container.c
index 0dd3bf7c0ed1..3c25ec7a1871 100644
--- a/drivers/acpi/container.c
+++ b/drivers/acpi/container.c
@@ -52,10 +52,18 @@ MODULE_LICENSE("GPL");
 static int acpi_container_add(struct acpi_device *device);
 static int acpi_container_remove(struct acpi_device *device, int type);
 
+static const struct acpi_device_id container_device_ids[] = {
+        {"ACPI0004", 0},
+        {"PNP0A05", 0},
+        {"PNP0A06", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, container_device_ids);
+
 static struct acpi_driver acpi_container_driver = {
         .name = "container",
         .class = ACPI_CONTAINER_CLASS,
-        .ids = "ACPI0004,PNP0A05,PNP0A06",
+        .ids = container_device_ids,
         .ops = {
                 .add = acpi_container_add,
                 .remove = acpi_container_remove,
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 10e851021eca..469f3f57f881 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -41,7 +41,6 @@
 #include <acpi/actypes.h>
 
 #define ACPI_EC_CLASS                   "embedded_controller"
-#define ACPI_EC_HID                     "PNP0C09"
 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
 #define ACPI_EC_FILE_INFO               "info"
 
@@ -82,10 +81,15 @@ static int acpi_ec_start(struct acpi_device *device);
 static int acpi_ec_stop(struct acpi_device *device, int type);
 static int acpi_ec_add(struct acpi_device *device);
 
+static const struct acpi_device_id ec_device_ids[] = {
+        {"PNP0C09", 0},
+        {"", 0},
+};
+
 static struct acpi_driver acpi_ec_driver = {
         .name = "ec",
         .class = ACPI_EC_CLASS,
-        .ids = ACPI_EC_HID,
+        .ids = ec_device_ids,
         .ops = {
                 .add = acpi_ec_add,
                 .remove = acpi_ec_remove,
diff --git a/drivers/acpi/events/evrgnini.c b/drivers/acpi/events/evrgnini.c
index 23ee7bc4a705..b1aaa0e84588 100644
--- a/drivers/acpi/events/evrgnini.c
+++ b/drivers/acpi/events/evrgnini.c
@@ -378,7 +378,7 @@ static u8 acpi_ev_match_pci_root_bridge(char *id)
 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
 {
         acpi_status status;
-        struct acpi_device_id hid;
+        struct acpica_device_id hid;
         struct acpi_compatible_id_list *cid;
         acpi_native_uint i;
 
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index ec655c539492..c81f6bdb68b8 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -50,10 +50,16 @@ static int acpi_fan_remove(struct acpi_device *device, int type);
 static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state);
 static int acpi_fan_resume(struct acpi_device *device);
 
+static const struct acpi_device_id fan_device_ids[] = {
+        {"PNP0C0B", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, fan_device_ids);
+
 static struct acpi_driver acpi_fan_driver = {
         .name = "fan",
         .class = ACPI_FAN_CLASS,
-        .ids = "PNP0C0B",
+        .ids = fan_device_ids,
         .ops = {
                 .add = acpi_fan_add,
                 .remove = acpi_fan_remove,
diff --git a/drivers/acpi/namespace/nsxfeval.c b/drivers/acpi/namespace/nsxfeval.c
index be4f2899de74..ab65b2c2560e 100644
--- a/drivers/acpi/namespace/nsxfeval.c
+++ b/drivers/acpi/namespace/nsxfeval.c
@@ -440,7 +440,7 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
         acpi_status status;
         struct acpi_namespace_node *node;
         u32 flags;
-        struct acpi_device_id hid;
+        struct acpica_device_id hid;
         struct acpi_compatible_id_list *cid;
         acpi_native_uint i;
 
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index 3448edd61dc4..c9f526e55392 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -46,7 +46,6 @@
 #define _COMPONENT              ACPI_PCI_COMPONENT
 ACPI_MODULE_NAME("pci_link");
 #define ACPI_PCI_LINK_CLASS             "pci_irq_routing"
-#define ACPI_PCI_LINK_HID               "PNP0C0F"
 #define ACPI_PCI_LINK_DEVICE_NAME       "PCI Interrupt Link"
 #define ACPI_PCI_LINK_FILE_INFO         "info"
 #define ACPI_PCI_LINK_FILE_STATUS       "state"
@@ -54,10 +53,16 @@ ACPI_MODULE_NAME("pci_link");
 static int acpi_pci_link_add(struct acpi_device *device);
 static int acpi_pci_link_remove(struct acpi_device *device, int type);
 
+static struct acpi_device_id link_device_ids[] = {
+        {"PNP0C0F", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, link_device_ids);
+
 static struct acpi_driver acpi_pci_link_driver = {
         .name = "pci_link",
         .class = ACPI_PCI_LINK_CLASS,
-        .ids = ACPI_PCI_LINK_HID,
+        .ids = link_device_ids,
         .ops = {
                 .add = acpi_pci_link_add,
                 .remove = acpi_pci_link_remove,
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index ad4145a37786..f14ff1ffab29 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -38,16 +38,21 @@
 #define _COMPONENT              ACPI_PCI_COMPONENT
 ACPI_MODULE_NAME("pci_root");
 #define ACPI_PCI_ROOT_CLASS             "pci_bridge"
-#define ACPI_PCI_ROOT_HID               "PNP0A03"
 #define ACPI_PCI_ROOT_DEVICE_NAME       "PCI Root Bridge"
 static int acpi_pci_root_add(struct acpi_device *device);
 static int acpi_pci_root_remove(struct acpi_device *device, int type);
 static int acpi_pci_root_start(struct acpi_device *device);
 
+static struct acpi_device_id root_device_ids[] = {
+        {"PNP0A03", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, root_device_ids);
+
 static struct acpi_driver acpi_pci_root_driver = {
         .name = "pci_root",
         .class = ACPI_PCI_ROOT_CLASS,
-        .ids = ACPI_PCI_ROOT_HID,
+        .ids = root_device_ids,
         .ops = {
                 .add = acpi_pci_root_add,
                 .remove = acpi_pci_root_remove,
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 4ffecd179702..57b9a2998fd0 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -59,10 +59,16 @@ static int acpi_power_remove(struct acpi_device *device, int type);
 static int acpi_power_resume(struct acpi_device *device);
 static int acpi_power_open_fs(struct inode *inode, struct file *file);
 
+static struct acpi_device_id power_device_ids[] = {
+        {ACPI_POWER_HID, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, power_device_ids);
+
 static struct acpi_driver acpi_power_driver = {
         .name = "power",
         .class = ACPI_POWER_CLASS,
-        .ids = ACPI_POWER_HID,
+        .ids = power_device_ids,
         .ops = {
                 .add = acpi_power_add,
                 .remove = acpi_power_remove,
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 81aceb5da7c7..498422343f38 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -88,10 +88,16 @@ static int acpi_processor_handle_eject(struct acpi_processor *pr);
 extern int acpi_processor_tstate_has_changed(struct acpi_processor *pr);
 
 
+static const struct acpi_device_id processor_device_ids[] = {
+        {ACPI_PROCESSOR_HID, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, processor_device_ids);
+
 static struct acpi_driver acpi_processor_driver = {
         .name = "processor",
         .class = ACPI_PROCESSOR_CLASS,
-        .ids = ACPI_PROCESSOR_HID,
+        .ids = processor_device_ids,
         .ops = {
                 .add = acpi_processor_add,
                 .remove = acpi_processor_remove,
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 3f55d1f90c11..0b8204e7082a 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -47,6 +47,9 @@ ACPI_MODULE_NAME("processor_throttling");
 static int acpi_processor_get_throttling(struct acpi_processor *pr);
 int acpi_processor_set_throttling(struct acpi_processor *pr, int state);
 
+/*
+ * _TPC - Throttling Present Capabilities
+ */
 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
 {
         acpi_status status = 0;
@@ -55,8 +58,10 @@ static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
         if (!pr)
                 return -EINVAL;
         status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
-        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
+        if (ACPI_FAILURE(status)) {
+                if (status != AE_NOT_FOUND) {
+                        ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
+                }
                 return -ENODEV;
         }
         pr->throttling_platform_limit = (int)tpc;
@@ -68,9 +73,9 @@ int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
         return acpi_processor_get_platform_limit(pr);
 }
 
-/* --------------------------------------------------------------------------
-                             _PTC, _TSS, _TSD support 
-   -------------------------------------------------------------------------- */
+/*
+ * _PTC - Processor Throttling Control (and status) register location
+ */
 static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
 {
         int result = 0;
@@ -81,7 +86,9 @@ static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
 
         status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
+                if (status != AE_NOT_FOUND) {
+                        ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
+                }
                 return -ENODEV;
         }
 
@@ -132,6 +139,10 @@ static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
 
         return result;
 }
+
+/*
+ * _TSS - Throttling Supported States
+ */
 static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
 {
         int result = 0;
@@ -144,7 +155,9 @@ static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
 
         status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
+                if (status != AE_NOT_FOUND) {
+                        ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
+                }
                 return -ENODEV;
         }
 
@@ -201,6 +214,10 @@ static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
 
         return result;
 }
+
+/*
+ * _TSD - T-State Dependencies
+ */
 static int acpi_processor_get_tsd(struct acpi_processor *pr)
 {
         int result = 0;
@@ -213,6 +230,9 @@ static int acpi_processor_get_tsd(struct acpi_processor *pr)
 
         status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
+                if (status != AE_NOT_FOUND) {
+                        ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD"));
+                }
                 return -ENODEV;
         }
 
@@ -525,9 +545,6 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
         int result = 0;
         int step = 0;
         int i = 0;
-        int no_ptc = 0;
-        int no_tss = 0;
-        int no_tsd = 0;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
@@ -538,12 +555,14 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
         if (!pr)
                 return -EINVAL;
 
-        /* TBD: Support ACPI 2.0 objects */
-        no_ptc = acpi_processor_get_throttling_control(pr);
-        no_tss = acpi_processor_get_throttling_states(pr);
-        no_tsd = acpi_processor_get_tsd(pr);
-
-        if (no_ptc || no_tss) {
+        /*
+         * Evaluate _PTC, _TSS and _TPC
+         * They must all be present or none of them can be used.
+         */
+        if (acpi_processor_get_throttling_control(pr) ||
+                acpi_processor_get_throttling_states(pr) ||
+                acpi_processor_get_platform_limit(pr))
+        {
                 pr->throttling.acpi_processor_get_throttling =
                     &acpi_processor_get_throttling_fadt;
                 pr->throttling.acpi_processor_set_throttling =
@@ -555,6 +574,8 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
                     &acpi_processor_set_throttling_ptc;
         }
 
+        acpi_processor_get_tsd(pr);
+
         if (!pr->throttling.address) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
                 return 0;
@@ -658,18 +679,20 @@ static int acpi_processor_throttling_seq_show(struct seq_file *seq,
                    pr->throttling.state_count - 1);
 
         seq_puts(seq, "states:\n");
-        if (acpi_processor_get_throttling == acpi_processor_get_throttling_fadt)
+        if (pr->throttling.acpi_processor_get_throttling ==
+                        acpi_processor_get_throttling_fadt) {
                 for (i = 0; i < pr->throttling.state_count; i++)
                         seq_printf(seq, "   %cT%d:                  %02d%%\n",
                                    (i == pr->throttling.state ? '*' : ' '), i,
                                    (pr->throttling.states[i].performance ? pr->
                                     throttling.states[i].performance / 10 : 0));
-        else
+        } else {
                 for (i = 0; i < pr->throttling.state_count; i++)
                         seq_printf(seq, "   %cT%d:                  %02d%%\n",
                                    (i == pr->throttling.state ? '*' : ' '), i,
                                    (int)pr->throttling.states_tss[i].
                                    freqpercentage);
+        }
 
       end:
         return 0;
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 974d00ccfe84..7d8e78ea13a5 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -38,7 +38,6 @@
 #define ACPI_SBS_CLASS                  "sbs"
 #define ACPI_AC_CLASS                   "ac_adapter"
 #define ACPI_BATTERY_CLASS              "battery"
-#define ACPI_SBS_HID                    "ACPI0002"
 #define ACPI_SBS_DEVICE_NAME            "Smart Battery System"
 #define ACPI_SBS_FILE_INFO              "info"
 #define ACPI_SBS_FILE_STATE             "state"
@@ -124,10 +123,17 @@ static int acpi_sbs_add(struct acpi_device *device);
 static int acpi_sbs_remove(struct acpi_device *device, int type);
 static int acpi_sbs_resume(struct acpi_device *device);
 
+static const struct acpi_device_id sbs_device_ids[] = {
+        {"ACPI0001", 0},
+        {"ACPI0005", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, sbs_device_ids);
+
 static struct acpi_driver acpi_sbs_driver = {
         .name = "sbs",
         .class = ACPI_SBS_CLASS,
-        .ids = "ACPI0001,ACPI0005",
+        .ids = sbs_device_ids,
         .ops = {
                 .add = acpi_sbs_add,
                 .remove = acpi_sbs_remove,
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 6b3b8a522476..be74347d1354 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -16,7 +16,7 @@ ACPI_MODULE_NAME("scan");
 extern struct acpi_device *acpi_root;
 
 #define ACPI_BUS_CLASS                  "system_bus"
-#define ACPI_BUS_HID                    "ACPI_BUS"
+#define ACPI_BUS_HID                    "LNXSYBUS"
 #define ACPI_BUS_DEVICE_NAME            "System Bus"
 
 static LIST_HEAD(acpi_device_list);
@@ -29,6 +29,62 @@ struct acpi_device_bus_id{
         unsigned int instance_no;
         struct list_head node;
 };
+
+/*
+ * Creates hid/cid(s) string needed for modalias and uevent
+ * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
+ * char *modalias: "acpi:IBM0001:ACPI0001"
+*/
+int create_modalias(struct acpi_device *acpi_dev, char *modalias, int size){
+
+        int len;
+
+        if (!acpi_dev->flags.hardware_id)
+                return -ENODEV;
+
+        len = snprintf(modalias, size, "acpi:%s:",
+                       acpi_dev->pnp.hardware_id);
+        if (len < 0 || len >= size)
+                return -EINVAL;
+        size -= len;
+
+        if (acpi_dev->flags.compatible_ids) {
+                struct acpi_compatible_id_list *cid_list;
+                int i;
+                int count;
+
+                cid_list = acpi_dev->pnp.cid_list;
+                for (i = 0; i < cid_list->count; i++) {
+                        count = snprintf(&modalias[len], size, "%s:",
+                                         cid_list->id[i].value);
+                        if (count < 0 || count >= size) {
+                                printk(KERN_ERR "acpi: %s cid[%i] exceeds event buffer size",
+                                       acpi_dev->pnp.device_name, i);
+                                break;
+                        }
+                        len += count;
+                        size -= count;
+                }
+        }
+
+        modalias[len] = '\0';
+        return len;
+}
+
+static ssize_t
+acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        int len;
+
+        /* Device has no HID and no CID or string is >1024 */
+        len = create_modalias(acpi_dev, buf, 1024);
+        if (len <= 0)
+                return 0;
+        buf[len++] = '\n';
+        return len;
+}
+static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
+
 static int acpi_eject_operation(acpi_handle handle, int lockable)
 {
         struct acpi_object_list arg_list;
@@ -154,6 +210,12 @@ static int acpi_device_setup_files(struct acpi_device *dev)
                         goto end;
         }
 
+        if (dev->flags.hardware_id || dev->flags.compatible_ids){
+                result = device_create_file(&dev->dev, &dev_attr_modalias);
+                if(result)
+                        goto end;
+        }
+
         /*
          * If device has _EJ0, 'eject' file is created that is used to trigger
          * hot-removal function from userland.
@@ -178,6 +240,9 @@ static void acpi_device_remove_files(struct acpi_device *dev)
         if (ACPI_SUCCESS(status))
                 device_remove_file(&dev->dev, &dev_attr_eject);
 
+        if (dev->flags.hardware_id || dev->flags.compatible_ids)
+                device_remove_file(&dev->dev, &dev_attr_modalias);
+
         if(dev->flags.hardware_id)
                 device_remove_file(&dev->dev, &dev_attr_hid);
         if(dev->handle)
@@ -186,6 +251,37 @@ static void acpi_device_remove_files(struct acpi_device *dev)
 /* --------------------------------------------------------------------------
                         ACPI Bus operations
    -------------------------------------------------------------------------- */
+
+int acpi_match_device_ids(struct acpi_device *device,
+                          const struct acpi_device_id *ids)
+{
+        const struct acpi_device_id *id;
+
+        if (device->flags.hardware_id) {
+                for (id = ids; id->id[0]; id++) {
+                        if (!strcmp((char*)id->id, device->pnp.hardware_id))
+                                return 0;
+                }
+        }
+
+        if (device->flags.compatible_ids) {
+                struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
+                int i;
+
+                for (id = ids; id->id[0]; id++) {
+                        /* compare multiple _CID entries against driver ids */
+                        for (i = 0; i < cid_list->count; i++) {
+                                if (!strcmp((char*)id->id,
+                                            cid_list->id[i].value))
+                                        return 0;
+                        }
+                }
+        }
+
+        return -ENOENT;
+}
+EXPORT_SYMBOL(acpi_match_device_ids);
+
 static void acpi_device_release(struct device *dev)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
@@ -219,37 +315,19 @@ static int acpi_bus_match(struct device *dev, struct device_driver *drv)
         struct acpi_device *acpi_dev = to_acpi_device(dev);
         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 
-        return !acpi_match_ids(acpi_dev, acpi_drv->ids);
+        return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 }
 
 static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
-        char *buffer, int buffer_size)
+                              char *buffer, int buffer_size)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
-        int i = 0, length = 0, ret = 0;
-
-        if (acpi_dev->flags.hardware_id)
-                ret = add_uevent_var(envp, num_envp, &i,
-                        buffer, buffer_size, &length,
-                        "HWID=%s", acpi_dev->pnp.hardware_id);
-        if (ret)
-                return -ENOMEM;
-        if (acpi_dev->flags.compatible_ids) {
-                int j;
-                struct acpi_compatible_id_list *cid_list;
 
-                cid_list = acpi_dev->pnp.cid_list;
-
-                for (j = 0; j < cid_list->count; j++) {
-                        ret = add_uevent_var(envp, num_envp, &i, buffer,
-                                buffer_size, &length, "COMPTID=%s",
-                                cid_list->id[j].value);
-                        if (ret)
-                                return -ENOMEM;
-                }
+        strcpy(buffer, "MODALIAS=");
+        if (create_modalias(acpi_dev, buffer + 9, buffer_size - 9) > 0) {
+                envp[0] = buffer;
+                envp[1] = NULL;
         }
-
-        envp[i] = NULL;
         return 0;
 }
 
@@ -543,25 +621,6 @@ void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
         return;
 }
 
-int acpi_match_ids(struct acpi_device *device, char *ids)
-{
-        if (device->flags.hardware_id)
-                if (strstr(ids, device->pnp.hardware_id))
-                        return 0;
-
-        if (device->flags.compatible_ids) {
-                struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
-                int i;
-
-                /* compare multiple _CID entries against driver ids */
-                for (i = 0; i < cid_list->count; i++) {
-                        if (strstr(ids, cid_list->id[i].value))
-                                return 0;
-                }
-        }
-        return -ENOENT;
-}
-
 static int acpi_bus_get_perf_flags(struct acpi_device *device)
 {
         device->performance.state = ACPI_STATE_UNKNOWN;
@@ -624,6 +683,13 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *package = NULL;
 
+        struct acpi_device_id button_device_ids[] = {
+                {"PNP0C0D", 0},
+                {"PNP0C0C", 0},
+                {"PNP0C0E", 0},
+                {"", 0},
+        };
+
 
         /* _PRW */
         status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
@@ -643,7 +709,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 
         device->wakeup.flags.valid = 1;
         /* Power button, Lid switch always enable wakeup */
-        if (!acpi_match_ids(device, "PNP0C0D,PNP0C0C,PNP0C0E"))
+        if (!acpi_match_device_ids(device, button_device_ids))
                 device->wakeup.flags.run_wake = 1;
 
       end:
diff --git a/drivers/acpi/sleep/Makefile b/drivers/acpi/sleep/Makefile
index d6c017709c85..195a4f69c0f7 100644
--- a/drivers/acpi/sleep/Makefile
+++ b/drivers/acpi/sleep/Makefile
@@ -1,5 +1,5 @@
 obj-y                                   := poweroff.o wakeup.o
 obj-$(CONFIG_ACPI_SLEEP)                += main.o
-obj-$(CONFIG_ACPI_SLEEP_PROC_FS)        += proc.o
+obj-$(CONFIG_ACPI_SLEEP)                += proc.o
 
 EXTRA_CFLAGS += $(ACPI_CFLAGS)
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index 3279e72a94f8..e8cff5dd4cbc 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -21,6 +21,9 @@
 
 u8 sleep_states[ACPI_S_STATE_COUNT];
 
+static u32 acpi_target_sleep_state = ACPI_STATE_S0;
+
+#ifdef CONFIG_SUSPEND
 static struct pm_ops acpi_pm_ops;
 
 extern void do_suspend_lowlevel(void);
@@ -35,34 +38,49 @@ static u32 acpi_suspend_states[] = {
 static int init_8259A_after_S1;
 
 /**
+ *      acpi_pm_set_target - Set the target system sleep state to the state
+ *              associated with given @pm_state, if supported.
+ */
+
+static int acpi_pm_set_target(suspend_state_t pm_state)
+{
+        u32 acpi_state = acpi_suspend_states[pm_state];
+        int error = 0;
+
+        if (sleep_states[acpi_state]) {
+                acpi_target_sleep_state = acpi_state;
+        } else {
+                printk(KERN_ERR "ACPI does not support this state: %d\n",
+                        pm_state);
+                error = -ENOSYS;
+        }
+        return error;
+}
+
+/**
  *      acpi_pm_prepare - Do preliminary suspend work.
- *      @pm_state:              suspend state we're entering.
+ *      @pm_state: ignored
  *
- *      Make sure we support the state. If we do, and we need it, set the
- *      firmware waking vector and do arch-specific nastiness to get the 
- *      wakeup code to the waking vector. 
+ *      If necessary, set the firmware waking vector and do arch-specific
+ *      nastiness to get the wakeup code to the waking vector.
  */
 
-extern int acpi_sleep_prepare(u32 acpi_state);
-extern void acpi_power_off(void);
-
 static int acpi_pm_prepare(suspend_state_t pm_state)
 {
-        u32 acpi_state = acpi_suspend_states[pm_state];
+        int error = acpi_sleep_prepare(acpi_target_sleep_state);
 
-        if (!sleep_states[acpi_state]) {
-                printk("acpi_pm_prepare does not support %d \n", pm_state);
-                return -EPERM;
-        }
-        return acpi_sleep_prepare(acpi_state);
+        if (error)
+                acpi_target_sleep_state = ACPI_STATE_S0;
+
+        return error;
 }
 
 /**
  *      acpi_pm_enter - Actually enter a sleep state.
- *      @pm_state:              State we're entering.
+ *      @pm_state: ignored
  *
- *      Flush caches and go to sleep. For STR or STD, we have to call 
- *      arch-specific assembly, which in turn call acpi_enter_sleep_state().
+ *      Flush caches and go to sleep. For STR we have to call arch-specific
+ *      assembly, which in turn call acpi_enter_sleep_state().
  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
  */
 
@@ -70,31 +88,31 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 {
         acpi_status status = AE_OK;
         unsigned long flags = 0;
-        u32 acpi_state = acpi_suspend_states[pm_state];
+        u32 acpi_state = acpi_target_sleep_state;
 
         ACPI_FLUSH_CPU_CACHE();
 
         /* Do arch specific saving of state. */
-        if (pm_state > PM_SUSPEND_STANDBY) {
+        if (acpi_state == ACPI_STATE_S3) {
                 int error = acpi_save_state_mem();
-                if (error)
+
+                if (error) {
+                        acpi_target_sleep_state = ACPI_STATE_S0;
                         return error;
+                }
         }
 
         local_irq_save(flags);
         acpi_enable_wakeup_device(acpi_state);
-        switch (pm_state) {
-        case PM_SUSPEND_STANDBY:
+        switch (acpi_state) {
+        case ACPI_STATE_S1:
                 barrier();
                 status = acpi_enter_sleep_state(acpi_state);
                 break;
 
-        case PM_SUSPEND_MEM:
+        case ACPI_STATE_S3:
                 do_suspend_lowlevel();
                 break;
-
-        default:
-                return -EINVAL;
         }
 
         /* ACPI 3.0 specs (P62) says that it's the responsabilty
@@ -107,12 +125,8 @@ static int acpi_pm_enter(suspend_state_t pm_state)
         local_irq_restore(flags);
         printk(KERN_DEBUG "Back to C!\n");
 
-        /* restore processor state
-         * We should only be here if we're coming back from STR or STD.
-         * And, in the case of the latter, the memory image should have already
-         * been loaded from disk.
-         */
-        if (pm_state > PM_SUSPEND_STANDBY)
+        /* restore processor state */
+        if (acpi_state == ACPI_STATE_S3)
                 acpi_restore_state_mem();
 
         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
@@ -120,7 +134,7 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 
 /**
  *      acpi_pm_finish - Finish up suspend sequence.
- *      @pm_state:              State we're coming out of.
+ *      @pm_state: ignored
  *
  *      This is called after we wake back up (or if entering the sleep state
  *      failed). 
@@ -128,7 +142,7 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 
 static int acpi_pm_finish(suspend_state_t pm_state)
 {
-        u32 acpi_state = acpi_suspend_states[pm_state];
+        u32 acpi_state = acpi_target_sleep_state;
 
         acpi_leave_sleep_state(acpi_state);
         acpi_disable_wakeup_device(acpi_state);
@@ -136,28 +150,17 @@ static int acpi_pm_finish(suspend_state_t pm_state)
         /* reset firmware waking vector */
         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
 
+        acpi_target_sleep_state = ACPI_STATE_S0;
+
+#ifdef CONFIG_X86
         if (init_8259A_after_S1) {
                 printk("Broken toshiba laptop -> kicking interrupts\n");
                 init_8259A(0);
         }
+#endif
         return 0;
 }
 
-int acpi_suspend(u32 acpi_state)
-{
-        suspend_state_t states[] = {
-                [1] = PM_SUSPEND_STANDBY,
-                [3] = PM_SUSPEND_MEM,
-                [5] = PM_SUSPEND_MAX
-        };
-
-        if (acpi_state < 6 && states[acpi_state])
-                return pm_suspend(states[acpi_state]);
-        if (acpi_state == 4)
-                return hibernate();
-        return -EINVAL;
-}
-
 static int acpi_pm_state_valid(suspend_state_t pm_state)
 {
         u32 acpi_state;
@@ -176,12 +179,34 @@ static int acpi_pm_state_valid(suspend_state_t pm_state)
 
 static struct pm_ops acpi_pm_ops = {
         .valid = acpi_pm_state_valid,
+        .set_target = acpi_pm_set_target,
         .prepare = acpi_pm_prepare,
         .enter = acpi_pm_enter,
         .finish = acpi_pm_finish,
 };
 
-#ifdef CONFIG_SOFTWARE_SUSPEND
+/*
+ * Toshiba fails to preserve interrupts over S1, reinitialization
+ * of 8259 is needed after S1 resume.
+ */
+static int __init init_ints_after_s1(struct dmi_system_id *d)
+{
+        printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
+        init_8259A_after_S1 = 1;
+        return 0;
+}
+
+static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
+        {
+         .callback = init_ints_after_s1,
+         .ident = "Toshiba Satellite 4030cdt",
+         .matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
+         },
+        {},
+};
+#endif /* CONFIG_SUSPEND */
+
+#ifdef CONFIG_HIBERNATION
 static int acpi_hibernation_prepare(void)
 {
         return acpi_sleep_prepare(ACPI_STATE_S4);
@@ -233,41 +258,114 @@ static struct hibernation_ops acpi_hibernation_ops = {
         .pre_restore = acpi_hibernation_pre_restore,
         .restore_cleanup = acpi_hibernation_restore_cleanup,
 };
-#endif                          /* CONFIG_SOFTWARE_SUSPEND */
+#endif                          /* CONFIG_HIBERNATION */
 
-/*
- * Toshiba fails to preserve interrupts over S1, reinitialization
- * of 8259 is needed after S1 resume.
- */
-static int __init init_ints_after_s1(struct dmi_system_id *d)
+int acpi_suspend(u32 acpi_state)
 {
-        printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
-        init_8259A_after_S1 = 1;
-        return 0;
+        suspend_state_t states[] = {
+                [1] = PM_SUSPEND_STANDBY,
+                [3] = PM_SUSPEND_MEM,
+                [5] = PM_SUSPEND_MAX
+        };
+
+        if (acpi_state < 6 && states[acpi_state])
+                return pm_suspend(states[acpi_state]);
+        if (acpi_state == 4)
+                return hibernate();
+        return -EINVAL;
 }
 
-static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
-        {
-         .callback = init_ints_after_s1,
-         .ident = "Toshiba Satellite 4030cdt",
-         .matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
-         },
-        {},
-};
+/**
+ *      acpi_pm_device_sleep_state - return preferred power state of ACPI device
+ *              in the system sleep state given by %acpi_target_sleep_state
+ *      @dev: device to examine
+ *      @wake: if set, the device should be able to wake up the system
+ *      @d_min_p: used to store the upper limit of allowed states range
+ *      Return value: preferred power state of the device on success, -ENODEV on
+ *              failure (ie. if there's no 'struct acpi_device' for @dev)
+ *
+ *      Find the lowest power (highest number) ACPI device power state that
+ *      device @dev can be in while the system is in the sleep state represented
+ *      by %acpi_target_sleep_state.  If @wake is nonzero, the device should be
+ *      able to wake up the system from this sleep state.  If @d_min_p is set,
+ *      the highest power (lowest number) device power state of @dev allowed
+ *      in this system sleep state is stored at the location pointed to by it.
+ *
+ *      The caller must ensure that @dev is valid before using this function.
+ *      The caller is also responsible for figuring out if the device is
+ *      supposed to be able to wake up the system and passing this information
+ *      via @wake.
+ */
+
+int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
+{
+        acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
+        struct acpi_device *adev;
+        char acpi_method[] = "_SxD";
+        unsigned long d_min, d_max;
+
+        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
+                printk(KERN_ERR "ACPI handle has no context!\n");
+                return -ENODEV;
+        }
+
+        acpi_method[2] = '0' + acpi_target_sleep_state;
+        /*
+         * If the sleep state is S0, we will return D3, but if the device has
+         * _S0W, we will use the value from _S0W
+         */
+        d_min = ACPI_STATE_D0;
+        d_max = ACPI_STATE_D3;
+
+        /*
+         * If present, _SxD methods return the minimum D-state (highest power
+         * state) we can use for the corresponding S-states.  Otherwise, the
+         * minimum D-state is D0 (ACPI 3.x).
+         *
+         * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
+         * provided -- that's our fault recovery, we ignore retval.
+         */
+        if (acpi_target_sleep_state > ACPI_STATE_S0)
+                acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
+
+        /*
+         * If _PRW says we can wake up the system from the target sleep state,
+         * the D-state returned by _SxD is sufficient for that (we assume a
+         * wakeup-aware driver if wake is set).  Still, if _SxW exists
+         * (ACPI 3.x), it should return the maximum (lowest power) D-state that
+         * can wake the system.  _S0W may be valid, too.
+         */
+        if (acpi_target_sleep_state == ACPI_STATE_S0 ||
+            (wake && adev->wakeup.state.enabled &&
+             adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
+                acpi_method[3] = 'W';
+                acpi_evaluate_integer(handle, acpi_method, NULL, &d_max);
+                /* Sanity check */
+                if (d_max < d_min)
+                        d_min = d_max;
+        }
+
+        if (d_min_p)
+                *d_min_p = d_min;
+        return d_max;
+}
 
 int __init acpi_sleep_init(void)
 {
+        acpi_status status;
+        u8 type_a, type_b;
+#ifdef CONFIG_SUSPEND
         int i = 0;
 
         dmi_check_system(acpisleep_dmi_table);
+#endif
 
         if (acpi_disabled)
                 return 0;
 
+#ifdef CONFIG_SUSPEND
         printk(KERN_INFO PREFIX "(supports");
-        for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
-                acpi_status status;
-                u8 type_a, type_b;
+        for (i = ACPI_STATE_S0; i < ACPI_STATE_S4; i++) {
                 status = acpi_get_sleep_type_data(i, &type_a, &type_b);
                 if (ACPI_SUCCESS(status)) {
                         sleep_states[i] = 1;
@@ -277,10 +375,14 @@ int __init acpi_sleep_init(void)
         printk(")\n");
 
         pm_set_ops(&acpi_pm_ops);
+#endif
 
-#ifdef CONFIG_SOFTWARE_SUSPEND
-        if (sleep_states[ACPI_STATE_S4])
+#ifdef CONFIG_HIBERNATION
+        status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
+        if (ACPI_SUCCESS(status)) {
                 hibernation_set_ops(&acpi_hibernation_ops);
+                sleep_states[ACPI_STATE_S4] = 1;
+        }
 #else
         sleep_states[ACPI_STATE_S4] = 0;
 #endif
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index 61f1822cc350..66b62b0d3609 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -14,8 +14,16 @@
 #include "sleep.h"
 
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
+
+/*
+ * this file provides support for:
+ * /proc/acpi/sleep
+ * /proc/acpi/alarm
+ * /proc/acpi/wakeup
+ */
+
 ACPI_MODULE_NAME("sleep")
-#ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
+#ifdef  CONFIG_ACPI_PROCFS_SLEEP
 static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
 {
         int i;
@@ -58,7 +66,7 @@ acpi_system_write_sleep(struct file *file,
                 goto Done;
         }
         state = simple_strtoul(str, NULL, 0);
-#ifdef CONFIG_SOFTWARE_SUSPEND
+#ifdef CONFIG_HIBERNATION
         if (state == 4) {
                 error = hibernate();
                 goto Done;
@@ -68,9 +76,9 @@ acpi_system_write_sleep(struct file *file,
       Done:
         return error ? error : count;
 }
-#endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
+#endif                          /* CONFIG_ACPI_PROCFS_SLEEP */
 
-#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
+#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) || !defined(CONFIG_X86)
 /* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
 #else
 #define HAVE_ACPI_LEGACY_ALARM
@@ -463,7 +471,7 @@ static const struct file_operations acpi_system_wakeup_device_fops = {
         .release = single_release,
 };
 
-#ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
+#ifdef  CONFIG_ACPI_PROCFS_SLEEP
 static const struct file_operations acpi_system_sleep_fops = {
         .open = acpi_system_sleep_open_fs,
         .read = seq_read,
@@ -471,7 +479,7 @@ static const struct file_operations acpi_system_sleep_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
-#endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
+#endif                          /* CONFIG_ACPI_PROCFS_SLEEP */
 
 #ifdef  HAVE_ACPI_LEGACY_ALARM
 static const struct file_operations acpi_system_alarm_fops = {
@@ -498,14 +506,14 @@ static int __init acpi_sleep_proc_init(void)
         if (acpi_disabled)
                 return 0;
 
-#ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
+#ifdef  CONFIG_ACPI_PROCFS_SLEEP
         /* 'sleep' [R/W] */
         entry =
             create_proc_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
                               acpi_root_dir);
         if (entry)
                 entry->proc_fops = &acpi_system_sleep_fops;
-#endif
+#endif                          /* CONFIG_ACPI_PROCFS */
 
 #ifdef  HAVE_ACPI_LEGACY_ALARM
         /* 'alarm' [R/W] */
diff --git a/drivers/acpi/sleep/sleep.h b/drivers/acpi/sleep/sleep.h
index f3e70397a7d6..ff1f8504f497 100644
--- a/drivers/acpi/sleep/sleep.h
+++ b/drivers/acpi/sleep/sleep.h
@@ -6,3 +6,5 @@ extern void acpi_enable_wakeup_device_prep(u8 sleep_state);
 extern void acpi_enable_wakeup_device(u8 sleep_state);
 extern void acpi_disable_wakeup_device(u8 sleep_state);
 extern void acpi_gpe_sleep_prepare(u32 sleep_state);
+
+extern int acpi_sleep_prepare(u32 acpi_state);
diff --git a/drivers/acpi/sleep/wakeup.c b/drivers/acpi/sleep/wakeup.c
index fab8f2694f03..97c27ddb144d 100644
--- a/drivers/acpi/sleep/wakeup.c
+++ b/drivers/acpi/sleep/wakeup.c
@@ -17,7 +17,6 @@ ACPI_MODULE_NAME("wakeup_devices")
 extern struct list_head acpi_wakeup_device_list;
 extern spinlock_t acpi_device_lock;
 
-#ifdef CONFIG_ACPI_SLEEP
 /**
  * acpi_enable_wakeup_device_prep - prepare wakeup devices
  *      @sleep_state:   ACPI state
@@ -180,7 +179,6 @@ static int __init acpi_wakeup_device_init(void)
 }
 
 late_initcall(acpi_wakeup_device_init);
-#endif
 
 /*
  * Disable all wakeup GPEs before entering requested sleep state.
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 58f1338981bc..5a62de1b7f2a 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -92,10 +92,16 @@ static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
 static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
                                           size_t, loff_t *);
 
+static const struct acpi_device_id  thermal_device_ids[] = {
+        {ACPI_THERMAL_HID, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
+
 static struct acpi_driver acpi_thermal_driver = {
         .name = "thermal",
         .class = ACPI_THERMAL_CLASS,
-        .ids = ACPI_THERMAL_HID,
+        .ids = thermal_device_ids,
         .ops = {
                 .add = acpi_thermal_add,
                 .remove = acpi_thermal_remove,
diff --git a/drivers/acpi/utilities/uteval.c b/drivers/acpi/utilities/uteval.c
index f112af433e36..0042b7e78b26 100644
--- a/drivers/acpi/utilities/uteval.c
+++ b/drivers/acpi/utilities/uteval.c
@@ -407,7 +407,7 @@ acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length)
 
 acpi_status
 acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
-                    struct acpi_device_id *hid)
+                    struct acpica_device_id *hid)
 {
         union acpi_operand_object *obj_desc;
         acpi_status status;
@@ -609,7 +609,7 @@ acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
 
 acpi_status
 acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
-                    struct acpi_device_id *uid)
+                    struct acpica_device_id *uid)
 {
         union acpi_operand_object *obj_desc;
         acpi_status status;
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 04ea697f72bf..d98701941981 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -74,10 +74,16 @@ MODULE_LICENSE("GPL");
 static int acpi_video_bus_add(struct acpi_device *device);
 static int acpi_video_bus_remove(struct acpi_device *device, int type);
 
+static const struct acpi_device_id video_device_ids[] = {
+        {ACPI_VIDEO_HID, 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, video_device_ids);
+
 static struct acpi_driver acpi_video_bus = {
         .name = "video",
         .class = ACPI_VIDEO_CLASS,
-        .ids = ACPI_VIDEO_HID,
+        .ids = video_device_ids,
         .ops = {
                 .add = acpi_video_bus_add,
                 .remove = acpi_video_bus_remove,