13 files changed, 276 insertions, 126 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 408b45168aba..251344cb29ae 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -11,6 +11,9 @@ menuconfig ACPI
         depends on PCI
         depends on PM
         select PNP
+        # for sleep
+        select HOTPLUG_CPU if X86 && SMP
+        select SUSPEND_SMP if X86 && SMP
         default y
         ---help---
           Advanced Configuration and Power Interface (ACPI) support for 
@@ -42,51 +45,26 @@ 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
-        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/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/sleep/Makefile b/drivers/acpi/sleep/Makefile
index d6c017709c85..01a993a1d086 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-y                                   += main.o
+obj-$(CONFIG_X86)                       += proc.o
 
 EXTRA_CFLAGS += $(ACPI_CFLAGS)
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index 3279e72a94f8..ab21357c5c7b 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -34,35 +34,55 @@ static u32 acpi_suspend_states[] = {
 
 static int init_8259A_after_S1;
 
+extern int acpi_sleep_prepare(u32 acpi_state);
+extern void acpi_power_off(void);
+
+static u32 acpi_target_sleep_state = ACPI_STATE_S0;
+
+/**
+ *      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 +90,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 +127,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 +136,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 +144,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,10 +152,14 @@ 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;
 }
 
@@ -176,6 +196,7 @@ 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,
@@ -235,6 +256,81 @@ static struct hibernation_ops acpi_hibernation_ops = {
 };
 #endif                          /* CONFIG_SOFTWARE_SUSPEND */
 
+/**
+ *      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;
+}
+
 /*
  * Toshiba fails to preserve interrupts over S1, reinitialization
  * of 8259 is needed after S1 resume.
diff --git a/drivers/acpi/sleep/poweroff.c b/drivers/acpi/sleep/poweroff.c
index 39e40d56b034..b3f68ef0669e 100644
--- a/drivers/acpi/sleep/poweroff.c
+++ b/drivers/acpi/sleep/poweroff.c
@@ -18,7 +18,6 @@
 
 int acpi_sleep_prepare(u32 acpi_state)
 {
-#ifdef CONFIG_ACPI_SLEEP
         /* do we have a wakeup address for S2 and S3? */
         if (acpi_state == ACPI_STATE_S3) {
                 if (!acpi_wakeup_address) {
@@ -31,7 +30,6 @@ int acpi_sleep_prepare(u32 acpi_state)
         }
         ACPI_FLUSH_CPU_CACHE();
         acpi_enable_wakeup_device_prep(acpi_state);
-#endif
         acpi_gpe_sleep_prepare(acpi_state);
         acpi_enter_sleep_state_prep(acpi_state);
         return 0;
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index 61f1822cc350..ed58e1168aed 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
 static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
 {
         int i;
@@ -68,7 +76,7 @@ acpi_system_write_sleep(struct file *file,
       Done:
         return error ? error : count;
 }
-#endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
+#endif                          /* CONFIG_ACPI_PROCFS */
 
 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
 /* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
@@ -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
 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 */
 
 #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' [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/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/misc/asus-laptop.c b/drivers/misc/asus-laptop.c
index 63953fe03320..d0fc4fd212e6 100644
--- a/drivers/misc/asus-laptop.c
+++ b/drivers/misc/asus-laptop.c
@@ -1072,19 +1072,16 @@ static void asus_backlight_exit(void)
 }
 
 #define  ASUS_LED_UNREGISTER(object)                            \
-        if(object##_led.class_dev                               \
-           && !IS_ERR(object##_led.class_dev))                  \
-                led_classdev_unregister(&object##_led)
+        led_classdev_unregister(&object##_led)
 
 static void asus_led_exit(void)
 {
+        destroy_workqueue(led_workqueue);
         ASUS_LED_UNREGISTER(mled);
         ASUS_LED_UNREGISTER(tled);
         ASUS_LED_UNREGISTER(pled);
         ASUS_LED_UNREGISTER(rled);
         ASUS_LED_UNREGISTER(gled);
-
-        destroy_workqueue(led_workqueue);
 }
 
 static void __exit asus_laptop_exit(void)
@@ -1140,29 +1137,42 @@ static int asus_led_init(struct device *dev)
 
         rv = ASUS_LED_REGISTER(mled, dev);
         if (rv)
-                return rv;
+                goto out;
 
         rv = ASUS_LED_REGISTER(tled, dev);
         if (rv)
-                return rv;
+                goto out1;
 
         rv = ASUS_LED_REGISTER(rled, dev);
         if (rv)
-                return rv;
+                goto out2;
 
         rv = ASUS_LED_REGISTER(pled, dev);
         if (rv)
-                return rv;
+                goto out3;
 
         rv = ASUS_LED_REGISTER(gled, dev);
         if (rv)
-                return rv;
+                goto out4;
 
         led_workqueue = create_singlethread_workqueue("led_workqueue");
         if (!led_workqueue)
-                return -ENOMEM;
+                goto out5;
 
         return 0;
+out5:
+        rv = -ENOMEM;
+        ASUS_LED_UNREGISTER(gled);
+out4:
+        ASUS_LED_UNREGISTER(pled);
+out3:
+        ASUS_LED_UNREGISTER(rled);
+out2:
+        ASUS_LED_UNREGISTER(tled);
+out1:
+        ASUS_LED_UNREGISTER(mled);
+out:
+        return rv;
 }
 
 static int __init asus_laptop_init(void)
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index c8062494009f..67c63d1f1582 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -245,16 +245,33 @@ EXPORT_SYMBOL(pci_osc_control_set);
  * currently we simply return _SxD, if present.
  */
 
-static int acpi_pci_choose_state(struct pci_dev *pdev, pm_message_t state)
+static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev,
+        pm_message_t state)
 {
-        /* TBD */
-
-        return -ENODEV;
+        int acpi_state;
+
+        acpi_state = acpi_pm_device_sleep_state(&pdev->dev,
+                device_may_wakeup(&pdev->dev), NULL);
+        if (acpi_state < 0)
+                return PCI_POWER_ERROR;
+
+        switch (acpi_state) {
+        case ACPI_STATE_D0:
+                return PCI_D0;
+        case ACPI_STATE_D1:
+                return PCI_D1;
+        case ACPI_STATE_D2:
+                return PCI_D2;
+        case ACPI_STATE_D3:
+                return PCI_D3hot;
+        }
+        return PCI_POWER_ERROR;
 }
 
 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 {
         acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
+        acpi_handle tmp;
         static int state_conv[] = {
                 [0] = 0,
                 [1] = 1,
@@ -266,6 +283,9 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 
         if (!handle)
                 return -ENODEV;
+        /* If the ACPI device has _EJ0, ignore the device */
+        if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
+                return 0;
         return acpi_bus_set_power(handle, acpi_state);
 }
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 03fd59e80fef..1458fd69e670 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -499,7 +499,7 @@ pci_set_power_state(struct pci_dev *dev, pci_power_t state)
         return 0;
 }
 
-int (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
+pci_power_t (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
  
 /**
  * pci_choose_state - Choose the power state of a PCI device
@@ -513,15 +513,15 @@ int (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
 
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)
 {
-        int ret;
+        pci_power_t ret;
 
         if (!pci_find_capability(dev, PCI_CAP_ID_PM))
                 return PCI_D0;
 
         if (platform_pci_choose_state) {
                 ret = platform_pci_choose_state(dev, state);
-                if (ret >= 0)
-                        state.event = ret;
+                if (ret != PCI_POWER_ERROR)
+                        return ret;
         }
 
         switch (state.event) {
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 3fec13d3add7..c293ba1f274a 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -13,7 +13,7 @@ extern int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
                                               resource_size_t, resource_size_t),
                                   void *alignf_data);
 /* Firmware callbacks */
-extern int (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
+extern pci_power_t (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
 extern int (*platform_pci_set_power_state)(struct pci_dev *dev, pci_power_t state);
 
 extern int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index e161423b4300..1432806451cd 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -167,6 +167,8 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state)
                         return error;
         }
 
+        if (pnp_dev->protocol && pnp_dev->protocol->suspend)
+                pnp_dev->protocol->suspend(pnp_dev, state);
         return 0;
 }
 
@@ -179,6 +181,9 @@ static int pnp_bus_resume(struct device *dev)
         if (!pnp_drv)
                 return 0;
 
+        if (pnp_dev->protocol && pnp_dev->protocol->resume)
+                pnp_dev->protocol->resume(pnp_dev);
+
         if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) {
                 error = pnp_start_dev(pnp_dev);
                 if (error)
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index 0bc889144e6f..fcd32ac575c3 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -124,11 +124,25 @@ static int pnpacpi_disable_resources(struct pnp_dev *dev)
         return ACPI_FAILURE(status) ? -ENODEV : 0;
 }
 
+static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
+{
+        return acpi_bus_set_power((acpi_handle)dev->data,
+                acpi_pm_device_sleep_state(&dev->dev,
+                device_may_wakeup(&dev->dev), NULL));
+}
+
+static int pnpacpi_resume(struct pnp_dev *dev)
+{
+        return acpi_bus_set_power((acpi_handle)dev->data, ACPI_STATE_D0);
+}
+
 static struct pnp_protocol pnpacpi_protocol = {
         .name   = "Plug and Play ACPI",
         .get    = pnpacpi_get_resources,
         .set    = pnpacpi_set_resources,
         .disable = pnpacpi_disable_resources,
+        .suspend = pnpacpi_suspend,
+        .resume = pnpacpi_resume,
 };
 
 static int __init pnpacpi_add_device(struct acpi_device *device)