10 files changed, 429 insertions, 97 deletions

diff --git a/arch/powerpc/platforms/pseries/Kconfig b/arch/powerpc/platforms/pseries/Kconfig
index c81f6bb9c10f..ae7b6d41fed3 100644
--- a/arch/powerpc/platforms/pseries/Kconfig
+++ b/arch/powerpc/platforms/pseries/Kconfig
@@ -120,3 +120,12 @@ config DTL
           which are accessible through a debugfs file.
 
           Say N if you are unsure.
+
+config PSERIES_IDLE
+        tristate "Cpuidle driver for pSeries platforms"
+        depends on CPU_IDLE
+        depends on PPC_PSERIES
+        default y
+        help
+          Select this option to enable processor idle state management
+          through cpuidle subsystem.
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 3556e402cbf5..236db46b4078 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_PHYP_DUMP)		+= phyp_dump.o
 obj-$(CONFIG_CMM)               += cmm.o
 obj-$(CONFIG_DTL)               += dtl.o
 obj-$(CONFIG_IO_EVENT_IRQ)      += io_event_irq.o
+obj-$(CONFIG_PSERIES_IDLE)      += processor_idle.o
 
 ifeq ($(CONFIG_PPC_PSERIES),y)
 obj-$(CONFIG_SUSPEND)           += suspend.o
diff --git a/arch/powerpc/platforms/pseries/hvCall_inst.c b/arch/powerpc/platforms/pseries/hvCall_inst.c
index f106662f4381..c9311cfdfcac 100644
--- a/arch/powerpc/platforms/pseries/hvCall_inst.c
+++ b/arch/powerpc/platforms/pseries/hvCall_inst.c
@@ -109,7 +109,7 @@ static void probe_hcall_entry(void *ignored, unsigned long opcode, unsigned long
         if (opcode > MAX_HCALL_OPCODE)
                 return;
 
-        h = &get_cpu_var(hcall_stats)[opcode / 4];
+        h = &__get_cpu_var(hcall_stats)[opcode / 4];
         h->tb_start = mftb();
         h->purr_start = mfspr(SPRN_PURR);
 }
@@ -126,8 +126,6 @@ static void probe_hcall_exit(void *ignored, unsigned long opcode, unsigned long
         h->num_calls++;
         h->tb_total += mftb() - h->tb_start;
         h->purr_total += mfspr(SPRN_PURR) - h->purr_start;
-
-        put_cpu_var(hcall_stats);
 }
 
 static int __init hcall_inst_init(void)
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index b719d9709730..c442f2b1980f 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -52,13 +52,42 @@
 #include "plpar_wrappers.h"
 
 
+static void tce_invalidate_pSeries_sw(struct iommu_table *tbl,
+                                      u64 *startp, u64 *endp)
+{
+        u64 __iomem *invalidate = (u64 __iomem *)tbl->it_index;
+        unsigned long start, end, inc;
+
+        start = __pa(startp);
+        end = __pa(endp);
+        inc = L1_CACHE_BYTES; /* invalidate a cacheline of TCEs at a time */
+
+        /* If this is non-zero, change the format.  We shift the
+         * address and or in the magic from the device tree. */
+        if (tbl->it_busno) {
+                start <<= 12;
+                end <<= 12;
+                inc <<= 12;
+                start |= tbl->it_busno;
+                end |= tbl->it_busno;
+        }
+
+        end |= inc - 1; /* round up end to be different than start */
+
+        mb(); /* Make sure TCEs in memory are written */
+        while (start <= end) {
+                out_be64(invalidate, start);
+                start += inc;
+        }
+}
+
 static int tce_build_pSeries(struct iommu_table *tbl, long index,
                               long npages, unsigned long uaddr,
                               enum dma_data_direction direction,
                               struct dma_attrs *attrs)
 {
         u64 proto_tce;
-        u64 *tcep;
+        u64 *tcep, *tces;
         u64 rpn;
 
         proto_tce = TCE_PCI_READ; // Read allowed
@@ -66,7 +95,7 @@ static int tce_build_pSeries(struct iommu_table *tbl, long index,
         if (direction != DMA_TO_DEVICE)
                 proto_tce |= TCE_PCI_WRITE;
 
-        tcep = ((u64 *)tbl->it_base) + index;
+        tces = tcep = ((u64 *)tbl->it_base) + index;
 
         while (npages--) {
                 /* can't move this out since we might cross MEMBLOCK boundary */
@@ -76,18 +105,24 @@ static int tce_build_pSeries(struct iommu_table *tbl, long index,
                 uaddr += TCE_PAGE_SIZE;
                 tcep++;
         }
+
+        if (tbl->it_type == TCE_PCI_SWINV_CREATE)
+                tce_invalidate_pSeries_sw(tbl, tces, tcep - 1);
         return 0;
 }
 
 
 static void tce_free_pSeries(struct iommu_table *tbl, long index, long npages)
 {
-        u64 *tcep;
+        u64 *tcep, *tces;
 
-        tcep = ((u64 *)tbl->it_base) + index;
+        tces = tcep = ((u64 *)tbl->it_base) + index;
 
         while (npages--)
                 *(tcep++) = 0;
+
+        if (tbl->it_type == TCE_PCI_SWINV_FREE)
+                tce_invalidate_pSeries_sw(tbl, tces, tcep - 1);
 }
 
 static unsigned long tce_get_pseries(struct iommu_table *tbl, long index)
@@ -425,7 +460,7 @@ static void iommu_table_setparms(struct pci_controller *phb,
                                  struct iommu_table *tbl)
 {
         struct device_node *node;
-        const unsigned long *basep;
+        const unsigned long *basep, *sw_inval;
         const u32 *sizep;
 
         node = phb->dn;
@@ -462,6 +497,22 @@ static void iommu_table_setparms(struct pci_controller *phb,
         tbl->it_index = 0;
         tbl->it_blocksize = 16;
         tbl->it_type = TCE_PCI;
+
+        sw_inval = of_get_property(node, "linux,tce-sw-invalidate-info", NULL);
+        if (sw_inval) {
+                /*
+                 * This property contains information on how to
+                 * invalidate the TCE entry.  The first property is
+                 * the base MMIO address used to invalidate entries.
+                 * The second property tells us the format of the TCE
+                 * invalidate (whether it needs to be shifted) and
+                 * some magic routing info to add to our invalidate
+                 * command.
+                 */
+                tbl->it_index = (unsigned long) ioremap(sw_inval[0], 8);
+                tbl->it_busno = sw_inval[1]; /* overload this with magic */
+                tbl->it_type = TCE_PCI_SWINV_CREATE | TCE_PCI_SWINV_FREE;
+        }
 }
 
 /*
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 52d429be6c76..948e0e3b3547 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -554,6 +554,7 @@ void __trace_hcall_entry(unsigned long opcode, unsigned long *args)
                 goto out;
 
         (*depth)++;
+        preempt_disable();
         trace_hcall_entry(opcode, args);
         if (opcode == H_CEDE)
                 rcu_idle_enter();
@@ -580,6 +581,7 @@ void __trace_hcall_exit(long opcode, unsigned long retval,
         if (opcode == H_CEDE)
                 rcu_idle_exit();
         trace_hcall_exit(opcode, retval, retbuf);
+        preempt_enable();
         (*depth)--;
 
 out:
diff --git a/arch/powerpc/platforms/pseries/nvram.c b/arch/powerpc/platforms/pseries/nvram.c
index a76b22844d18..330a57b7c17c 100644
--- a/arch/powerpc/platforms/pseries/nvram.c
+++ b/arch/powerpc/platforms/pseries/nvram.c
@@ -625,6 +625,8 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
 {
         static unsigned int oops_count = 0;
         static bool panicking = false;
+        static DEFINE_SPINLOCK(lock);
+        unsigned long flags;
         size_t text_len;
         unsigned int err_type = ERR_TYPE_KERNEL_PANIC_GZ;
         int rc = -1;
@@ -655,6 +657,9 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
         if (clobbering_unread_rtas_event())
                 return;
 
+        if (!spin_trylock_irqsave(&lock, flags))
+                return;
+
         if (big_oops_buf) {
                 text_len = capture_last_msgs(old_msgs, old_len,
                         new_msgs, new_len, big_oops_buf, big_oops_buf_sz);
@@ -670,4 +675,6 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
 
         (void) nvram_write_os_partition(&oops_log_partition, oops_buf,
                 (int) (sizeof(*oops_len) + *oops_len), err_type, ++oops_count);
+
+        spin_unlock_irqrestore(&lock, flags);
 }
diff --git a/arch/powerpc/platforms/pseries/processor_idle.c b/arch/powerpc/platforms/pseries/processor_idle.c
new file mode 100644
index 000000000000..085fd3f45ad2
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/processor_idle.c
@@ -0,0 +1,329 @@
+/*
+ *  processor_idle - idle state cpuidle driver.
+ *  Adapted from drivers/idle/intel_idle.c and
+ *  drivers/acpi/processor_idle.c
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/moduleparam.h>
+#include <linux/cpuidle.h>
+#include <linux/cpu.h>
+
+#include <asm/paca.h>
+#include <asm/reg.h>
+#include <asm/system.h>
+#include <asm/machdep.h>
+#include <asm/firmware.h>
+
+#include "plpar_wrappers.h"
+#include "pseries.h"
+
+struct cpuidle_driver pseries_idle_driver = {
+        .name =         "pseries_idle",
+        .owner =        THIS_MODULE,
+};
+
+#define MAX_IDLE_STATE_COUNT    2
+
+static int max_idle_state = MAX_IDLE_STATE_COUNT - 1;
+static struct cpuidle_device __percpu *pseries_cpuidle_devices;
+static struct cpuidle_state *cpuidle_state_table;
+
+void update_smt_snooze_delay(int snooze)
+{
+        struct cpuidle_driver *drv = cpuidle_get_driver();
+        if (drv)
+                drv->states[0].target_residency = snooze;
+}
+
+static inline void idle_loop_prolog(unsigned long *in_purr, ktime_t *kt_before)
+{
+
+        *kt_before = ktime_get_real();
+        *in_purr = mfspr(SPRN_PURR);
+        /*
+         * Indicate to the HV that we are idle. Now would be
+         * a good time to find other work to dispatch.
+         */
+        get_lppaca()->idle = 1;
+}
+
+static inline  s64 idle_loop_epilog(unsigned long in_purr, ktime_t kt_before)
+{
+        get_lppaca()->wait_state_cycles += mfspr(SPRN_PURR) - in_purr;
+        get_lppaca()->idle = 0;
+
+        return ktime_to_us(ktime_sub(ktime_get_real(), kt_before));
+}
+
+static int snooze_loop(struct cpuidle_device *dev,
+                        struct cpuidle_driver *drv,
+                        int index)
+{
+        unsigned long in_purr;
+        ktime_t kt_before;
+        unsigned long start_snooze;
+        long snooze = drv->states[0].target_residency;
+
+        idle_loop_prolog(&in_purr, &kt_before);
+
+        if (snooze) {
+                start_snooze = get_tb() + snooze * tb_ticks_per_usec;
+                local_irq_enable();
+                set_thread_flag(TIF_POLLING_NRFLAG);
+
+                while ((snooze < 0) || (get_tb() < start_snooze)) {
+                        if (need_resched() || cpu_is_offline(dev->cpu))
+                                goto out;
+                        ppc64_runlatch_off();
+                        HMT_low();
+                        HMT_very_low();
+                }
+
+                HMT_medium();
+                clear_thread_flag(TIF_POLLING_NRFLAG);
+                smp_mb();
+                local_irq_disable();
+        }
+
+out:
+        HMT_medium();
+        dev->last_residency =
+                (int)idle_loop_epilog(in_purr, kt_before);
+        return index;
+}
+
+static int dedicated_cede_loop(struct cpuidle_device *dev,
+                                struct cpuidle_driver *drv,
+                                int index)
+{
+        unsigned long in_purr;
+        ktime_t kt_before;
+
+        idle_loop_prolog(&in_purr, &kt_before);
+        get_lppaca()->donate_dedicated_cpu = 1;
+
+        ppc64_runlatch_off();
+        HMT_medium();
+        cede_processor();
+
+        get_lppaca()->donate_dedicated_cpu = 0;
+        dev->last_residency =
+                (int)idle_loop_epilog(in_purr, kt_before);
+        return index;
+}
+
+static int shared_cede_loop(struct cpuidle_device *dev,
+                        struct cpuidle_driver *drv,
+                        int index)
+{
+        unsigned long in_purr;
+        ktime_t kt_before;
+
+        idle_loop_prolog(&in_purr, &kt_before);
+
+        /*
+         * Yield the processor to the hypervisor.  We return if
+         * an external interrupt occurs (which are driven prior
+         * to returning here) or if a prod occurs from another
+         * processor. When returning here, external interrupts
+         * are enabled.
+         */
+        cede_processor();
+
+        dev->last_residency =
+                (int)idle_loop_epilog(in_purr, kt_before);
+        return index;
+}
+
+/*
+ * States for dedicated partition case.
+ */
+static struct cpuidle_state dedicated_states[MAX_IDLE_STATE_COUNT] = {
+        { /* Snooze */
+                .name = "snooze",
+                .desc = "snooze",
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 0,
+                .target_residency = 0,
+                .enter = &snooze_loop },
+        { /* CEDE */
+                .name = "CEDE",
+                .desc = "CEDE",
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 1,
+                .target_residency = 10,
+                .enter = &dedicated_cede_loop },
+};
+
+/*
+ * States for shared partition case.
+ */
+static struct cpuidle_state shared_states[MAX_IDLE_STATE_COUNT] = {
+        { /* Shared Cede */
+                .name = "Shared Cede",
+                .desc = "Shared Cede",
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 0,
+                .target_residency = 0,
+                .enter = &shared_cede_loop },
+};
+
+int pseries_notify_cpuidle_add_cpu(int cpu)
+{
+        struct cpuidle_device *dev =
+                        per_cpu_ptr(pseries_cpuidle_devices, cpu);
+        if (dev && cpuidle_get_driver()) {
+                cpuidle_disable_device(dev);
+                cpuidle_enable_device(dev);
+        }
+        return 0;
+}
+
+/*
+ * pseries_cpuidle_driver_init()
+ */
+static int pseries_cpuidle_driver_init(void)
+{
+        int idle_state;
+        struct cpuidle_driver *drv = &pseries_idle_driver;
+
+        drv->state_count = 0;
+
+        for (idle_state = 0; idle_state < MAX_IDLE_STATE_COUNT; ++idle_state) {
+
+                if (idle_state > max_idle_state)
+                        break;
+
+                /* is the state not enabled? */
+                if (cpuidle_state_table[idle_state].enter == NULL)
+                        continue;
+
+                drv->states[drv->state_count] = /* structure copy */
+                        cpuidle_state_table[idle_state];
+
+                if (cpuidle_state_table == dedicated_states)
+                        drv->states[drv->state_count].target_residency =
+                                __get_cpu_var(smt_snooze_delay);
+
+                drv->state_count += 1;
+        }
+
+        return 0;
+}
+
+/* pseries_idle_devices_uninit(void)
+ * unregister cpuidle devices and de-allocate memory
+ */
+static void pseries_idle_devices_uninit(void)
+{
+        int i;
+        struct cpuidle_device *dev;
+
+        for_each_possible_cpu(i) {
+                dev = per_cpu_ptr(pseries_cpuidle_devices, i);
+                cpuidle_unregister_device(dev);
+        }
+
+        free_percpu(pseries_cpuidle_devices);
+        return;
+}
+
+/* pseries_idle_devices_init()
+ * allocate, initialize and register cpuidle device
+ */
+static int pseries_idle_devices_init(void)
+{
+        int i;
+        struct cpuidle_driver *drv = &pseries_idle_driver;
+        struct cpuidle_device *dev;
+
+        pseries_cpuidle_devices = alloc_percpu(struct cpuidle_device);
+        if (pseries_cpuidle_devices == NULL)
+                return -ENOMEM;
+
+        for_each_possible_cpu(i) {
+                dev = per_cpu_ptr(pseries_cpuidle_devices, i);
+                dev->state_count = drv->state_count;
+                dev->cpu = i;
+                if (cpuidle_register_device(dev)) {
+                        printk(KERN_DEBUG \
+                                "cpuidle_register_device %d failed!\n", i);
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * pseries_idle_probe()
+ * Choose state table for shared versus dedicated partition
+ */
+static int pseries_idle_probe(void)
+{
+
+        if (!firmware_has_feature(FW_FEATURE_SPLPAR))
+                return -ENODEV;
+
+        if (cpuidle_disable != IDLE_NO_OVERRIDE)
+                return -ENODEV;
+
+        if (max_idle_state == 0) {
+                printk(KERN_DEBUG "pseries processor idle disabled.\n");
+                return -EPERM;
+        }
+
+        if (get_lppaca()->shared_proc)
+                cpuidle_state_table = shared_states;
+        else
+                cpuidle_state_table = dedicated_states;
+
+        return 0;
+}
+
+static int __init pseries_processor_idle_init(void)
+{
+        int retval;
+
+        retval = pseries_idle_probe();
+        if (retval)
+                return retval;
+
+        pseries_cpuidle_driver_init();
+        retval = cpuidle_register_driver(&pseries_idle_driver);
+        if (retval) {
+                printk(KERN_DEBUG "Registration of pseries driver failed.\n");
+                return retval;
+        }
+
+        retval = pseries_idle_devices_init();
+        if (retval) {
+                pseries_idle_devices_uninit();
+                cpuidle_unregister_driver(&pseries_idle_driver);
+                return retval;
+        }
+
+        printk(KERN_DEBUG "pseries_idle_driver registered\n");
+
+        return 0;
+}
+
+static void __exit pseries_processor_idle_exit(void)
+{
+
+        pseries_idle_devices_uninit();
+        cpuidle_unregister_driver(&pseries_idle_driver);
+
+        return;
+}
+
+module_init(pseries_processor_idle_init);
+module_exit(pseries_processor_idle_exit);
+
+MODULE_AUTHOR("Deepthi Dharwar <deepthi@linux.vnet.ibm.com>");
+MODULE_DESCRIPTION("Cpuidle driver for POWER");
+MODULE_LICENSE("GPL");
diff --git a/arch/powerpc/platforms/pseries/pseries.h b/arch/powerpc/platforms/pseries/pseries.h
index 24c7162f11d9..9a3dda07566f 100644
--- a/arch/powerpc/platforms/pseries/pseries.h
+++ b/arch/powerpc/platforms/pseries/pseries.h
@@ -57,4 +57,7 @@ extern struct device_node *dlpar_configure_connector(u32);
 extern int dlpar_attach_node(struct device_node *);
 extern int dlpar_detach_node(struct device_node *);
 
+/* Snooze Delay, pseries_idle */
+DECLARE_PER_CPU(long, smt_snooze_delay);
+
 #endif /* _PSERIES_PSERIES_H */
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index c3408ca8855e..f79f1278dfca 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -39,6 +39,7 @@
 #include <linux/irq.h>
 #include <linux/seq_file.h>
 #include <linux/root_dev.h>
+#include <linux/cpuidle.h>
 
 #include <asm/mmu.h>
 #include <asm/processor.h>
@@ -74,9 +75,6 @@ EXPORT_SYMBOL(CMO_PageSize);
 
 int fwnmi_active;  /* TRUE if an FWNMI handler is present */
 
-static void pseries_shared_idle_sleep(void);
-static void pseries_dedicated_idle_sleep(void);
-
 static struct device_node *pSeries_mpic_node;
 
 static void pSeries_show_cpuinfo(struct seq_file *m)
@@ -192,8 +190,7 @@ static void __init pseries_mpic_init_IRQ(void)
         BUG_ON(openpic_addr == 0);
 
         /* Setup the openpic driver */
-        mpic = mpic_alloc(pSeries_mpic_node, openpic_addr,
-                          MPIC_PRIMARY,
+        mpic = mpic_alloc(pSeries_mpic_node, openpic_addr, 0,
                           16, 250, /* isu size, irq count */
                           " MPIC     ");
         BUG_ON(mpic == NULL);
@@ -352,8 +349,25 @@ static int alloc_dispatch_log_kmem_cache(void)
 }
 early_initcall(alloc_dispatch_log_kmem_cache);
 
+static void pSeries_idle(void)
+{
+        /* This would call on the cpuidle framework, and the back-end pseries
+         * driver to  go to idle states
+         */
+        if (cpuidle_idle_call()) {
+                /* On error, execute default handler
+                 * to go into low thread priority and possibly
+                 * low power mode.
+                 */
+                HMT_low();
+                HMT_very_low();
+        }
+}
+
 static void __init pSeries_setup_arch(void)
 {
+        panic_timeout = 10;
+
         /* Discover PIC type and setup ppc_md accordingly */
         pseries_discover_pic();
 
@@ -374,18 +388,9 @@ static void __init pSeries_setup_arch(void)
 
         pSeries_nvram_init();
 
-        /* Choose an idle loop */
         if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
                 vpa_init(boot_cpuid);
-                if (get_lppaca()->shared_proc) {
-                        printk(KERN_DEBUG "Using shared processor idle loop\n");
-                        ppc_md.power_save = pseries_shared_idle_sleep;
-                } else {
-                        printk(KERN_DEBUG "Using dedicated idle loop\n");
-                        ppc_md.power_save = pseries_dedicated_idle_sleep;
-                }
-        } else {
-                printk(KERN_DEBUG "Using default idle loop\n");
+                ppc_md.power_save = pSeries_idle;
         }
 
         if (firmware_has_feature(FW_FEATURE_LPAR))
@@ -586,80 +591,6 @@ static int __init pSeries_probe(void)
         return 1;
 }
 
-
-DECLARE_PER_CPU(long, smt_snooze_delay);
-
-static void pseries_dedicated_idle_sleep(void)
-{ 
-        unsigned int cpu = smp_processor_id();
-        unsigned long start_snooze;
-        unsigned long in_purr, out_purr;
-        long snooze = __get_cpu_var(smt_snooze_delay);
-
-        /*
-         * Indicate to the HV that we are idle. Now would be
-         * a good time to find other work to dispatch.
-         */
-        get_lppaca()->idle = 1;
-        get_lppaca()->donate_dedicated_cpu = 1;
-        in_purr = mfspr(SPRN_PURR);
-
-        /*
-         * We come in with interrupts disabled, and need_resched()
-         * has been checked recently.  If we should poll for a little
-         * while, do so.
-         */
-        if (snooze) {
-                start_snooze = get_tb() + snooze * tb_ticks_per_usec;
-                local_irq_enable();
-                set_thread_flag(TIF_POLLING_NRFLAG);
-
-                while ((snooze < 0) || (get_tb() < start_snooze)) {
-                        if (need_resched() || cpu_is_offline(cpu))
-                                goto out;
-                        ppc64_runlatch_off();
-                        HMT_low();
-                        HMT_very_low();
-                }
-
-                HMT_medium();
-                clear_thread_flag(TIF_POLLING_NRFLAG);
-                smp_mb();
-                local_irq_disable();
-                if (need_resched() || cpu_is_offline(cpu))
-                        goto out;
-        }
-
-        cede_processor();
-
-out:
-        HMT_medium();
-        out_purr = mfspr(SPRN_PURR);
-        get_lppaca()->wait_state_cycles += out_purr - in_purr;
-        get_lppaca()->donate_dedicated_cpu = 0;
-        get_lppaca()->idle = 0;
-}
-
-static void pseries_shared_idle_sleep(void)
-{
-        /*
-         * Indicate to the HV that we are idle. Now would be
-         * a good time to find other work to dispatch.
-         */
-        get_lppaca()->idle = 1;
-
-        /*
-         * Yield the processor to the hypervisor.  We return if
-         * an external interrupt occurs (which are driven prior
-         * to returning here) or if a prod occurs from another
-         * processor. When returning here, external interrupts
-         * are enabled.
-         */
-        cede_processor();
-
-        get_lppaca()->idle = 0;
-}
-
 static int pSeries_pci_probe_mode(struct pci_bus *bus)
 {
         if (firmware_has_feature(FW_FEATURE_LPAR))
diff --git a/arch/powerpc/platforms/pseries/smp.c b/arch/powerpc/platforms/pseries/smp.c
index 26e93fd4c62b..bbc3c42f6730 100644
--- a/arch/powerpc/platforms/pseries/smp.c
+++ b/arch/powerpc/platforms/pseries/smp.c
@@ -148,6 +148,7 @@ static void __devinit smp_xics_setup_cpu(int cpu)
         set_cpu_current_state(cpu, CPU_STATE_ONLINE);
         set_default_offline_state(cpu);
 #endif
+        pseries_notify_cpuidle_add_cpu(cpu);
 }
 
 static int __devinit smp_pSeries_kick_cpu(int nr)