9 files changed, 706 insertions, 190 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index bba867391a85..735f5ea17473 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -336,6 +336,15 @@ config ACPI_EC
           the battery and thermal drivers.  If you are compiling for a 
           mobile system, say Y.
 
+config ACPI_PCI_SLOT
+        tristate "PCI slot detection driver"
+        default n
+        help
+          This driver will attempt to discover all PCI slots in your system,
+          and creates entries in /sys/bus/pci/slots/. This feature can
+          help you correlate PCI bus addresses with the physical geography
+          of your slots. If you are unsure, say N.
+
 config ACPI_POWER
         bool
         default y
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 4efbe598c817..52a4cd4b81d0 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_ACPI_DOCK)		+= dock.o
 obj-$(CONFIG_ACPI_BAY)          += bay.o
 obj-$(CONFIG_ACPI_VIDEO)        += video.o
 obj-y                           += pci_root.o pci_link.o pci_irq.o pci_bind.o
+obj-$(CONFIG_ACPI_PCI_SLOT)     += pci_slot.o
 obj-$(CONFIG_ACPI_POWER)        += power.o
 obj-$(CONFIG_ACPI_PROCESSOR)    += processor.o
 obj-$(CONFIG_ACPI_CONTAINER)    += container.o
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index afb34387d5f2..ccae305ee55d 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -295,6 +295,28 @@ int acpi_bus_set_power(acpi_handle handle, int state)
 
 EXPORT_SYMBOL(acpi_bus_set_power);
 
+bool acpi_bus_power_manageable(acpi_handle handle)
+{
+        struct acpi_device *device;
+        int result;
+
+        result = acpi_bus_get_device(handle, &device);
+        return result ? false : device->flags.power_manageable;
+}
+
+EXPORT_SYMBOL(acpi_bus_power_manageable);
+
+bool acpi_bus_can_wakeup(acpi_handle handle)
+{
+        struct acpi_device *device;
+        int result;
+
+        result = acpi_bus_get_device(handle, &device);
+        return result ? false : device->wakeup.flags.valid;
+}
+
+EXPORT_SYMBOL(acpi_bus_can_wakeup);
+
 /* --------------------------------------------------------------------------
                                 Event Management
    -------------------------------------------------------------------------- */
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 6d18ca34b6aa..0f2dd81736bd 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -166,6 +166,8 @@ static int acpi_bind_one(struct device *dev, acpi_handle handle)
                                 "firmware_node");
                 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
                                 "physical_node");
+                if (acpi_dev->wakeup.flags.valid)
+                        device_set_wakeup_capable(dev, true);
         }
 
         return 0;
diff --git a/drivers/acpi/pci_slot.c b/drivers/acpi/pci_slot.c
new file mode 100644
index 000000000000..b9ab030a52d5
--- /dev/null
+++ b/drivers/acpi/pci_slot.c
@@ -0,0 +1,368 @@
+/*
+ *  pci_slot.c - ACPI PCI Slot Driver
+ *
+ *  The code here is heavily leveraged from the acpiphp module.
+ *  Thanks to Matthew Wilcox <matthew@wil.cx> for much guidance.
+ *  Thanks to Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com> for code
+ *  review and fixes.
+ *
+ *  Copyright (C) 2007 Alex Chiang <achiang@hp.com>
+ *  Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms and conditions of the GNU General Public License,
+ *  version 2, as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+static int debug;
+static int check_sta_before_sun;
+
+#define DRIVER_VERSION  "0.1"
+#define DRIVER_AUTHOR   "Alex Chiang <achiang@hp.com>"
+#define DRIVER_DESC     "ACPI PCI Slot Detection Driver"
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
+module_param(debug, bool, 0644);
+
+#define _COMPONENT              ACPI_PCI_COMPONENT
+ACPI_MODULE_NAME("pci_slot");
+
+#define MY_NAME "pci_slot"
+#define err(format, arg...) printk(KERN_ERR "%s: " format , MY_NAME , ## arg)
+#define info(format, arg...) printk(KERN_INFO "%s: " format , MY_NAME , ## arg)
+#define dbg(format, arg...)                                     \
+        do {                                                    \
+                if (debug)                                      \
+                        printk(KERN_DEBUG "%s: " format,        \
+                                MY_NAME , ## arg);              \
+        } while (0)
+
+#define SLOT_NAME_SIZE 20               /* Inspired by #define in acpiphp.h */
+
+struct acpi_pci_slot {
+        acpi_handle root_handle;        /* handle of the root bridge */
+        struct pci_slot *pci_slot;      /* corresponding pci_slot */
+        struct list_head list;          /* node in the list of slots */
+};
+
+static int acpi_pci_slot_add(acpi_handle handle);
+static void acpi_pci_slot_remove(acpi_handle handle);
+
+static LIST_HEAD(slot_list);
+static DEFINE_MUTEX(slot_list_lock);
+static struct acpi_pci_driver acpi_pci_slot_driver = {
+        .add = acpi_pci_slot_add,
+        .remove = acpi_pci_slot_remove,
+};
+
+static int
+check_slot(acpi_handle handle, int *device, unsigned long *sun)
+{
+        int retval = 0;
+        unsigned long adr, sta;
+        acpi_status status;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
+        dbg("Checking slot on path: %s\n", (char *)buffer.pointer);
+
+        if (check_sta_before_sun) {
+                /* If SxFy doesn't have _STA, we just assume it's there */
+                status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
+                if (ACPI_SUCCESS(status) && !(sta & ACPI_STA_DEVICE_PRESENT)) {
+                        retval = -1;
+                        goto out;
+                }
+        }
+
+        status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
+        if (ACPI_FAILURE(status)) {
+                dbg("_ADR returned %d on %s\n", status, (char *)buffer.pointer);
+                retval = -1;
+                goto out;
+        }
+
+        *device = (adr >> 16) & 0xffff;
+
+        /* No _SUN == not a slot == bail */
+        status = acpi_evaluate_integer(handle, "_SUN", NULL, sun);
+        if (ACPI_FAILURE(status)) {
+                dbg("_SUN returned %d on %s\n", status, (char *)buffer.pointer);
+                retval = -1;
+                goto out;
+        }
+
+out:
+        kfree(buffer.pointer);
+        return retval;
+}
+
+struct callback_args {
+        acpi_walk_callback      user_function;  /* only for walk_p2p_bridge */
+        struct pci_bus          *pci_bus;
+        acpi_handle             root_handle;
+};
+
+/*
+ * register_slot
+ *
+ * Called once for each SxFy object in the namespace. Don't worry about
+ * calling pci_create_slot multiple times for the same pci_bus:device,
+ * since each subsequent call simply bumps the refcount on the pci_slot.
+ *
+ * The number of calls to pci_destroy_slot from unregister_slot is
+ * symmetrical.
+ */
+static acpi_status
+register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int device;
+        unsigned long sun;
+        char name[SLOT_NAME_SIZE];
+        struct acpi_pci_slot *slot;
+        struct pci_slot *pci_slot;
+        struct callback_args *parent_context = context;
+        struct pci_bus *pci_bus = parent_context->pci_bus;
+
+        if (check_slot(handle, &device, &sun))
+                return AE_OK;
+
+        slot = kmalloc(sizeof(*slot), GFP_KERNEL);
+        if (!slot) {
+                err("%s: cannot allocate memory\n", __func__);
+                return AE_OK;
+        }
+
+        snprintf(name, sizeof(name), "%u", (u32)sun);
+        pci_slot = pci_create_slot(pci_bus, device, name);
+        if (IS_ERR(pci_slot)) {
+                err("pci_create_slot returned %ld\n", PTR_ERR(pci_slot));
+                kfree(slot);
+        }
+
+        slot->root_handle = parent_context->root_handle;
+        slot->pci_slot = pci_slot;
+        INIT_LIST_HEAD(&slot->list);
+        mutex_lock(&slot_list_lock);
+        list_add(&slot->list, &slot_list);
+        mutex_unlock(&slot_list_lock);
+
+        dbg("pci_slot: %p, pci_bus: %x, device: %d, name: %s\n",
+                pci_slot, pci_bus->number, device, name);
+
+        return AE_OK;
+}
+
+/*
+ * walk_p2p_bridge - discover and walk p2p bridges
+ * @handle: points to an acpi_pci_root
+ * @context: p2p_bridge_context pointer
+ *
+ * Note that when we call ourselves recursively, we pass a different
+ * value of pci_bus in the child_context.
+ */
+static acpi_status
+walk_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int device, function;
+        unsigned long adr;
+        acpi_status status;
+        acpi_handle dummy_handle;
+        acpi_walk_callback user_function;
+
+        struct pci_dev *dev;
+        struct pci_bus *pci_bus;
+        struct callback_args child_context;
+        struct callback_args *parent_context = context;
+
+        pci_bus = parent_context->pci_bus;
+        user_function = parent_context->user_function;
+
+        status = acpi_get_handle(handle, "_ADR", &dummy_handle);
+        if (ACPI_FAILURE(status))
+                return AE_OK;
+
+        status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
+        if (ACPI_FAILURE(status))
+                return AE_OK;
+
+        device = (adr >> 16) & 0xffff;
+        function = adr & 0xffff;
+
+        dev = pci_get_slot(pci_bus, PCI_DEVFN(device, function));
+        if (!dev || !dev->subordinate)
+                goto out;
+
+        child_context.pci_bus = dev->subordinate;
+        child_context.user_function = user_function;
+        child_context.root_handle = parent_context->root_handle;
+
+        dbg("p2p bridge walk, pci_bus = %x\n", dev->subordinate->number);
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                                     user_function, &child_context, NULL);
+        if (ACPI_FAILURE(status))
+                goto out;
+
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                                     walk_p2p_bridge, &child_context, NULL);
+out:
+        pci_dev_put(dev);
+        return AE_OK;
+}
+
+/*
+ * walk_root_bridge - generic root bridge walker
+ * @handle: points to an acpi_pci_root
+ * @user_function: user callback for slot objects
+ *
+ * Call user_function for all objects underneath this root bridge.
+ * Walk p2p bridges underneath us and call user_function on those too.
+ */
+static int
+walk_root_bridge(acpi_handle handle, acpi_walk_callback user_function)
+{
+        int seg, bus;
+        unsigned long tmp;
+        acpi_status status;
+        acpi_handle dummy_handle;
+        struct pci_bus *pci_bus;
+        struct callback_args context;
+
+        /* If the bridge doesn't have _STA, we assume it is always there */
+        status = acpi_get_handle(handle, "_STA", &dummy_handle);
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp);
+                if (ACPI_FAILURE(status)) {
+                        info("%s: _STA evaluation failure\n", __func__);
+                        return 0;
+                }
+                if ((tmp & ACPI_STA_DEVICE_FUNCTIONING) == 0)
+                        /* don't register this object */
+                        return 0;
+        }
+
+        status = acpi_evaluate_integer(handle, "_SEG", NULL, &tmp);
+        seg = ACPI_SUCCESS(status) ? tmp : 0;
+
+        status = acpi_evaluate_integer(handle, "_BBN", NULL, &tmp);
+        bus = ACPI_SUCCESS(status) ? tmp : 0;
+
+        pci_bus = pci_find_bus(seg, bus);
+        if (!pci_bus)
+                return 0;
+
+        context.pci_bus = pci_bus;
+        context.user_function = user_function;
+        context.root_handle = handle;
+
+        dbg("root bridge walk, pci_bus = %x\n", pci_bus->number);
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                                     user_function, &context, NULL);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                                     walk_p2p_bridge, &context, NULL);
+        if (ACPI_FAILURE(status))
+                err("%s: walk_p2p_bridge failure - %d\n", __func__, status);
+
+        return status;
+}
+
+/*
+ * acpi_pci_slot_add
+ * @handle: points to an acpi_pci_root
+ */
+static int
+acpi_pci_slot_add(acpi_handle handle)
+{
+        acpi_status status;
+
+        status = walk_root_bridge(handle, register_slot);
+        if (ACPI_FAILURE(status))
+                err("%s: register_slot failure - %d\n", __func__, status);
+
+        return status;
+}
+
+/*
+ * acpi_pci_slot_remove
+ * @handle: points to an acpi_pci_root
+ */
+static void
+acpi_pci_slot_remove(acpi_handle handle)
+{
+        struct acpi_pci_slot *slot, *tmp;
+
+        mutex_lock(&slot_list_lock);
+        list_for_each_entry_safe(slot, tmp, &slot_list, list) {
+                if (slot->root_handle == handle) {
+                        list_del(&slot->list);
+                        pci_destroy_slot(slot->pci_slot);
+                        kfree(slot);
+                }
+        }
+        mutex_unlock(&slot_list_lock);
+}
+
+static int do_sta_before_sun(const struct dmi_system_id *d)
+{
+        info("%s detected: will evaluate _STA before calling _SUN\n", d->ident);
+        check_sta_before_sun = 1;
+        return 0;
+}
+
+static struct dmi_system_id acpi_pci_slot_dmi_table[] __initdata = {
+        /*
+         * Fujitsu Primequest machines will return 1023 to indicate an
+         * error if the _SUN method is evaluated on SxFy objects that
+         * are not present (as indicated by _STA), so for those machines,
+         * we want to check _STA before evaluating _SUN.
+         */
+        {
+         .callback = do_sta_before_sun,
+         .ident = "Fujitsu PRIMEQUEST",
+         .matches = {
+                DMI_MATCH(DMI_BIOS_VENDOR, "FUJITSU LIMITED"),
+                DMI_MATCH(DMI_BIOS_VERSION, "PRIMEQUEST"),
+                },
+        },
+        {}
+};
+
+static int __init
+acpi_pci_slot_init(void)
+{
+        dmi_check_system(acpi_pci_slot_dmi_table);
+        acpi_pci_register_driver(&acpi_pci_slot_driver);
+        return 0;
+}
+
+static void __exit
+acpi_pci_slot_exit(void)
+{
+        acpi_pci_unregister_driver(&acpi_pci_slot_driver);
+}
+
+module_init(acpi_pci_slot_init);
+module_exit(acpi_pci_slot_exit);
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 81e4f081a4ae..4ab21cb1c8c7 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -292,69 +292,135 @@ static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
         return 0;
 }
 
+/**
+ * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
+ *                          ACPI 3.0) _PSW (Power State Wake)
+ * @dev: Device to handle.
+ * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
+ * @sleep_state: Target sleep state of the system.
+ * @dev_state: Target power state of the device.
+ *
+ * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
+ * State Wake) for the device, if present.  On failure reset the device's
+ * wakeup.flags.valid flag.
+ *
+ * RETURN VALUE:
+ * 0 if either _DSW or _PSW has been successfully executed
+ * 0 if neither _DSW nor _PSW has been found
+ * -ENODEV if the execution of either _DSW or _PSW has failed
+ */
+int acpi_device_sleep_wake(struct acpi_device *dev,
+                           int enable, int sleep_state, int dev_state)
+{
+        union acpi_object in_arg[3];
+        struct acpi_object_list arg_list = { 3, in_arg };
+        acpi_status status = AE_OK;
+
+        /*
+         * Try to execute _DSW first.
+         *
+         * Three agruments are needed for the _DSW object:
+         * Argument 0: enable/disable the wake capabilities
+         * Argument 1: target system state
+         * Argument 2: target device state
+         * When _DSW object is called to disable the wake capabilities, maybe
+         * the first argument is filled. The values of the other two agruments
+         * are meaningless.
+         */
+        in_arg[0].type = ACPI_TYPE_INTEGER;
+        in_arg[0].integer.value = enable;
+        in_arg[1].type = ACPI_TYPE_INTEGER;
+        in_arg[1].integer.value = sleep_state;
+        in_arg[2].type = ACPI_TYPE_INTEGER;
+        in_arg[2].integer.value = dev_state;
+        status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
+        if (ACPI_SUCCESS(status)) {
+                return 0;
+        } else if (status != AE_NOT_FOUND) {
+                printk(KERN_ERR PREFIX "_DSW execution failed\n");
+                dev->wakeup.flags.valid = 0;
+                return -ENODEV;
+        }
+
+        /* Execute _PSW */
+        arg_list.count = 1;
+        in_arg[0].integer.value = enable;
+        status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
+        if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
+                printk(KERN_ERR PREFIX "_PSW execution failed\n");
+                dev->wakeup.flags.valid = 0;
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
 /*
  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
  * 1. Power on the power resources required for the wakeup device 
- * 2. Enable _PSW (power state wake) for the device if present
+ * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
+ *    State Wake) for the device, if present
  */
-int acpi_enable_wakeup_device_power(struct acpi_device *dev)
+int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
 {
-        union acpi_object arg = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg };
-        acpi_status status = AE_OK;
-        int i;
-        int ret = 0;
+        int i, err;
 
         if (!dev || !dev->wakeup.flags.valid)
-                return -1;
+                return -EINVAL;
+
+        /*
+         * Do not execute the code below twice in a row without calling
+         * acpi_disable_wakeup_device_power() in between for the same device
+         */
+        if (dev->wakeup.flags.prepared)
+                return 0;
 
-        arg.integer.value = 1;
         /* Open power resource */
         for (i = 0; i < dev->wakeup.resources.count; i++) {
-                ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
+                int ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
                 if (ret) {
                         printk(KERN_ERR PREFIX "Transition power state\n");
                         dev->wakeup.flags.valid = 0;
-                        return -1;
+                        return -ENODEV;
                 }
         }
 
-        /* Execute PSW */
-        status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
-        if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
-                printk(KERN_ERR PREFIX "Evaluate _PSW\n");
-                dev->wakeup.flags.valid = 0;
-                ret = -1;
-        }
+        /*
+         * Passing 3 as the third argument below means the device may be placed
+         * in arbitrary power state afterwards.
+         */
+        err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
+        if (!err)
+                dev->wakeup.flags.prepared = 1;
 
-        return ret;
+        return err;
 }
 
 /*
  * Shutdown a wakeup device, counterpart of above method
- * 1. Disable _PSW (power state wake)
+ * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
+ *    State Wake) for the device, if present
  * 2. Shutdown down the power resources
  */
 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
 {
-        union acpi_object arg = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg };
-        acpi_status status = AE_OK;
-        int i;
-        int ret = 0;
-
+        int i, ret;
 
         if (!dev || !dev->wakeup.flags.valid)
-                return -1;
+                return -EINVAL;
 
-        arg.integer.value = 0;
-        /* Execute PSW */
-        status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
-        if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
-                printk(KERN_ERR PREFIX "Evaluate _PSW\n");
-                dev->wakeup.flags.valid = 0;
-                return -1;
-        }
+        /*
+         * Do not execute the code below twice in a row without calling
+         * acpi_enable_wakeup_device_power() in between for the same device
+         */
+        if (!dev->wakeup.flags.prepared)
+                return 0;
+
+        dev->wakeup.flags.prepared = 0;
+
+        ret = acpi_device_sleep_wake(dev, 0, 0, 0);
+        if (ret)
+                return ret;
 
         /* Close power resource */
         for (i = 0; i < dev->wakeup.resources.count; i++) {
@@ -362,7 +428,7 @@ int acpi_disable_wakeup_device_power(struct acpi_device *dev)
                 if (ret) {
                         printk(KERN_ERR PREFIX "Transition power state\n");
                         dev->wakeup.flags.valid = 0;
-                        return -1;
+                        return -ENODEV;
                 }
         }
 
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 5b049cd79553..f3132aa47a69 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -703,9 +703,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
         acpi_status status = 0;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *package = NULL;
-        union acpi_object in_arg[3];
-        struct acpi_object_list arg_list = { 3, in_arg };
-        acpi_status psw_status = AE_OK;
+        int psw_error;
 
         struct acpi_device_id button_device_ids[] = {
                 {"PNP0C0D", 0},
@@ -737,39 +735,11 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
          * So it is necessary to call _DSW object first. Only when it is not
          * present will the _PSW object used.
          */
-        /*
-         * Three agruments are needed for the _DSW object.
-         * Argument 0: enable/disable the wake capabilities
-         * When _DSW object is called to disable the wake capabilities, maybe
-         * the first argument is filled. The value of the other two agruments
-         * is meaningless.
-         */
-        in_arg[0].type = ACPI_TYPE_INTEGER;
-        in_arg[0].integer.value = 0;
-        in_arg[1].type = ACPI_TYPE_INTEGER;
-        in_arg[1].integer.value = 0;
-        in_arg[2].type = ACPI_TYPE_INTEGER;
-        in_arg[2].integer.value = 0;
-        psw_status = acpi_evaluate_object(device->handle, "_DSW",
-                                                &arg_list, NULL);
-        if (ACPI_FAILURE(psw_status) && (psw_status != AE_NOT_FOUND))
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "error in evaluate _DSW\n"));
-        /*
-         * When the _DSW object is not present, OSPM will call _PSW object.
-         */
-        if (psw_status == AE_NOT_FOUND) {
-                /*
-                 * Only one agruments is required for the _PSW object.
-                 * agrument 0: enable/disable the wake capabilities
-                 */
-                arg_list.count = 1;
-                in_arg[0].integer.value = 0;
-                psw_status = acpi_evaluate_object(device->handle, "_PSW",
-                                                &arg_list, NULL);
-                if (ACPI_FAILURE(psw_status) && (psw_status != AE_NOT_FOUND))
-                        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "error in "
-                                                "evaluate _PSW\n"));
-        }
+        psw_error = acpi_device_sleep_wake(device, 0, 0, 0);
+        if (psw_error)
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                "error in _DSW or _PSW evaluation\n"));
+
         /* Power button, Lid switch always enable wakeup */
         if (!acpi_match_device_ids(device, button_device_ids))
                 device->wakeup.flags.run_wake = 1;
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index 244e352f7661..0489a7d1d42c 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -24,10 +24,6 @@
 
 u8 sleep_states[ACPI_S_STATE_COUNT];
 
-#ifdef CONFIG_PM_SLEEP
-static u32 acpi_target_sleep_state = ACPI_STATE_S0;
-#endif
-
 static int acpi_sleep_prepare(u32 acpi_state)
 {
 #ifdef CONFIG_ACPI_SLEEP
@@ -49,9 +45,96 @@ static int acpi_sleep_prepare(u32 acpi_state)
         return 0;
 }
 
-#ifdef CONFIG_SUSPEND
-static struct platform_suspend_ops acpi_suspend_ops;
+#ifdef CONFIG_PM_SLEEP
+static u32 acpi_target_sleep_state = ACPI_STATE_S0;
+
+/*
+ * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
+ * user to request that behavior by using the 'acpi_old_suspend_ordering'
+ * kernel command line option that causes the following variable to be set.
+ */
+static bool old_suspend_ordering;
+
+void __init acpi_old_suspend_ordering(void)
+{
+        old_suspend_ordering = true;
+}
+
+/**
+ *      acpi_pm_disable_gpes - Disable the GPEs.
+ */
+static int acpi_pm_disable_gpes(void)
+{
+        acpi_hw_disable_all_gpes();
+        return 0;
+}
+
+/**
+ *      __acpi_pm_prepare - Prepare the platform to enter the target state.
+ *
+ *      If necessary, set the firmware waking vector and do arch-specific
+ *      nastiness to get the wakeup code to the waking vector.
+ */
+static int __acpi_pm_prepare(void)
+{
+        int error = acpi_sleep_prepare(acpi_target_sleep_state);
+
+        if (error)
+                acpi_target_sleep_state = ACPI_STATE_S0;
+        return error;
+}
+
+/**
+ *      acpi_pm_prepare - Prepare the platform to enter the target sleep
+ *              state and disable the GPEs.
+ */
+static int acpi_pm_prepare(void)
+{
+        int error = __acpi_pm_prepare();
+
+        if (!error)
+                acpi_hw_disable_all_gpes();
+        return error;
+}
+
+/**
+ *      acpi_pm_finish - Instruct the platform to leave a sleep state.
+ *
+ *      This is called after we wake back up (or if entering the sleep state
+ *      failed).
+ */
+static void acpi_pm_finish(void)
+{
+        u32 acpi_state = acpi_target_sleep_state;
+
+        if (acpi_state == ACPI_STATE_S0)
+                return;
+
+        printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
+                acpi_state);
+        acpi_disable_wakeup_device(acpi_state);
+        acpi_leave_sleep_state(acpi_state);
+
+        /* reset firmware waking vector */
+        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
+
+        acpi_target_sleep_state = ACPI_STATE_S0;
+}
+
+/**
+ *      acpi_pm_end - Finish up suspend sequence.
+ */
+static void acpi_pm_end(void)
+{
+        /*
+         * This is necessary in case acpi_pm_finish() is not called during a
+         * failing transition to a sleep state.
+         */
+        acpi_target_sleep_state = ACPI_STATE_S0;
+}
+#endif /* CONFIG_PM_SLEEP */
 
+#ifdef CONFIG_SUSPEND
 extern void do_suspend_lowlevel(void);
 
 static u32 acpi_suspend_states[] = {
@@ -65,7 +148,6 @@ static u32 acpi_suspend_states[] = {
  *      acpi_suspend_begin - Set the target system sleep state to the state
  *              associated with given @pm_state, if supported.
  */
-
 static int acpi_suspend_begin(suspend_state_t pm_state)
 {
         u32 acpi_state = acpi_suspend_states[pm_state];
@@ -82,25 +164,6 @@ static int acpi_suspend_begin(suspend_state_t pm_state)
 }
 
 /**
- *      acpi_suspend_prepare - Do preliminary suspend work.
- *
- *      If necessary, set the firmware waking vector and do arch-specific
- *      nastiness to get the wakeup code to the waking vector.
- */
-
-static int acpi_suspend_prepare(void)
-{
-        int error = acpi_sleep_prepare(acpi_target_sleep_state);
-
-        if (error) {
-                acpi_target_sleep_state = ACPI_STATE_S0;
-                return error;
-        }
-
-        return ACPI_SUCCESS(acpi_hw_disable_all_gpes()) ? 0 : -EFAULT;
-}
-
-/**
  *      acpi_suspend_enter - Actually enter a sleep state.
  *      @pm_state: ignored
  *
@@ -108,7 +171,6 @@ static int acpi_suspend_prepare(void)
  *      assembly, which in turn call acpi_enter_sleep_state().
  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
  */
-
 static int acpi_suspend_enter(suspend_state_t pm_state)
 {
         acpi_status status = AE_OK;
@@ -165,39 +227,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 }
 
-/**
- *      acpi_suspend_finish - Instruct the platform to leave a sleep state.
- *
- *      This is called after we wake back up (or if entering the sleep state
- *      failed). 
- */
-
-static void acpi_suspend_finish(void)
-{
-        u32 acpi_state = acpi_target_sleep_state;
-
-        acpi_disable_wakeup_device(acpi_state);
-        acpi_leave_sleep_state(acpi_state);
-
-        /* reset firmware waking vector */
-        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
-
-        acpi_target_sleep_state = ACPI_STATE_S0;
-}
-
-/**
- *      acpi_suspend_end - Finish up suspend sequence.
- */
-
-static void acpi_suspend_end(void)
-{
-        /*
-         * This is necessary in case acpi_suspend_finish() is not called during a
-         * failing transition to a sleep state.
-         */
-        acpi_target_sleep_state = ACPI_STATE_S0;
-}
-
 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 {
         u32 acpi_state;
@@ -217,10 +246,39 @@ static int acpi_suspend_state_valid(suspend_state_t pm_state)
 static struct platform_suspend_ops acpi_suspend_ops = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin,
-        .prepare = acpi_suspend_prepare,
+        .prepare = acpi_pm_prepare,
         .enter = acpi_suspend_enter,
-        .finish = acpi_suspend_finish,
-        .end = acpi_suspend_end,
+        .finish = acpi_pm_finish,
+        .end = acpi_pm_end,
+};
+
+/**
+ *      acpi_suspend_begin_old - Set the target system sleep state to the
+ *              state associated with given @pm_state, if supported, and
+ *              execute the _PTS control method.  This function is used if the
+ *              pre-ACPI 2.0 suspend ordering has been requested.
+ */
+static int acpi_suspend_begin_old(suspend_state_t pm_state)
+{
+        int error = acpi_suspend_begin(pm_state);
+
+        if (!error)
+                error = __acpi_pm_prepare();
+        return error;
+}
+
+/*
+ * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
+ * been requested.
+ */
+static struct platform_suspend_ops acpi_suspend_ops_old = {
+        .valid = acpi_suspend_state_valid,
+        .begin = acpi_suspend_begin_old,
+        .prepare = acpi_pm_disable_gpes,
+        .enter = acpi_suspend_enter,
+        .finish = acpi_pm_finish,
+        .end = acpi_pm_end,
+        .recover = acpi_pm_finish,
 };
 #endif /* CONFIG_SUSPEND */
 
@@ -228,22 +286,9 @@ static struct platform_suspend_ops acpi_suspend_ops = {
 static int acpi_hibernation_begin(void)
 {
         acpi_target_sleep_state = ACPI_STATE_S4;
-
         return 0;
 }
 
-static int acpi_hibernation_prepare(void)
-{
-        int error = acpi_sleep_prepare(ACPI_STATE_S4);
-
-        if (error) {
-                acpi_target_sleep_state = ACPI_STATE_S0;
-                return error;
-        }
-
-        return ACPI_SUCCESS(acpi_hw_disable_all_gpes()) ? 0 : -EFAULT;
-}
-
 static int acpi_hibernation_enter(void)
 {
         acpi_status status = AE_OK;
@@ -273,52 +318,55 @@ static void acpi_hibernation_leave(void)
         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 }
 
-static void acpi_hibernation_finish(void)
+static void acpi_pm_enable_gpes(void)
 {
-        acpi_disable_wakeup_device(ACPI_STATE_S4);
-        acpi_leave_sleep_state(ACPI_STATE_S4);
-
-        /* reset firmware waking vector */
-        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
-
-        acpi_target_sleep_state = ACPI_STATE_S0;
+        acpi_hw_enable_all_runtime_gpes();
 }
 
-static void acpi_hibernation_end(void)
-{
-        /*
-         * This is necessary in case acpi_hibernation_finish() is not called
-         * during a failing transition to the sleep state.
-         */
-        acpi_target_sleep_state = ACPI_STATE_S0;
-}
+static struct platform_hibernation_ops acpi_hibernation_ops = {
+        .begin = acpi_hibernation_begin,
+        .end = acpi_pm_end,
+        .pre_snapshot = acpi_pm_prepare,
+        .finish = acpi_pm_finish,
+        .prepare = acpi_pm_prepare,
+        .enter = acpi_hibernation_enter,
+        .leave = acpi_hibernation_leave,
+        .pre_restore = acpi_pm_disable_gpes,
+        .restore_cleanup = acpi_pm_enable_gpes,
+};
 
-static int acpi_hibernation_pre_restore(void)
+/**
+ *      acpi_hibernation_begin_old - Set the target system sleep state to
+ *              ACPI_STATE_S4 and execute the _PTS control method.  This
+ *              function is used if the pre-ACPI 2.0 suspend ordering has been
+ *              requested.
+ */
+static int acpi_hibernation_begin_old(void)
 {
-        acpi_status status;
-
-        status = acpi_hw_disable_all_gpes();
-
-        return ACPI_SUCCESS(status) ? 0 : -EFAULT;
-}
+        int error = acpi_sleep_prepare(ACPI_STATE_S4);
 
-static void acpi_hibernation_restore_cleanup(void)
-{
-        acpi_hw_enable_all_runtime_gpes();
+        if (!error)
+                acpi_target_sleep_state = ACPI_STATE_S4;
+        return error;
 }
 
-static struct platform_hibernation_ops acpi_hibernation_ops = {
-        .begin = acpi_hibernation_begin,
-        .end = acpi_hibernation_end,
-        .pre_snapshot = acpi_hibernation_prepare,
-        .finish = acpi_hibernation_finish,
-        .prepare = acpi_hibernation_prepare,
+/*
+ * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
+ * been requested.
+ */
+static struct platform_hibernation_ops acpi_hibernation_ops_old = {
+        .begin = acpi_hibernation_begin_old,
+        .end = acpi_pm_end,
+        .pre_snapshot = acpi_pm_disable_gpes,
+        .finish = acpi_pm_finish,
+        .prepare = acpi_pm_disable_gpes,
         .enter = acpi_hibernation_enter,
         .leave = acpi_hibernation_leave,
-        .pre_restore = acpi_hibernation_pre_restore,
-        .restore_cleanup = acpi_hibernation_restore_cleanup,
+        .pre_restore = acpi_pm_disable_gpes,
+        .restore_cleanup = acpi_pm_enable_gpes,
+        .recover = acpi_pm_finish,
 };
-#endif                          /* CONFIG_HIBERNATION */
+#endif /* CONFIG_HIBERNATION */
 
 int acpi_suspend(u32 acpi_state)
 {
@@ -419,6 +467,31 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
                 *d_min_p = d_min;
         return d_max;
 }
+
+/**
+ *      acpi_pm_device_sleep_wake - enable or disable the system wake-up
+ *                                  capability of given device
+ *      @dev: device to handle
+ *      @enable: 'true' - enable, 'false' - disable the wake-up capability
+ */
+int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
+{
+        acpi_handle handle;
+        struct acpi_device *adev;
+
+        if (!device_may_wakeup(dev))
+                return -EINVAL;
+
+        handle = DEVICE_ACPI_HANDLE(dev);
+        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
+                printk(KERN_DEBUG "ACPI handle has no context!\n");
+                return -ENODEV;
+        }
+
+        return enable ?
+                acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
+                acpi_disable_wakeup_device_power(adev);
+}
 #endif
 
 static void acpi_power_off_prepare(void)
@@ -460,13 +533,15 @@ int __init acpi_sleep_init(void)
                 }
         }
 
-        suspend_set_ops(&acpi_suspend_ops);
+        suspend_set_ops(old_suspend_ordering ?
+                &acpi_suspend_ops_old : &acpi_suspend_ops);
 #endif
 
 #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);
+                hibernation_set_ops(old_suspend_ordering ?
+                        &acpi_hibernation_ops_old : &acpi_hibernation_ops);
                 sleep_states[ACPI_STATE_S4] = 1;
                 printk(" S4");
         }
diff --git a/drivers/acpi/sleep/wakeup.c b/drivers/acpi/sleep/wakeup.c
index ed8e41becf0c..38655eb132dc 100644
--- a/drivers/acpi/sleep/wakeup.c
+++ b/drivers/acpi/sleep/wakeup.c
@@ -42,7 +42,7 @@ void acpi_enable_wakeup_device_prep(u8 sleep_state)
                         continue;
 
                 spin_unlock(&acpi_device_lock);
-                acpi_enable_wakeup_device_power(dev);
+                acpi_enable_wakeup_device_power(dev, sleep_state);
                 spin_lock(&acpi_device_lock);
         }
         spin_unlock(&acpi_device_lock);
@@ -66,13 +66,15 @@ void acpi_enable_wakeup_device(u8 sleep_state)
         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
                 struct acpi_device *dev =
                         container_of(node, struct acpi_device, wakeup_list);
+
                 if (!dev->wakeup.flags.valid)
                         continue;
+
                 /* If users want to disable run-wake GPE,
                  * we only disable it for wake and leave it for runtime
                  */
-                if (!dev->wakeup.state.enabled ||
-                    sleep_state > (u32) dev->wakeup.sleep_state) {
+                if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
+                    || sleep_state > (u32) dev->wakeup.sleep_state) {
                         if (dev->wakeup.flags.run_wake) {
                                 spin_unlock(&acpi_device_lock);
                                 /* set_gpe_type will disable GPE, leave it like that */
@@ -110,8 +112,9 @@ void acpi_disable_wakeup_device(u8 sleep_state)
 
                 if (!dev->wakeup.flags.valid)
                         continue;
-                if (!dev->wakeup.state.enabled ||
-                    sleep_state > (u32) dev->wakeup.sleep_state) {
+
+                if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
+                    || sleep_state > (u32) dev->wakeup.sleep_state) {
                         if (dev->wakeup.flags.run_wake) {
                                 spin_unlock(&acpi_device_lock);
                                 acpi_set_gpe_type(dev->wakeup.gpe_device,