Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6

* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6: (41 commits)
  ACPICA: hw: Don't carry spinlock over suspend
  ACPICA: hw: remove use_lock flag from acpi_hw_register_{read, write}
  ACPI: cpuidle: port idle timer suspend/resume workaround to cpuidle
  ACPI: clean up acpi_enter_sleep_state_prep
  Hibernation: Make sure that ACPI is enabled in acpi_hibernation_finish
  ACPI: suppress uninitialized var warning
  cpuidle: consolidate 2.6.22 cpuidle branch into one patch
  ACPI: thinkpad-acpi: skip blanks before the data when parsing sysfs
  ACPI: AC: Add sysfs interface
  ACPI: SBS: Add sysfs alarm
  ACPI: SBS: Add ACPI_PROCFS around procfs handling code.
  ACPI: SBS: Add support for power_supply class (and sysfs)
  ACPI: SBS: Make SBS reads table-driven.
  ACPI: SBS: Simplify data structures in SBS
  ACPI: SBS: Split host controller (ACPI0001) from SBS driver (ACPI0002)
  ACPI: EC: Add new query handler to list head.
  ACPI: Add acpi_bus_generate_event4() function
  ACPI: Battery: add sysfs alarm
  ACPI: Battery: Add sysfs support
  ACPI: Battery: Misc clean-ups, no functional changes
  ...

Fix up conflicts in drivers/misc/thinkpad_acpi.[ch] manually

10 files changed, 1220 insertions, 0 deletions

diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
new file mode 100644
index 000000000000..3bed4127d4ad
--- /dev/null
+++ b/drivers/cpuidle/Kconfig
@@ -0,0 +1,20 @@
+
+config CPU_IDLE
+        bool "CPU idle PM support"
+        help
+          CPU idle is a generic framework for supporting software-controlled
+          idle processor power management.  It includes modular cross-platform
+          governors that can be swapped during runtime.
+
+          If you're using a mobile platform that supports CPU idle PM (e.g.
+          an ACPI-capable notebook), you should say Y here.
+
+config CPU_IDLE_GOV_LADDER
+        bool
+        depends on CPU_IDLE
+        default y
+
+config CPU_IDLE_GOV_MENU
+        bool
+        depends on CPU_IDLE && NO_HZ
+        default y
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
new file mode 100644
index 000000000000..5634f88379df
--- /dev/null
+++ b/drivers/cpuidle/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for cpuidle.
+#
+
+obj-y += cpuidle.o driver.o governor.o sysfs.o governors/
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
new file mode 100644
index 000000000000..fdf4106b817b
--- /dev/null
+++ b/drivers/cpuidle/cpuidle.c
@@ -0,0 +1,295 @@
+/*
+ * cpuidle.c - core cpuidle infrastructure
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/notifier.h>
+#include <linux/latency.h>
+#include <linux/cpu.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+DEFINE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
+EXPORT_PER_CPU_SYMBOL_GPL(cpuidle_devices);
+
+DEFINE_MUTEX(cpuidle_lock);
+LIST_HEAD(cpuidle_detected_devices);
+static void (*pm_idle_old)(void);
+
+static int enabled_devices;
+
+/**
+ * cpuidle_idle_call - the main idle loop
+ *
+ * NOTE: no locks or semaphores should be used here
+ */
+static void cpuidle_idle_call(void)
+{
+        struct cpuidle_device *dev = __get_cpu_var(cpuidle_devices);
+        struct cpuidle_state *target_state;
+        int next_state;
+
+        /* check if the device is ready */
+        if (!dev || !dev->enabled) {
+                if (pm_idle_old)
+                        pm_idle_old();
+                else
+                        local_irq_enable();
+                return;
+        }
+
+        /* ask the governor for the next state */
+        next_state = cpuidle_curr_governor->select(dev);
+        if (need_resched())
+                return;
+        target_state = &dev->states[next_state];
+
+        /* enter the state and update stats */
+        dev->last_residency = target_state->enter(dev, target_state);
+        dev->last_state = target_state;
+        target_state->time += dev->last_residency;
+        target_state->usage++;
+
+        /* give the governor an opportunity to reflect on the outcome */
+        if (cpuidle_curr_governor->reflect)
+                cpuidle_curr_governor->reflect(dev);
+}
+
+/**
+ * cpuidle_install_idle_handler - installs the cpuidle idle loop handler
+ */
+void cpuidle_install_idle_handler(void)
+{
+        if (enabled_devices && (pm_idle != cpuidle_idle_call)) {
+                /* Make sure all changes finished before we switch to new idle */
+                smp_wmb();
+                pm_idle = cpuidle_idle_call;
+        }
+}
+
+/**
+ * cpuidle_uninstall_idle_handler - uninstalls the cpuidle idle loop handler
+ */
+void cpuidle_uninstall_idle_handler(void)
+{
+        if (enabled_devices && (pm_idle != pm_idle_old)) {
+                pm_idle = pm_idle_old;
+                cpu_idle_wait();
+        }
+}
+
+/**
+ * cpuidle_pause_and_lock - temporarily disables CPUIDLE
+ */
+void cpuidle_pause_and_lock(void)
+{
+        mutex_lock(&cpuidle_lock);
+        cpuidle_uninstall_idle_handler();
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_pause_and_lock);
+
+/**
+ * cpuidle_resume_and_unlock - resumes CPUIDLE operation
+ */
+void cpuidle_resume_and_unlock(void)
+{
+        cpuidle_install_idle_handler();
+        mutex_unlock(&cpuidle_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_resume_and_unlock);
+
+/**
+ * cpuidle_enable_device - enables idle PM for a CPU
+ * @dev: the CPU
+ *
+ * This function must be called between cpuidle_pause_and_lock and
+ * cpuidle_resume_and_unlock when used externally.
+ */
+int cpuidle_enable_device(struct cpuidle_device *dev)
+{
+        int ret, i;
+
+        if (dev->enabled)
+                return 0;
+        if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+                return -EIO;
+        if (!dev->state_count)
+                return -EINVAL;
+
+        if ((ret = cpuidle_add_state_sysfs(dev)))
+                return ret;
+
+        if (cpuidle_curr_governor->enable &&
+            (ret = cpuidle_curr_governor->enable(dev)))
+                goto fail_sysfs;
+
+        for (i = 0; i < dev->state_count; i++) {
+                dev->states[i].usage = 0;
+                dev->states[i].time = 0;
+        }
+        dev->last_residency = 0;
+        dev->last_state = NULL;
+
+        smp_wmb();
+
+        dev->enabled = 1;
+
+        enabled_devices++;
+        return 0;
+
+fail_sysfs:
+        cpuidle_remove_state_sysfs(dev);
+
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_enable_device);
+
+/**
+ * cpuidle_disable_device - disables idle PM for a CPU
+ * @dev: the CPU
+ *
+ * This function must be called between cpuidle_pause_and_lock and
+ * cpuidle_resume_and_unlock when used externally.
+ */
+void cpuidle_disable_device(struct cpuidle_device *dev)
+{
+        if (!dev->enabled)
+                return;
+        if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+                return;
+
+        dev->enabled = 0;
+
+        if (cpuidle_curr_governor->disable)
+                cpuidle_curr_governor->disable(dev);
+
+        cpuidle_remove_state_sysfs(dev);
+        enabled_devices--;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_disable_device);
+
+/**
+ * cpuidle_register_device - registers a CPU's idle PM feature
+ * @dev: the cpu
+ */
+int cpuidle_register_device(struct cpuidle_device *dev)
+{
+        int ret;
+        struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+
+        if (!sys_dev)
+                return -EINVAL;
+        if (!try_module_get(cpuidle_curr_driver->owner))
+                return -EINVAL;
+
+        init_completion(&dev->kobj_unregister);
+
+        mutex_lock(&cpuidle_lock);
+
+        per_cpu(cpuidle_devices, dev->cpu) = dev;
+        list_add(&dev->device_list, &cpuidle_detected_devices);
+        if ((ret = cpuidle_add_sysfs(sys_dev))) {
+                mutex_unlock(&cpuidle_lock);
+                module_put(cpuidle_curr_driver->owner);
+                return ret;
+        }
+
+        cpuidle_enable_device(dev);
+        cpuidle_install_idle_handler();
+
+        mutex_unlock(&cpuidle_lock);
+
+        return 0;
+
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_device);
+
+/**
+ * cpuidle_unregister_device - unregisters a CPU's idle PM feature
+ * @dev: the cpu
+ */
+void cpuidle_unregister_device(struct cpuidle_device *dev)
+{
+        struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+
+        cpuidle_pause_and_lock();
+
+        cpuidle_disable_device(dev);
+
+        cpuidle_remove_sysfs(sys_dev);
+        list_del(&dev->device_list);
+        wait_for_completion(&dev->kobj_unregister);
+        per_cpu(cpuidle_devices, dev->cpu) = NULL;
+
+        cpuidle_resume_and_unlock();
+
+        module_put(cpuidle_curr_driver->owner);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_device);
+
+#ifdef CONFIG_SMP
+
+static void smp_callback(void *v)
+{
+        /* we already woke the CPU up, nothing more to do */
+}
+
+/*
+ * This function gets called when a part of the kernel has a new latency
+ * requirement.  This means we need to get all processors out of their C-state,
+ * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that
+ * wakes them all right up.
+ */
+static int cpuidle_latency_notify(struct notifier_block *b,
+                unsigned long l, void *v)
+{
+        smp_call_function(smp_callback, NULL, 0, 1);
+        return NOTIFY_OK;
+}
+
+static struct notifier_block cpuidle_latency_notifier = {
+        .notifier_call = cpuidle_latency_notify,
+};
+
+#define latency_notifier_init(x) do { register_latency_notifier(x); } while (0)
+
+#else /* CONFIG_SMP */
+
+#define latency_notifier_init(x) do { } while (0)
+
+#endif /* CONFIG_SMP */
+
+/**
+ * cpuidle_init - core initializer
+ */
+static int __init cpuidle_init(void)
+{
+        int ret;
+
+        pm_idle_old = pm_idle;
+
+        ret = cpuidle_add_class_sysfs(&cpu_sysdev_class);
+        if (ret)
+                return ret;
+
+        latency_notifier_init(&cpuidle_latency_notifier);
+
+        return 0;
+}
+
+core_initcall(cpuidle_init);
diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h
new file mode 100644
index 000000000000..9476ba33ee2c
--- /dev/null
+++ b/drivers/cpuidle/cpuidle.h
@@ -0,0 +1,33 @@
+/*
+ * cpuidle.h - The internal header file
+ */
+
+#ifndef __DRIVER_CPUIDLE_H
+#define __DRIVER_CPUIDLE_H
+
+#include <linux/sysdev.h>
+
+/* For internal use only */
+extern struct cpuidle_governor *cpuidle_curr_governor;
+extern struct cpuidle_driver *cpuidle_curr_driver;
+extern struct list_head cpuidle_governors;
+extern struct list_head cpuidle_detected_devices;
+extern struct mutex cpuidle_lock;
+extern spinlock_t cpuidle_driver_lock;
+
+/* idle loop */
+extern void cpuidle_install_idle_handler(void);
+extern void cpuidle_uninstall_idle_handler(void);
+
+/* governors */
+extern int cpuidle_switch_governor(struct cpuidle_governor *gov);
+
+/* sysfs */
+extern int cpuidle_add_class_sysfs(struct sysdev_class *cls);
+extern void cpuidle_remove_class_sysfs(struct sysdev_class *cls);
+extern int cpuidle_add_state_sysfs(struct cpuidle_device *device);
+extern void cpuidle_remove_state_sysfs(struct cpuidle_device *device);
+extern int cpuidle_add_sysfs(struct sys_device *sysdev);
+extern void cpuidle_remove_sysfs(struct sys_device *sysdev);
+
+#endif /* __DRIVER_CPUIDLE_H */
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
new file mode 100644
index 000000000000..2257004fe33d
--- /dev/null
+++ b/drivers/cpuidle/driver.c
@@ -0,0 +1,56 @@
+/*
+ * driver.c - driver support
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+struct cpuidle_driver *cpuidle_curr_driver;
+DEFINE_SPINLOCK(cpuidle_driver_lock);
+
+/**
+ * cpuidle_register_driver - registers a driver
+ * @drv: the driver
+ */
+int cpuidle_register_driver(struct cpuidle_driver *drv)
+{
+        if (!drv)
+                return -EINVAL;
+
+        spin_lock(&cpuidle_driver_lock);
+        if (cpuidle_curr_driver) {
+                spin_unlock(&cpuidle_driver_lock);
+                return -EBUSY;
+        }
+        cpuidle_curr_driver = drv;
+        spin_unlock(&cpuidle_driver_lock);
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_driver);
+
+/**
+ * cpuidle_unregister_driver - unregisters a driver
+ * @drv: the driver
+ */
+void cpuidle_unregister_driver(struct cpuidle_driver *drv)
+{
+        if (!drv)
+                return;
+
+        spin_lock(&cpuidle_driver_lock);
+        cpuidle_curr_driver = NULL;
+        spin_unlock(&cpuidle_driver_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
diff --git a/drivers/cpuidle/governor.c b/drivers/cpuidle/governor.c
new file mode 100644
index 000000000000..bb699cb2dc5a
--- /dev/null
+++ b/drivers/cpuidle/governor.c
@@ -0,0 +1,141 @@
+/*
+ * governor.c - governor support
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+LIST_HEAD(cpuidle_governors);
+struct cpuidle_governor *cpuidle_curr_governor;
+
+/**
+ * __cpuidle_find_governor - finds a governor of the specified name
+ * @str: the name
+ *
+ * Must be called with cpuidle_lock aquired.
+ */
+static struct cpuidle_governor * __cpuidle_find_governor(const char *str)
+{
+        struct cpuidle_governor *gov;
+
+        list_for_each_entry(gov, &cpuidle_governors, governor_list)
+                if (!strnicmp(str, gov->name, CPUIDLE_NAME_LEN))
+                        return gov;
+
+        return NULL;
+}
+
+/**
+ * cpuidle_switch_governor - changes the governor
+ * @gov: the new target governor
+ *
+ * NOTE: "gov" can be NULL to specify disabled
+ * Must be called with cpuidle_lock aquired.
+ */
+int cpuidle_switch_governor(struct cpuidle_governor *gov)
+{
+        struct cpuidle_device *dev;
+
+        if (gov == cpuidle_curr_governor)
+                return 0;
+
+        cpuidle_uninstall_idle_handler();
+
+        if (cpuidle_curr_governor) {
+                list_for_each_entry(dev, &cpuidle_detected_devices, device_list)
+                        cpuidle_disable_device(dev);
+                module_put(cpuidle_curr_governor->owner);
+        }
+
+        cpuidle_curr_governor = gov;
+
+        if (gov) {
+                if (!try_module_get(cpuidle_curr_governor->owner))
+                        return -EINVAL;
+                list_for_each_entry(dev, &cpuidle_detected_devices, device_list)
+                        cpuidle_enable_device(dev);
+                cpuidle_install_idle_handler();
+                printk(KERN_INFO "cpuidle: using governor %s\n", gov->name);
+        }
+
+        return 0;
+}
+
+/**
+ * cpuidle_register_governor - registers a governor
+ * @gov: the governor
+ */
+int cpuidle_register_governor(struct cpuidle_governor *gov)
+{
+        int ret = -EEXIST;
+
+        if (!gov || !gov->select)
+                return -EINVAL;
+
+        mutex_lock(&cpuidle_lock);
+        if (__cpuidle_find_governor(gov->name) == NULL) {
+                ret = 0;
+                list_add_tail(&gov->governor_list, &cpuidle_governors);
+                if (!cpuidle_curr_governor ||
+                    cpuidle_curr_governor->rating < gov->rating)
+                        cpuidle_switch_governor(gov);
+        }
+        mutex_unlock(&cpuidle_lock);
+
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_governor);
+
+/**
+ * cpuidle_replace_governor - find a replacement governor
+ * @exclude_rating: the rating that will be skipped while looking for
+ * new governor.
+ */
+static struct cpuidle_governor *cpuidle_replace_governor(int exclude_rating)
+{
+        struct cpuidle_governor *gov;
+        struct cpuidle_governor *ret_gov = NULL;
+        unsigned int max_rating = 0;
+
+        list_for_each_entry(gov, &cpuidle_governors, governor_list) {
+                if (gov->rating == exclude_rating)
+                        continue;
+                if (gov->rating > max_rating) {
+                        max_rating = gov->rating;
+                        ret_gov = gov;
+                }
+        }
+
+        return ret_gov;
+}
+
+/**
+ * cpuidle_unregister_governor - unregisters a governor
+ * @gov: the governor
+ */
+void cpuidle_unregister_governor(struct cpuidle_governor *gov)
+{
+        if (!gov)
+                return;
+
+        mutex_lock(&cpuidle_lock);
+        if (gov == cpuidle_curr_governor) {
+                struct cpuidle_governor *new_gov;
+                new_gov = cpuidle_replace_governor(gov->rating);
+                cpuidle_switch_governor(new_gov);
+        }
+        list_del(&gov->governor_list);
+        mutex_unlock(&cpuidle_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_governor);
diff --git a/drivers/cpuidle/governors/Makefile b/drivers/cpuidle/governors/Makefile
new file mode 100644
index 000000000000..1b512722689f
--- /dev/null
+++ b/drivers/cpuidle/governors/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for cpuidle governors.
+#
+
+obj-$(CONFIG_CPU_IDLE_GOV_LADDER) += ladder.o
+obj-$(CONFIG_CPU_IDLE_GOV_MENU) += menu.o
diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
new file mode 100644
index 000000000000..eb666ecae7c9
--- /dev/null
+++ b/drivers/cpuidle/governors/ladder.c
@@ -0,0 +1,166 @@
+/*
+ * ladder.c - the residency ladder algorithm
+ *
+ *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
+ *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
+ *  Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/latency.h>
+#include <linux/moduleparam.h>
+#include <linux/jiffies.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#define PROMOTION_COUNT 4
+#define DEMOTION_COUNT 1
+
+struct ladder_device_state {
+        struct {
+                u32 promotion_count;
+                u32 demotion_count;
+                u32 promotion_time;
+                u32 demotion_time;
+        } threshold;
+        struct {
+                int promotion_count;
+                int demotion_count;
+        } stats;
+};
+
+struct ladder_device {
+        struct ladder_device_state states[CPUIDLE_STATE_MAX];
+        int last_state_idx;
+};
+
+static DEFINE_PER_CPU(struct ladder_device, ladder_devices);
+
+/**
+ * ladder_do_selection - prepares private data for a state change
+ * @ldev: the ladder device
+ * @old_idx: the current state index
+ * @new_idx: the new target state index
+ */
+static inline void ladder_do_selection(struct ladder_device *ldev,
+                                       int old_idx, int new_idx)
+{
+        ldev->states[old_idx].stats.promotion_count = 0;
+        ldev->states[old_idx].stats.demotion_count = 0;
+        ldev->last_state_idx = new_idx;
+}
+
+/**
+ * ladder_select_state - selects the next state to enter
+ * @dev: the CPU
+ */
+static int ladder_select_state(struct cpuidle_device *dev)
+{
+        struct ladder_device *ldev = &__get_cpu_var(ladder_devices);
+        struct ladder_device_state *last_state;
+        int last_residency, last_idx = ldev->last_state_idx;
+
+        if (unlikely(!ldev))
+                return 0;
+
+        last_state = &ldev->states[last_idx];
+
+        if (dev->states[last_idx].flags & CPUIDLE_FLAG_TIME_VALID)
+                last_residency = cpuidle_get_last_residency(dev) - dev->states[last_idx].exit_latency;
+        else
+                last_residency = last_state->threshold.promotion_time + 1;
+
+        /* consider promotion */
+        if (last_idx < dev->state_count - 1 &&
+            last_residency > last_state->threshold.promotion_time &&
+            dev->states[last_idx + 1].exit_latency <= system_latency_constraint()) {
+                last_state->stats.promotion_count++;
+                last_state->stats.demotion_count = 0;
+                if (last_state->stats.promotion_count >= last_state->threshold.promotion_count) {
+                        ladder_do_selection(ldev, last_idx, last_idx + 1);
+                        return last_idx + 1;
+                }
+        }
+
+        /* consider demotion */
+        if (last_idx > 0 &&
+            last_residency < last_state->threshold.demotion_time) {
+                last_state->stats.demotion_count++;
+                last_state->stats.promotion_count = 0;
+                if (last_state->stats.demotion_count >= last_state->threshold.demotion_count) {
+                        ladder_do_selection(ldev, last_idx, last_idx - 1);
+                        return last_idx - 1;
+                }
+        }
+
+        /* otherwise remain at the current state */
+        return last_idx;
+}
+
+/**
+ * ladder_enable_device - setup for the governor
+ * @dev: the CPU
+ */
+static int ladder_enable_device(struct cpuidle_device *dev)
+{
+        int i;
+        struct ladder_device *ldev = &per_cpu(ladder_devices, dev->cpu);
+        struct ladder_device_state *lstate;
+        struct cpuidle_state *state;
+
+        ldev->last_state_idx = 0;
+
+        for (i = 0; i < dev->state_count; i++) {
+                state = &dev->states[i];
+                lstate = &ldev->states[i];
+
+                lstate->stats.promotion_count = 0;
+                lstate->stats.demotion_count = 0;
+
+                lstate->threshold.promotion_count = PROMOTION_COUNT;
+                lstate->threshold.demotion_count = DEMOTION_COUNT;
+
+                if (i < dev->state_count - 1)
+                        lstate->threshold.promotion_time = state->exit_latency;
+                if (i > 0)
+                        lstate->threshold.demotion_time = state->exit_latency;
+        }
+
+        return 0;
+}
+
+static struct cpuidle_governor ladder_governor = {
+        .name =         "ladder",
+        .rating =       10,
+        .enable =       ladder_enable_device,
+        .select =       ladder_select_state,
+        .owner =        THIS_MODULE,
+};
+
+/**
+ * init_ladder - initializes the governor
+ */
+static int __init init_ladder(void)
+{
+        return cpuidle_register_governor(&ladder_governor);
+}
+
+/**
+ * exit_ladder - exits the governor
+ */
+static void __exit exit_ladder(void)
+{
+        cpuidle_unregister_governor(&ladder_governor);
+}
+
+MODULE_LICENSE("GPL");
+module_init(init_ladder);
+module_exit(exit_ladder);
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
new file mode 100644
index 000000000000..299d45c3bdd2
--- /dev/null
+++ b/drivers/cpuidle/governors/menu.c
@@ -0,0 +1,137 @@
+/*
+ * menu.c - the menu idle governor
+ *
+ * Copyright (C) 2006-2007 Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/latency.h>
+#include <linux/time.h>
+#include <linux/ktime.h>
+#include <linux/hrtimer.h>
+#include <linux/tick.h>
+
+#define BREAK_FUZZ      4       /* 4 us */
+
+struct menu_device {
+        int             last_state_idx;
+
+        unsigned int    expected_us;
+        unsigned int    predicted_us;
+        unsigned int    last_measured_us;
+        unsigned int    elapsed_us;
+};
+
+static DEFINE_PER_CPU(struct menu_device, menu_devices);
+
+/**
+ * menu_select - selects the next idle state to enter
+ * @dev: the CPU
+ */
+static int menu_select(struct cpuidle_device *dev)
+{
+        struct menu_device *data = &__get_cpu_var(menu_devices);
+        int i;
+
+        /* determine the expected residency time */
+        data->expected_us =
+                (u32) ktime_to_ns(tick_nohz_get_sleep_length()) / 1000;
+
+        /* find the deepest idle state that satisfies our constraints */
+        for (i = 1; i < dev->state_count; i++) {
+                struct cpuidle_state *s = &dev->states[i];
+
+                if (s->target_residency > data->expected_us)
+                        break;
+                if (s->target_residency > data->predicted_us)
+                        break;
+                if (s->exit_latency > system_latency_constraint())
+                        break;
+        }
+
+        data->last_state_idx = i - 1;
+        return i - 1;
+}
+
+/**
+ * menu_reflect - attempts to guess what happened after entry
+ * @dev: the CPU
+ *
+ * NOTE: it's important to be fast here because this operation will add to
+ *       the overall exit latency.
+ */
+static void menu_reflect(struct cpuidle_device *dev)
+{
+        struct menu_device *data = &__get_cpu_var(menu_devices);
+        int last_idx = data->last_state_idx;
+        unsigned int measured_us =
+                cpuidle_get_last_residency(dev) + data->elapsed_us;
+        struct cpuidle_state *target = &dev->states[last_idx];
+
+        /*
+         * Ugh, this idle state doesn't support residency measurements, so we
+         * are basically lost in the dark.  As a compromise, assume we slept
+         * for one full standard timer tick.  However, be aware that this
+         * could potentially result in a suboptimal state transition.
+         */
+        if (!(target->flags & CPUIDLE_FLAG_TIME_VALID))
+                measured_us = USEC_PER_SEC / HZ;
+
+        /* Predict time remaining until next break event */
+        if (measured_us + BREAK_FUZZ < data->expected_us - target->exit_latency) {
+                data->predicted_us = max(measured_us, data->last_measured_us);
+                data->last_measured_us = measured_us;
+                data->elapsed_us = 0;
+        } else {
+                if (data->elapsed_us < data->elapsed_us + measured_us)
+                        data->elapsed_us = measured_us;
+                else
+                        data->elapsed_us = -1;
+                data->predicted_us = max(measured_us, data->last_measured_us);
+        }
+}
+
+/**
+ * menu_enable_device - scans a CPU's states and does setup
+ * @dev: the CPU
+ */
+static int menu_enable_device(struct cpuidle_device *dev)
+{
+        struct menu_device *data = &per_cpu(menu_devices, dev->cpu);
+
+        memset(data, 0, sizeof(struct menu_device));
+
+        return 0;
+}
+
+static struct cpuidle_governor menu_governor = {
+        .name =         "menu",
+        .rating =       20,
+        .enable =       menu_enable_device,
+        .select =       menu_select,
+        .reflect =      menu_reflect,
+        .owner =        THIS_MODULE,
+};
+
+/**
+ * init_menu - initializes the governor
+ */
+static int __init init_menu(void)
+{
+        return cpuidle_register_governor(&menu_governor);
+}
+
+/**
+ * exit_menu - exits the governor
+ */
+static void __exit exit_menu(void)
+{
+        cpuidle_unregister_governor(&menu_governor);
+}
+
+MODULE_LICENSE("GPL");
+module_init(init_menu);
+module_exit(exit_menu);
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
new file mode 100644
index 000000000000..0f3515e77d4b
--- /dev/null
+++ b/drivers/cpuidle/sysfs.c
@@ -0,0 +1,361 @@
+/*
+ * sysfs.c - sysfs support
+ *
+ * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/sysfs.h>
+#include <linux/cpu.h>
+
+#include "cpuidle.h"
+
+static unsigned int sysfs_switch;
+static int __init cpuidle_sysfs_setup(char *unused)
+{
+        sysfs_switch = 1;
+        return 1;
+}
+__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
+
+static ssize_t show_available_governors(struct sys_device *dev, char *buf)
+{
+        ssize_t i = 0;
+        struct cpuidle_governor *tmp;
+
+        mutex_lock(&cpuidle_lock);
+        list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
+                if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
+                        goto out;
+                i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
+        }
+
+out:
+        i+= sprintf(&buf[i], "\n");
+        mutex_unlock(&cpuidle_lock);
+        return i;
+}
+
+static ssize_t show_current_driver(struct sys_device *dev, char *buf)
+{
+        ssize_t ret;
+
+        spin_lock(&cpuidle_driver_lock);
+        if (cpuidle_curr_driver)
+                ret = sprintf(buf, "%s\n", cpuidle_curr_driver->name);
+        else
+                ret = sprintf(buf, "none\n");
+        spin_unlock(&cpuidle_driver_lock);
+
+        return ret;
+}
+
+static ssize_t show_current_governor(struct sys_device *dev, char *buf)
+{
+        ssize_t ret;
+
+        mutex_lock(&cpuidle_lock);
+        if (cpuidle_curr_governor)
+                ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
+        else
+                ret = sprintf(buf, "none\n");
+        mutex_unlock(&cpuidle_lock);
+
+        return ret;
+}
+
+static ssize_t store_current_governor(struct sys_device *dev,
+        const char *buf, size_t count)
+{
+        char gov_name[CPUIDLE_NAME_LEN];
+        int ret = -EINVAL;
+        size_t len = count;
+        struct cpuidle_governor *gov;
+
+        if (!len || len >= sizeof(gov_name))
+                return -EINVAL;
+
+        memcpy(gov_name, buf, len);
+        gov_name[len] = '\0';
+        if (gov_name[len - 1] == '\n')
+                gov_name[--len] = '\0';
+
+        mutex_lock(&cpuidle_lock);
+
+        list_for_each_entry(gov, &cpuidle_governors, governor_list) {
+                if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
+                        ret = cpuidle_switch_governor(gov);
+                        break;
+                }
+        }
+
+        mutex_unlock(&cpuidle_lock);
+
+        if (ret)
+                return ret;
+        else
+                return count;
+}
+
+static SYSDEV_ATTR(current_driver, 0444, show_current_driver, NULL);
+static SYSDEV_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
+
+static struct attribute *cpuclass_default_attrs[] = {
+        &attr_current_driver.attr,
+        &attr_current_governor_ro.attr,
+        NULL
+};
+
+static SYSDEV_ATTR(available_governors, 0444, show_available_governors, NULL);
+static SYSDEV_ATTR(current_governor, 0644, show_current_governor,
+        store_current_governor);
+
+static struct attribute *cpuclass_switch_attrs[] = {
+        &attr_available_governors.attr,
+        &attr_current_driver.attr,
+        &attr_current_governor.attr,
+        NULL
+};
+
+static struct attribute_group cpuclass_attr_group = {
+        .attrs = cpuclass_default_attrs,
+        .name = "cpuidle",
+};
+
+/**
+ * cpuidle_add_class_sysfs - add CPU global sysfs attributes
+ */
+int cpuidle_add_class_sysfs(struct sysdev_class *cls)
+{
+        if (sysfs_switch)
+                cpuclass_attr_group.attrs = cpuclass_switch_attrs;
+
+        return sysfs_create_group(&cls->kset.kobj, &cpuclass_attr_group);
+}
+
+/**
+ * cpuidle_remove_class_sysfs - remove CPU global sysfs attributes
+ */
+void cpuidle_remove_class_sysfs(struct sysdev_class *cls)
+{
+        sysfs_remove_group(&cls->kset.kobj, &cpuclass_attr_group);
+}
+
+struct cpuidle_attr {
+        struct attribute attr;
+        ssize_t (*show)(struct cpuidle_device *, char *);
+        ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
+};
+
+#define define_one_ro(_name, show) \
+        static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
+#define define_one_rw(_name, show, store) \
+        static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
+
+#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
+#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
+static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
+{
+        int ret = -EIO;
+        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+
+        if (cattr->show) {
+                mutex_lock(&cpuidle_lock);
+                ret = cattr->show(dev, buf);
+                mutex_unlock(&cpuidle_lock);
+        }
+        return ret;
+}
+
+static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
+                     const char * buf, size_t count)
+{
+        int ret = -EIO;
+        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+
+        if (cattr->store) {
+                mutex_lock(&cpuidle_lock);
+                ret = cattr->store(dev, buf, count);
+                mutex_unlock(&cpuidle_lock);
+        }
+        return ret;
+}
+
+static struct sysfs_ops cpuidle_sysfs_ops = {
+        .show = cpuidle_show,
+        .store = cpuidle_store,
+};
+
+static void cpuidle_sysfs_release(struct kobject *kobj)
+{
+        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+
+        complete(&dev->kobj_unregister);
+}
+
+static struct kobj_type ktype_cpuidle = {
+        .sysfs_ops = &cpuidle_sysfs_ops,
+        .release = cpuidle_sysfs_release,
+};
+
+struct cpuidle_state_attr {
+        struct attribute attr;
+        ssize_t (*show)(struct cpuidle_state *, char *);
+        ssize_t (*store)(struct cpuidle_state *, const char *, size_t);
+};
+
+#define define_one_state_ro(_name, show) \
+static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
+
+#define define_show_state_function(_name) \
+static ssize_t show_state_##_name(struct cpuidle_state *state, char *buf) \
+{ \
+        return sprintf(buf, "%u\n", state->_name);\
+}
+
+static ssize_t show_state_name(struct cpuidle_state *state, char *buf)
+{
+        return sprintf(buf, "%s\n", state->name);
+}
+
+define_show_state_function(exit_latency)
+define_show_state_function(power_usage)
+define_show_state_function(usage)
+define_show_state_function(time)
+define_one_state_ro(name, show_state_name);
+define_one_state_ro(latency, show_state_exit_latency);
+define_one_state_ro(power, show_state_power_usage);
+define_one_state_ro(usage, show_state_usage);
+define_one_state_ro(time, show_state_time);
+
+static struct attribute *cpuidle_state_default_attrs[] = {
+        &attr_name.attr,
+        &attr_latency.attr,
+        &attr_power.attr,
+        &attr_usage.attr,
+        &attr_time.attr,
+        NULL
+};
+
+#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
+#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
+#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
+static ssize_t cpuidle_state_show(struct kobject * kobj,
+        struct attribute * attr ,char * buf)
+{
+        int ret = -EIO;
+        struct cpuidle_state *state = kobj_to_state(kobj);
+        struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
+
+        if (cattr->show)
+                ret = cattr->show(state, buf);
+
+        return ret;
+}
+
+static struct sysfs_ops cpuidle_state_sysfs_ops = {
+        .show = cpuidle_state_show,
+};
+
+static void cpuidle_state_sysfs_release(struct kobject *kobj)
+{
+        struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
+
+        complete(&state_obj->kobj_unregister);
+}
+
+static struct kobj_type ktype_state_cpuidle = {
+        .sysfs_ops = &cpuidle_state_sysfs_ops,
+        .default_attrs = cpuidle_state_default_attrs,
+        .release = cpuidle_state_sysfs_release,
+};
+
+static void inline cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
+{
+        kobject_unregister(&device->kobjs[i]->kobj);
+        wait_for_completion(&device->kobjs[i]->kobj_unregister);
+        kfree(device->kobjs[i]);
+        device->kobjs[i] = NULL;
+}
+
+/**
+ * cpuidle_add_driver_sysfs - adds driver-specific sysfs attributes
+ * @device: the target device
+ */
+int cpuidle_add_state_sysfs(struct cpuidle_device *device)
+{
+        int i, ret = -ENOMEM;
+        struct cpuidle_state_kobj *kobj;
+
+        /* state statistics */
+        for (i = 0; i < device->state_count; i++) {
+                kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
+                if (!kobj)
+                        goto error_state;
+                kobj->state = &device->states[i];
+                init_completion(&kobj->kobj_unregister);
+
+                kobj->kobj.parent = &device->kobj;
+                kobj->kobj.ktype = &ktype_state_cpuidle;
+                kobject_set_name(&kobj->kobj, "state%d", i);
+                ret = kobject_register(&kobj->kobj);
+                if (ret) {
+                        kfree(kobj);
+                        goto error_state;
+                }
+                device->kobjs[i] = kobj;
+        }
+
+        return 0;
+
+error_state:
+        for (i = i - 1; i >= 0; i--)
+                cpuidle_free_state_kobj(device, i);
+        return ret;
+}
+
+/**
+ * cpuidle_remove_driver_sysfs - removes driver-specific sysfs attributes
+ * @device: the target device
+ */
+void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
+{
+        int i;
+
+        for (i = 0; i < device->state_count; i++)
+                cpuidle_free_state_kobj(device, i);
+}
+
+/**
+ * cpuidle_add_sysfs - creates a sysfs instance for the target device
+ * @sysdev: the target device
+ */
+int cpuidle_add_sysfs(struct sys_device *sysdev)
+{
+        int cpu = sysdev->id;
+        struct cpuidle_device *dev;
+
+        dev = per_cpu(cpuidle_devices, cpu);
+        dev->kobj.parent = &sysdev->kobj;
+        dev->kobj.ktype = &ktype_cpuidle;
+        kobject_set_name(&dev->kobj, "%s", "cpuidle");
+        return kobject_register(&dev->kobj);
+}
+
+/**
+ * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
+ * @sysdev: the target device
+ */
+void cpuidle_remove_sysfs(struct sys_device *sysdev)
+{
+        int cpu = sysdev->id;
+        struct cpuidle_device *dev;
+
+        dev = per_cpu(cpuidle_devices, cpu);
+        kobject_unregister(&dev->kobj);
+}