Merge branch 'pm-cpuidle'

* pm-cpuidle: (25 commits)
  cpuidle: Change struct menu_device field types
  cpuidle: Add a comment warning about possible overflow
  cpuidle: Fix variable domains in get_typical_interval()
  cpuidle: Fix menu_device->intervals type
  cpuidle: CodingStyle: Break up multiple assignments on single line
  cpuidle: Check called function parameter in get_typical_interval()
  cpuidle: Rearrange code and comments in get_typical_interval()
  cpuidle: Ignore interval prediction result when timer is shorter
  cpuidle-kirkwood.c: simplify use of devm_ioremap_resource()
  cpuidle: kirkwood: Make kirkwood_cpuidle_remove function static
  cpuidle: calxeda: Add missing __iomem annotation
  SH: cpuidle: Add missing parameter for cpuidle_register()
  ARM: ux500: cpuidle: Move ux500 cpuidle driver to drivers/cpuidle
  ARM: ux500: cpuidle: Remove pointless include
  ARM: ux500: cpuidle: Instantiate the driver from platform device
  ARM: davinci: cpuidle: Fix target residency
  cpuidle: Add Kconfig.arm and move calxeda, kirkwood and zynq
  cpuidle: Check if device is already registered
  cpuidle: Introduce __cpuidle_device_init()
  cpuidle: Introduce __cpuidle_unregister_device()
  ...

15 files changed, 256 insertions, 163 deletions

diff --git a/arch/arm/mach-davinci/cpuidle.c b/arch/arm/mach-davinci/cpuidle.c
index 36aef3a7dedb..f1ac1c94ac0f 100644
--- a/arch/arm/mach-davinci/cpuidle.c
+++ b/arch/arm/mach-davinci/cpuidle.c
@@ -65,7 +65,7 @@ static struct cpuidle_driver davinci_idle_driver = {
         .states[1]              = {
                 .enter                  = davinci_enter_idle,
                 .exit_latency           = 10,
-                .target_residency       = 100000,
+                .target_residency       = 10000,
                 .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "DDR SR",
                 .desc                   = "WFI and DDR Self Refresh",
diff --git a/arch/arm/mach-ux500/Makefile b/arch/arm/mach-ux500/Makefile
index bf9b6be5b180..fe1f3e26b88b 100644
--- a/arch/arm/mach-ux500/Makefile
+++ b/arch/arm/mach-ux500/Makefile
@@ -4,7 +4,6 @@
 
 obj-y                           := cpu.o devices.o devices-common.o \
                                    id.o usb.o timer.o pm.o
-obj-$(CONFIG_CPU_IDLE)          += cpuidle.o
 obj-$(CONFIG_CACHE_L2X0)        += cache-l2x0.o
 obj-$(CONFIG_UX500_SOC_DB8500)  += cpu-db8500.o devices-db8500.o
 obj-$(CONFIG_MACH_MOP500)       += board-mop500.o board-mop500-sdi.o \
diff --git a/arch/sh/kernel/cpu/shmobile/cpuidle.c b/arch/sh/kernel/cpu/shmobile/cpuidle.c
index d30622592116..e3abfd4277e2 100644
--- a/arch/sh/kernel/cpu/shmobile/cpuidle.c
+++ b/arch/sh/kernel/cpu/shmobile/cpuidle.c
@@ -91,13 +91,11 @@ static struct cpuidle_driver cpuidle_driver = {
 
 int __init sh_mobile_setup_cpuidle(void)
 {
-        int ret;
-
         if (sh_mobile_sleep_supported & SUSP_SH_SF)
                 cpuidle_driver.states[1].disabled = false;
 
         if (sh_mobile_sleep_supported & SUSP_SH_STANDBY)
                 cpuidle_driver.states[2].disabled = false;
 
-        return cpuidle_register(&cpuidle_driver);
+        return cpuidle_register(&cpuidle_driver, NULL);
 }
diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig
index 0e2cd5cab4d0..b3fb81d7cf04 100644
--- a/drivers/cpuidle/Kconfig
+++ b/drivers/cpuidle/Kconfig
@@ -1,5 +1,6 @@
+menu "CPU Idle"
 
-menuconfig CPU_IDLE
+config CPU_IDLE
         bool "CPU idle PM support"
         default y if ACPI || PPC_PSERIES
         select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE)
@@ -29,20 +30,13 @@ config CPU_IDLE_GOV_MENU
         bool "Menu governor (for tickless system)"
         default y
 
-config CPU_IDLE_CALXEDA
-        bool "CPU Idle Driver for Calxeda processors"
-        depends on ARCH_HIGHBANK
-        select ARM_CPU_SUSPEND
-        help
-          Select this to enable cpuidle on Calxeda processors.
-
-config CPU_IDLE_ZYNQ
-        bool "CPU Idle Driver for Xilinx Zynq processors"
-        depends on ARCH_ZYNQ
-        help
-          Select this to enable cpuidle on Xilinx Zynq processors.
+menu "ARM CPU Idle Drivers"
+depends on ARM
+source "drivers/cpuidle/Kconfig.arm"
+endmenu
 
 endif
 
 config ARCH_NEEDS_CPU_IDLE_COUPLED
         def_bool n
+endmenu
diff --git a/drivers/cpuidle/Kconfig.arm b/drivers/cpuidle/Kconfig.arm
new file mode 100644
index 000000000000..b3302193c15a
--- /dev/null
+++ b/drivers/cpuidle/Kconfig.arm
@@ -0,0 +1,29 @@
+#
+# ARM CPU Idle drivers
+#
+
+config ARM_HIGHBANK_CPUIDLE
+        bool "CPU Idle Driver for Calxeda processors"
+        depends on ARCH_HIGHBANK
+        select ARM_CPU_SUSPEND
+        help
+          Select this to enable cpuidle on Calxeda processors.
+
+config ARM_KIRKWOOD_CPUIDLE
+        bool "CPU Idle Driver for Marvell Kirkwood SoCs"
+        depends on ARCH_KIRKWOOD
+        help
+          This adds the CPU Idle driver for Marvell Kirkwood SoCs.
+
+config ARM_ZYNQ_CPUIDLE
+        bool "CPU Idle Driver for Xilinx Zynq processors"
+        depends on ARCH_ZYNQ
+        help
+          Select this to enable cpuidle on Xilinx Zynq processors.
+
+config ARM_U8500_CPUIDLE
+        bool "Cpu Idle Driver for the ST-E u8500 processors"
+        depends on ARCH_U8500
+        help
+          Select this to enable cpuidle for ST-E u8500 processors
+
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
index 8767a7b3eb91..0b9d200c7e45 100644
--- a/drivers/cpuidle/Makefile
+++ b/drivers/cpuidle/Makefile
@@ -5,6 +5,9 @@
 obj-y += cpuidle.o driver.o governor.o sysfs.o governors/
 obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
 
-obj-$(CONFIG_CPU_IDLE_CALXEDA) += cpuidle-calxeda.o
-obj-$(CONFIG_ARCH_KIRKWOOD) += cpuidle-kirkwood.o
-obj-$(CONFIG_CPU_IDLE_ZYNQ) += cpuidle-zynq.o
+##################################################################################
+# ARM SoC drivers
+obj-$(CONFIG_ARM_HIGHBANK_CPUIDLE)      += cpuidle-calxeda.o
+obj-$(CONFIG_ARM_KIRKWOOD_CPUIDLE)      += cpuidle-kirkwood.o
+obj-$(CONFIG_ARM_ZYNQ_CPUIDLE)          += cpuidle-zynq.o
+obj-$(CONFIG_ARM_U8500_CPUIDLE)         += cpuidle-ux500.o
diff --git a/drivers/cpuidle/cpuidle-calxeda.c b/drivers/cpuidle/cpuidle-calxeda.c
index 0e6e408c0a63..346058479572 100644
--- a/drivers/cpuidle/cpuidle-calxeda.c
+++ b/drivers/cpuidle/cpuidle-calxeda.c
@@ -35,7 +35,7 @@
 #include <asm/cp15.h>
 
 extern void highbank_set_cpu_jump(int cpu, void *jump_addr);
-extern void *scu_base_addr;
+extern void __iomem *scu_base_addr;
 
 static noinline void calxeda_idle_restore(void)
 {
diff --git a/drivers/cpuidle/cpuidle-kirkwood.c b/drivers/cpuidle/cpuidle-kirkwood.c
index 521b0a7fdd89..41ba843251b8 100644
--- a/drivers/cpuidle/cpuidle-kirkwood.c
+++ b/drivers/cpuidle/cpuidle-kirkwood.c
@@ -60,9 +60,6 @@ static int kirkwood_cpuidle_probe(struct platform_device *pdev)
         struct resource *res;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL)
-                return -EINVAL;
-
         ddr_operation_base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(ddr_operation_base))
                 return PTR_ERR(ddr_operation_base);
@@ -70,7 +67,7 @@ static int kirkwood_cpuidle_probe(struct platform_device *pdev)
         return cpuidle_register(&kirkwood_idle_driver, NULL);
 }
 
-int kirkwood_cpuidle_remove(struct platform_device *pdev)
+static int kirkwood_cpuidle_remove(struct platform_device *pdev)
 {
         cpuidle_unregister(&kirkwood_idle_driver);
         return 0;
diff --git a/arch/arm/mach-ux500/cpuidle.c b/drivers/cpuidle/cpuidle-ux500.c
index a45dd09daed9..e0564652af35 100644
--- a/arch/arm/mach-ux500/cpuidle.c
+++ b/drivers/cpuidle/cpuidle-ux500.c
@@ -16,13 +16,11 @@
 #include <linux/smp.h>
 #include <linux/mfd/dbx500-prcmu.h>
 #include <linux/platform_data/arm-ux500-pm.h>
+#include <linux/platform_device.h>
 
 #include <asm/cpuidle.h>
 #include <asm/proc-fns.h>
 
-#include "db8500-regs.h"
-#include "id.h"
-
 static atomic_t master = ATOMIC_INIT(0);
 static DEFINE_SPINLOCK(master_lock);
 
@@ -113,11 +111,8 @@ static struct cpuidle_driver ux500_idle_driver = {
         .state_count = 2,
 };
 
-int __init ux500_idle_init(void)
+static int __init dbx500_cpuidle_probe(struct platform_device *pdev)
 {
-        if (!(cpu_is_u8500_family() || cpu_is_ux540_family()))
-                return -ENODEV;
-
         /* Configure wake up reasons */
         prcmu_enable_wakeups(PRCMU_WAKEUP(ARM) | PRCMU_WAKEUP(RTC) |
                              PRCMU_WAKEUP(ABB));
@@ -125,4 +120,12 @@ int __init ux500_idle_init(void)
         return cpuidle_register(&ux500_idle_driver, NULL);
 }
 
-device_initcall(ux500_idle_init);
+static struct platform_driver dbx500_cpuidle_plat_driver = {
+        .driver = {
+                .name = "cpuidle-dbx500",
+                .owner = THIS_MODULE,
+        },
+        .probe = dbx500_cpuidle_probe,
+};
+
+module_platform_driver(dbx500_cpuidle_plat_driver);
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index fdc432f18022..d75040ddd2b3 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -42,8 +42,6 @@ void disable_cpuidle(void)
         off = 1;
 }
 
-static int __cpuidle_register_device(struct cpuidle_device *dev);
-
 /**
  * cpuidle_play_dead - cpu off-lining
  *
@@ -278,7 +276,7 @@ static void poll_idle_init(struct cpuidle_driver *drv) {}
  */
 int cpuidle_enable_device(struct cpuidle_device *dev)
 {
-        int ret, i;
+        int ret;
         struct cpuidle_driver *drv;
 
         if (!dev)
@@ -292,15 +290,12 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
         if (!drv || !cpuidle_curr_governor)
                 return -EIO;
 
+        if (!dev->registered)
+                return -EINVAL;
+
         if (!dev->state_count)
                 dev->state_count = drv->state_count;
 
-        if (dev->registered == 0) {
-                ret = __cpuidle_register_device(dev);
-                if (ret)
-                        return ret;
-        }
-
         poll_idle_init(drv);
 
         ret = cpuidle_add_device_sysfs(dev);
@@ -311,12 +306,6 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
             (ret = cpuidle_curr_governor->enable(drv, dev)))
                 goto fail_sysfs;
 
-        for (i = 0; i < dev->state_count; i++) {
-                dev->states_usage[i].usage = 0;
-                dev->states_usage[i].time = 0;
-        }
-        dev->last_residency = 0;
-
         smp_wmb();
 
         dev->enabled = 1;
@@ -360,6 +349,23 @@ void cpuidle_disable_device(struct cpuidle_device *dev)
 
 EXPORT_SYMBOL_GPL(cpuidle_disable_device);
 
+static void __cpuidle_unregister_device(struct cpuidle_device *dev)
+{
+        struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
+
+        list_del(&dev->device_list);
+        per_cpu(cpuidle_devices, dev->cpu) = NULL;
+        module_put(drv->owner);
+}
+
+static int __cpuidle_device_init(struct cpuidle_device *dev)
+{
+        memset(dev->states_usage, 0, sizeof(dev->states_usage));
+        dev->last_residency = 0;
+
+        return 0;
+}
+
 /**
  * __cpuidle_register_device - internal register function called before register
  * and enable routines
@@ -377,24 +383,15 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
 
         per_cpu(cpuidle_devices, dev->cpu) = dev;
         list_add(&dev->device_list, &cpuidle_detected_devices);
-        ret = cpuidle_add_sysfs(dev);
-        if (ret)
-                goto err_sysfs;
 
         ret = cpuidle_coupled_register_device(dev);
-        if (ret)
-                goto err_coupled;
+        if (ret) {
+                __cpuidle_unregister_device(dev);
+                return ret;
+        }
 
         dev->registered = 1;
         return 0;
-
-err_coupled:
-        cpuidle_remove_sysfs(dev);
-err_sysfs:
-        list_del(&dev->device_list);
-        per_cpu(cpuidle_devices, dev->cpu) = NULL;
-        module_put(drv->owner);
-        return ret;
 }
 
 /**
@@ -403,25 +400,44 @@ err_sysfs:
  */
 int cpuidle_register_device(struct cpuidle_device *dev)
 {
-        int ret;
+        int ret = -EBUSY;
 
         if (!dev)
                 return -EINVAL;
 
         mutex_lock(&cpuidle_lock);
 
-        if ((ret = __cpuidle_register_device(dev))) {
-                mutex_unlock(&cpuidle_lock);
-                return ret;
-        }
+        if (dev->registered)
+                goto out_unlock;
+
+        ret = __cpuidle_device_init(dev);
+        if (ret)
+                goto out_unlock;
+
+        ret = __cpuidle_register_device(dev);
+        if (ret)
+                goto out_unlock;
+
+        ret = cpuidle_add_sysfs(dev);
+        if (ret)
+                goto out_unregister;
+
+        ret = cpuidle_enable_device(dev);
+        if (ret)
+                goto out_sysfs;
 
-        cpuidle_enable_device(dev);
         cpuidle_install_idle_handler();
 
+out_unlock:
         mutex_unlock(&cpuidle_lock);
 
-        return 0;
+        return ret;
 
+out_sysfs:
+        cpuidle_remove_sysfs(dev);
+out_unregister:
+        __cpuidle_unregister_device(dev);
+        goto out_unlock;
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_register_device);
@@ -432,8 +448,6 @@ EXPORT_SYMBOL_GPL(cpuidle_register_device);
  */
 void cpuidle_unregister_device(struct cpuidle_device *dev)
 {
-        struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
-
         if (dev->registered == 0)
                 return;
 
@@ -442,14 +456,12 @@ void cpuidle_unregister_device(struct cpuidle_device *dev)
         cpuidle_disable_device(dev);
 
         cpuidle_remove_sysfs(dev);
-        list_del(&dev->device_list);
-        per_cpu(cpuidle_devices, dev->cpu) = NULL;
+
+        __cpuidle_unregister_device(dev);
 
         cpuidle_coupled_unregister_device(dev);
 
         cpuidle_resume_and_unlock();
-
-        module_put(drv->owner);
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_unregister_device);
diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
index 9b784051ec12..9f08e8cce1af 100644
--- a/drivers/cpuidle/governors/ladder.c
+++ b/drivers/cpuidle/governors/ladder.c
@@ -192,14 +192,4 @@ static int __init init_ladder(void)
         return cpuidle_register_governor(&ladder_governor);
 }
 
-/**
- * exit_ladder - exits the governor
- */
-static void __exit exit_ladder(void)
-{
-        cpuidle_unregister_governor(&ladder_governor);
-}
-
-MODULE_LICENSE("GPL");
-module_init(init_ladder);
-module_exit(exit_ladder);
+postcore_initcall(init_ladder);
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index bc580b67a652..cf7f2f0e4ef5 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -21,6 +21,15 @@
 #include <linux/math64.h>
 #include <linux/module.h>
 
+/*
+ * Please note when changing the tuning values:
+ * If (MAX_INTERESTING-1) * RESOLUTION > UINT_MAX, the result of
+ * a scaling operation multiplication may overflow on 32 bit platforms.
+ * In that case, #define RESOLUTION as ULL to get 64 bit result:
+ * #define RESOLUTION 1024ULL
+ *
+ * The default values do not overflow.
+ */
 #define BUCKETS 12
 #define INTERVALS 8
 #define RESOLUTION 1024
@@ -114,11 +123,11 @@ struct menu_device {
         int             needs_update;
 
         unsigned int    expected_us;
-        u64             predicted_us;
+        unsigned int    predicted_us;
         unsigned int    exit_us;
         unsigned int    bucket;
-        u64             correction_factor[BUCKETS];
-        u32             intervals[INTERVALS];
+        unsigned int    correction_factor[BUCKETS];
+        unsigned int    intervals[INTERVALS];
         int             interval_ptr;
 };
 
@@ -199,16 +208,20 @@ static u64 div_round64(u64 dividend, u32 divisor)
  */
 static void get_typical_interval(struct menu_device *data)
 {
-        int i = 0, divisor = 0;
-        uint64_t max = 0, avg = 0, stddev = 0;
-        int64_t thresh = LLONG_MAX; /* Discard outliers above this value. */
+        int i, divisor;
+        unsigned int max, thresh;
+        uint64_t avg, stddev;
+
+        thresh = UINT_MAX; /* Discard outliers above this value */
 
 again:
 
-        /* first calculate average and standard deviation of the past */
-        max = avg = divisor = stddev = 0;
+        /* First calculate the average of past intervals */
+        max = 0;
+        avg = 0;
+        divisor = 0;
         for (i = 0; i < INTERVALS; i++) {
-                int64_t value = data->intervals[i];
+                unsigned int value = data->intervals[i];
                 if (value <= thresh) {
                         avg += value;
                         divisor++;
@@ -218,15 +231,38 @@ again:
         }
         do_div(avg, divisor);
 
+        /* Then try to determine standard deviation */
+        stddev = 0;
         for (i = 0; i < INTERVALS; i++) {
-                int64_t value = data->intervals[i];
+                unsigned int value = data->intervals[i];
                 if (value <= thresh) {
                         int64_t diff = value - avg;
                         stddev += diff * diff;
                 }
         }
         do_div(stddev, divisor);
-        stddev = int_sqrt(stddev);
+        /*
+         * The typical interval is obtained when standard deviation is small
+         * or standard deviation is small compared to the average interval.
+         *
+         * int_sqrt() formal parameter type is unsigned long. When the
+         * greatest difference to an outlier exceeds ~65 ms * sqrt(divisor)
+         * the resulting squared standard deviation exceeds the input domain
+         * of int_sqrt on platforms where unsigned long is 32 bits in size.
+         * In such case reject the candidate average.
+         *
+         * Use this result only if there is no timer to wake us up sooner.
+         */
+        if (likely(stddev <= ULONG_MAX)) {
+                stddev = int_sqrt(stddev);
+                if (((avg > stddev * 6) && (divisor * 4 >= INTERVALS * 3))
+                                                        || stddev <= 20) {
+                        if (data->expected_us > avg)
+                                data->predicted_us = avg;
+                        return;
+                }
+        }
+
         /*
          * If we have outliers to the upside in our distribution, discard
          * those by setting the threshold to exclude these outliers, then
@@ -235,20 +271,12 @@ again:
          *
          * This can deal with workloads that have long pauses interspersed
          * with sporadic activity with a bunch of short pauses.
-         *
-         * The typical interval is obtained when standard deviation is small
-         * or standard deviation is small compared to the average interval.
          */
-        if (((avg > stddev * 6) && (divisor * 4 >= INTERVALS * 3))
-                                                        || stddev <= 20) {
-                data->predicted_us = avg;
+        if ((divisor * 4) <= INTERVALS * 3)
                 return;
 
-        } else if ((divisor * 4) > INTERVALS * 3) {
-                /* Exclude the max interval */
-                thresh = max - 1;
-                goto again;
-        }
+        thresh = max - 1;
+        goto again;
 }
 
 /**
@@ -293,8 +321,13 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
         if (data->correction_factor[data->bucket] == 0)
                 data->correction_factor[data->bucket] = RESOLUTION * DECAY;
 
-        /* Make sure to round up for half microseconds */
-        data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket],
+        /*
+         * Force the result of multiplication to be 64 bits even if both
+         * operands are 32 bits.
+         * Make sure to round up for half microseconds.
+         */
+        data->predicted_us = div_round64((uint64_t)data->expected_us *
+                                         data->correction_factor[data->bucket],
                                          RESOLUTION * DECAY);
 
         get_typical_interval(data);
@@ -360,7 +393,7 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
         unsigned int last_idle_us = cpuidle_get_last_residency(dev);
         struct cpuidle_state *target = &drv->states[last_idx];
         unsigned int measured_us;
-        u64 new_factor;
+        unsigned int new_factor;
 
         /*
          * Ugh, this idle state doesn't support residency measurements, so we
@@ -381,10 +414,9 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
                 measured_us -= data->exit_us;
 
 
-        /* update our correction ratio */
-
-        new_factor = data->correction_factor[data->bucket]
-                        * (DECAY - 1) / DECAY;
+        /* Update our correction ratio */
+        new_factor = data->correction_factor[data->bucket];
+        new_factor -= new_factor / DECAY;
 
         if (data->expected_us > 0 && measured_us < MAX_INTERESTING)
                 new_factor += RESOLUTION * measured_us / data->expected_us;
@@ -397,9 +429,11 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
 
         /*
          * We don't want 0 as factor; we always want at least
-         * a tiny bit of estimated time.
+         * a tiny bit of estimated time. Fortunately, due to rounding,
+         * new_factor will stay nonzero regardless of measured_us values
+         * and the compiler can eliminate this test as long as DECAY > 1.
          */
-        if (new_factor == 0)
+        if (DECAY == 1 && unlikely(new_factor == 0))
                 new_factor = 1;
 
         data->correction_factor[data->bucket] = new_factor;
@@ -442,14 +476,4 @@ static int __init init_menu(void)
         return cpuidle_register_governor(&menu_governor);
 }
 
-/**
- * exit_menu - exits the governor
- */
-static void __exit exit_menu(void)
-{
-        cpuidle_unregister_governor(&menu_governor);
-}
-
-MODULE_LICENSE("GPL");
-module_init(init_menu);
-module_exit(exit_menu);
+postcore_initcall(init_menu);
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 428754af6236..8739cc05228c 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -11,8 +11,10 @@
 #include <linux/sysfs.h>
 #include <linux/slab.h>
 #include <linux/cpu.h>
+#include <linux/completion.h>
 #include <linux/capability.h>
 #include <linux/device.h>
+#include <linux/kobject.h>
 
 #include "cpuidle.h"
 
@@ -33,7 +35,8 @@ static ssize_t show_available_governors(struct device *dev,
 
         mutex_lock(&cpuidle_lock);
         list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
-                if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
+                if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
+                                    CPUIDLE_NAME_LEN - 2))
                         goto out;
                 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
         }
@@ -166,13 +169,28 @@ struct cpuidle_attr {
 #define define_one_rw(_name, show, store) \
         static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
 
-#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
 #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
-static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
+
+struct cpuidle_device_kobj {
+        struct cpuidle_device *dev;
+        struct completion kobj_unregister;
+        struct kobject kobj;
+};
+
+static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
+{
+        struct cpuidle_device_kobj *kdev =
+                container_of(kobj, struct cpuidle_device_kobj, kobj);
+
+        return kdev->dev;
+}
+
+static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
+                            char *buf)
 {
         int ret = -EIO;
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
-        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+        struct cpuidle_device *dev = to_cpuidle_device(kobj);
+        struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
 
         if (cattr->show) {
                 mutex_lock(&cpuidle_lock);
@@ -182,12 +200,12 @@ static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char
         return ret;
 }
 
-static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
-                     const char * buf, size_t count)
+static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
+                             const char *buf, size_t count)
 {
         int ret = -EIO;
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
-        struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+        struct cpuidle_device *dev = to_cpuidle_device(kobj);
+        struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
 
         if (cattr->store) {
                 mutex_lock(&cpuidle_lock);
@@ -204,9 +222,10 @@ static const struct sysfs_ops cpuidle_sysfs_ops = {
 
 static void cpuidle_sysfs_release(struct kobject *kobj)
 {
-        struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+        struct cpuidle_device_kobj *kdev =
+                container_of(kobj, struct cpuidle_device_kobj, kobj);
 
-        complete(&dev->kobj_unregister);
+        complete(&kdev->kobj_unregister);
 }
 
 static struct kobj_type ktype_cpuidle = {
@@ -237,8 +256,8 @@ static ssize_t show_state_##_name(struct cpuidle_state *state, \
 
 #define define_store_state_ull_function(_name) \
 static ssize_t store_state_##_name(struct cpuidle_state *state, \
-                struct cpuidle_state_usage *state_usage, \
-                const char *buf, size_t size) \
+                                   struct cpuidle_state_usage *state_usage, \
+                                   const char *buf, size_t size)        \
 { \
         unsigned long long value; \
         int err; \
@@ -256,14 +275,16 @@ static ssize_t store_state_##_name(struct cpuidle_state *state, \
 
 #define define_show_state_ull_function(_name) \
 static ssize_t show_state_##_name(struct cpuidle_state *state, \
-                        struct cpuidle_state_usage *state_usage, char *buf) \
+                                  struct cpuidle_state_usage *state_usage, \
+                                  char *buf)                            \
 { \
         return sprintf(buf, "%llu\n", state_usage->_name);\
 }
 
 #define define_show_state_str_function(_name) \
 static ssize_t show_state_##_name(struct cpuidle_state *state, \
-                        struct cpuidle_state_usage *state_usage, char *buf) \
+                                  struct cpuidle_state_usage *state_usage, \
+                                  char *buf)                            \
 { \
         if (state->_name[0] == '\0')\
                 return sprintf(buf, "<null>\n");\
@@ -309,8 +330,9 @@ struct cpuidle_state_kobj {
 #define kobj_to_state(k) (kobj_to_state_obj(k)->state)
 #define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
 #define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
-static ssize_t cpuidle_state_show(struct kobject * kobj,
-        struct attribute * attr ,char * buf)
+
+static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
+                                  char * buf)
 {
         int ret = -EIO;
         struct cpuidle_state *state = kobj_to_state(kobj);
@@ -323,8 +345,8 @@ static ssize_t cpuidle_state_show(struct kobject * kobj,
         return ret;
 }
 
-static ssize_t cpuidle_state_store(struct kobject *kobj,
-        struct attribute *attr, const char *buf, size_t size)
+static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
+                                   const char *buf, size_t size)
 {
         int ret = -EIO;
         struct cpuidle_state *state = kobj_to_state(kobj);
@@ -371,6 +393,7 @@ static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
 {
         int i, ret = -ENOMEM;
         struct cpuidle_state_kobj *kobj;
+        struct cpuidle_device_kobj *kdev = device->kobj_dev;
         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
 
         /* state statistics */
@@ -383,7 +406,7 @@ static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
                 init_completion(&kobj->kobj_unregister);
 
                 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
-                                           &device->kobj, "state%d", i);
+                                           &kdev->kobj, "state%d", i);
                 if (ret) {
                         kfree(kobj);
                         goto error_state;
@@ -449,8 +472,8 @@ static void cpuidle_driver_sysfs_release(struct kobject *kobj)
         complete(&driver_kobj->kobj_unregister);
 }
 
-static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute * attr,
-                                   char * buf)
+static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
+                                   char *buf)
 {
         int ret = -EIO;
         struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
@@ -500,6 +523,7 @@ static struct kobj_type ktype_driver_cpuidle = {
 static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
 {
         struct cpuidle_driver_kobj *kdrv;
+        struct cpuidle_device_kobj *kdev = dev->kobj_dev;
         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
         int ret;
 
@@ -511,7 +535,7 @@ static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
         init_completion(&kdrv->kobj_unregister);
 
         ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
-                                   &dev->kobj, "driver");
+                                   &kdev->kobj, "driver");
         if (ret) {
                 kfree(kdrv);
                 return ret;
@@ -580,16 +604,28 @@ void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
  */
 int cpuidle_add_sysfs(struct cpuidle_device *dev)
 {
+        struct cpuidle_device_kobj *kdev;
         struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
         int error;
 
-        init_completion(&dev->kobj_unregister);
+        kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
+        if (!kdev)
+                return -ENOMEM;
+        kdev->dev = dev;
+        dev->kobj_dev = kdev;
 
-        error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
-                                     "cpuidle");
-        if (!error)
-                kobject_uevent(&dev->kobj, KOBJ_ADD);
-        return error;
+        init_completion(&kdev->kobj_unregister);
+
+        error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
+                                   "cpuidle");
+        if (error) {
+                kfree(kdev);
+                return error;
+        }
+
+        kobject_uevent(&kdev->kobj, KOBJ_ADD);
+
+        return 0;
 }
 
 /**
@@ -598,6 +634,9 @@ int cpuidle_add_sysfs(struct cpuidle_device *dev)
  */
 void cpuidle_remove_sysfs(struct cpuidle_device *dev)
 {
-        kobject_put(&dev->kobj);
-        wait_for_completion(&dev->kobj_unregister);
+        struct cpuidle_device_kobj *kdev = dev->kobj_dev;
+
+        kobject_put(&kdev->kobj);
+        wait_for_completion(&kdev->kobj_unregister);
+        kfree(kdev);
 }
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 3c157faee645..0d68eb1a5ec5 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -3094,6 +3094,10 @@ static struct mfd_cell db8500_prcmu_devs[] = {
                 .pdata_size = sizeof(db8500_cpufreq_table),
         },
         {
+                .name = "cpuidle-dbx500",
+                .of_compatible = "stericsson,cpuidle-dbx500",
+        },
+        {
                 .name = "db8500-thermal",
                 .num_resources = ARRAY_SIZE(db8500_thsens_resources),
                 .resources = db8500_thsens_resources,
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 0bc4b74668e9..781addc66f03 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -13,8 +13,6 @@
 
 #include <linux/percpu.h>
 #include <linux/list.h>
-#include <linux/kobject.h>
-#include <linux/completion.h>
 #include <linux/hrtimer.h>
 
 #define CPUIDLE_STATE_MAX       10
@@ -61,6 +59,10 @@ struct cpuidle_state {
 
 #define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
 
+struct cpuidle_device_kobj;
+struct cpuidle_state_kobj;
+struct cpuidle_driver_kobj;
+
 struct cpuidle_device {
         unsigned int            registered:1;
         unsigned int            enabled:1;
@@ -71,9 +73,8 @@ struct cpuidle_device {
         struct cpuidle_state_usage      states_usage[CPUIDLE_STATE_MAX];
         struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
         struct cpuidle_driver_kobj *kobj_driver;
+        struct cpuidle_device_kobj *kobj_dev;
         struct list_head        device_list;
-        struct kobject          kobj;
-        struct completion       kobj_unregister;
 
 #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
         int                     safe_state_index;