cpuidle/powernv: Enable Fast-Sleep on PowerNV
Subsystems (4)
cover cpuidle/powernv: Enable Fast-Sleep on PowerNV
This series is based on tip/timers/core ontop of commit 849401b66d305:tick: Fixup more fallout from hrtimer broadcast mode.
Fast sleep is one of the deep idle states on Power8 in which local timers of CPUs stop. On PowerPC we do not have an external clock device which can handle wakeup of such CPUs. Now that we have the support in the tick broadcast framework for archs that do not sport such a device soon to go upstream, add fast sleep as one of the idle states on PowerNV along with related arch specific support.
The earlier versions of this patchset included support in the tick broadcast framework for such idle states. Now that the support in the broadcast framework has been pulled into tip separately, this series is posted independently and as a new patchset altogether. This series depends in particular on the following commits in tip/timers/core:
1.da7e6f45c3:time: Change the return type of clockevents_notify() to integer 2.ba8f20c2eb:cpuidle: Handle clockevents_notify(BROADCAST_ENTER) failure 3.5d1638acb9f62fa:tick: Introduce hrtimer based broadcast 4.f1689bb7abec8e2e6:time: Fixup fallout from recent clockevent/tick changes 5.849401b66d305f3feb75:Fixup more fallout from hrtimer broadcast mode
---
Preeti U Murthy (3):
cpuidle/ppc: Split timer_interrupt() into timer handling and interrupt handling routines cpuidle/powernv: Add "Fast-Sleep" CPU idle state
cpuidle/powernv: Parse device tree to setup idle states
Srivatsa S. Bhat (2):
powerpc: Free up the slot of PPC_MSG_CALL_FUNC_SINGLE IPI message
powerpc: Implement tick broadcast IPI as a fixed IPI message
Vaidyanathan Srinivasan (2):
powernv/cpuidle: Add context management for Fast Sleep
powermgt: Add OPAL call to resync timebase on wakeup
arch/powerpc/Kconfig | 2 arch/powerpc/include/asm/opal.h | 2 arch/powerpc/include/asm/processor.h | 1 arch/powerpc/include/asm/smp.h | 2 arch/powerpc/include/asm/time.h | 1 arch/powerpc/kernel/exceptions-64s.S | 10 ++ arch/powerpc/kernel/idle_power7.S | 90 +++++++++++++++++---- arch/powerpc/kernel/smp.c | 25 ++++-- arch/powerpc/kernel/time.c | 90 +++++++++++++-------- arch/powerpc/platforms/cell/interrupt.c | 2 arch/powerpc/platforms/powernv/opal-wrappers.S | 1 arch/powerpc/platforms/ps3/smp.c | 2 drivers/cpuidle/cpuidle-powernv.c | 102 ++++++++++++++++++++++-- 13 files changed, 253 insertions(+), 77 deletions(-)
Signature · 1 line
Signature
PATCH 1/7 powerpc: Free up the slot of PPC_MSG_CALL_FUNC_SINGLE IPI message
From: Srivatsa S. Bhat <[email protected]>
The IPI handlers for both PPC_MSG_CALL_FUNC and PPC_MSG_CALL_FUNC_SINGLE map to a common implementation - generic_smp_call_function_single_interrupt(). So, we can consolidate them and save one of the IPI message slots, (which are precious on powerpc, since only 4 of those slots are available).
So, implement the functionality of PPC_MSG_CALL_FUNC_SINGLE using PPC_MSG_CALL_FUNC itself and release its IPI message slot, so that it can be used for something else in the future, if desired.
---
arch/powerpc/include/asm/smp.h | 2 +- arch/powerpc/kernel/smp.c | 12 +++++------- arch/powerpc/platforms/cell/interrupt.c | 2 +- arch/powerpc/platforms/ps3/smp.c | 2 +- 4 files changed, 8 insertions(+), 10 deletions(-)
arch/powerpc/include/asm/smp.h +1 -1
@@ -120,7 +120,7 @@ extern int cpu_to_core_id(int cpu);* in /proc/interrupts will be wrong!!! --Troy */ #define PPC_MSG_CALL_FUNCTION 0#define PPC_MSG_RESCHEDULE 1 -#define PPC_MSG_CALL_FUNC_SINGLE 2 +#define PPC_MSG_UNUSED 2#define PPC_MSG_DEBUGGER_BREAK 3/* for irq controllers that have dedicated ipis per message (4) */
arch/powerpc/kernel/smp.c +5 -7
@@ -145,9 +145,9 @@ static irqreturn_t reschedule_action(int irq, void *data)return IRQ_HANDLED ; } -static irqreturn_t call_function_single_action (int irq,void *data) +static irqreturn_t unused_action (int irq,void *data) { -generic_smp_call_function_single_interrupt (); +/* This slot is unused and hence available for use, if needed */ return IRQ_HANDLED ; }
@@ -168,14 +168,14 @@ static irqreturn_t debug_ipi_action(int irq, void *data)static irq_handler_t smp_ipi_action[] = { [PPC_MSG_CALL_FUNCTION ] = call_function_action, [PPC_MSG_RESCHEDULE ] = reschedule_action, - [PPC_MSG_CALL_FUNC_SINGLE ] = call_function_single_action, + [PPC_MSG_UNUSED ] = unused_action, [PPC_MSG_DEBUGGER_BREAK ] = debug_ipi_action, };const char *smp_ipi_name[] = { [PPC_MSG_CALL_FUNCTION ] ="ipi call function" , [PPC_MSG_RESCHEDULE ] ="ipi reschedule" , - [PPC_MSG_CALL_FUNC_SINGLE ] ="ipi call function single" , + [PPC_MSG_UNUSED ] ="ipi unused" , [PPC_MSG_DEBUGGER_BREAK ] ="ipi debugger" , };
@@ -251,8 +251,6 @@ irqreturn_t smp_ipi_demux(void)generic_smp_call_function_interrupt ();if (all &IPI_MESSAGE (PPC_MSG_RESCHEDULE ))scheduler_ipi (); -if (all &IPI_MESSAGE (PPC_MSG_CALL_FUNC_SINGLE )) -generic_smp_call_function_single_interrupt ();if (all &IPI_MESSAGE (PPC_MSG_DEBUGGER_BREAK ))debug_ipi_action (0 ,NULL ); }while (info->messages);
@@ -280,7 +278,7 @@ EXPORT_SYMBOL_GPL(smp_send_reschedule);void arch_send_call_function_single_ipi (int cpu) { -do_message_pass (cpu,PPC_MSG_CALL_FUNC_SINGLE ); +do_message_pass (cpu,PPC_MSG_CALL_FUNCTION ); }void arch_send_call_function_ipi_mask (const struct cpumask *mask)
arch/powerpc/platforms/cell/interrupt.c +1 -1
@@ -215,7 +215,7 @@ void iic_request_IPIs(void) {iic_request_ipi (PPC_MSG_CALL_FUNCTION );iic_request_ipi (PPC_MSG_RESCHEDULE ); -iic_request_ipi (PPC_MSG_CALL_FUNC_SINGLE ); +iic_request_ipi (PPC_MSG_UNUSED );iic_request_ipi (PPC_MSG_DEBUGGER_BREAK ); }
arch/powerpc/platforms/ps3/smp.c +1 -1
@@ -76,7 +76,7 @@ static int __init ps3_smp_probe(void)BUILD_BUG_ON (PPC_MSG_CALL_FUNCTION !=0 );BUILD_BUG_ON (PPC_MSG_RESCHEDULE !=1 ); -BUILD_BUG_ON (PPC_MSG_CALL_FUNC_SINGLE !=2 ); +BUILD_BUG_ON (PPC_MSG_UNUSED !=2 );BUILD_BUG_ON (PPC_MSG_DEBUGGER_BREAK !=3 );for (i =0 ; i <MSG_COUNT ; i++) {
PATCH 2/7 powerpc: Implement tick broadcast IPI as a fixed IPI message
In reply to Preeti U MurthyFrom: Srivatsa S. Bhat <[email protected]>
For scalability and performance reasons, we want the tick broadcast IPIs to be handled as efficiently as possible. Fixed IPI messages
are one of the most efficient mechanisms available - they are faster than the smp_call_function mechanism because the IPI handlers are fixed and hence they don't involve costly operations such as adding IPI handlers to the target CPU's function queue, acquiring locks for synchronization etc.
Luckily we have an unused IPI message slot, so use that to implement tick broadcast IPIs efficiently.
[Functions renamed to tick_broadcast* and Changelog modified by
Preeti U. Murthy<[email protected]>]
---
arch/powerpc/include/asm/smp.h | 2 +- arch/powerpc/include/asm/time.h | 1 + arch/powerpc/kernel/smp.c | 21 +++++++++++++++++---- arch/powerpc/kernel/time.c | 5 +++++ arch/powerpc/platforms/cell/interrupt.c | 2 +- arch/powerpc/platforms/ps3/smp.c | 2 +- 6 files changed, 26 insertions(+), 7 deletions(-)
arch/powerpc/include/asm/smp.h +1 -1
@@ -120,7 +120,7 @@ extern int cpu_to_core_id(int cpu);* in /proc/interrupts will be wrong!!! --Troy */ #define PPC_MSG_CALL_FUNCTION 0#define PPC_MSG_RESCHEDULE 1 -#define PPC_MSG_UNUSED 2 +#define PPC_MSG_TICK_BROADCAST 2#define PPC_MSG_DEBUGGER_BREAK 3/* for irq controllers that have dedicated ipis per message (4) */
arch/powerpc/include/asm/time.h +1 -0
@@ -28,6 +28,7 @@ extern struct clock_event_device decrementer_clockevent;struct rtc_time ;extern void to_tm (int tim,struct rtc_time * tm);extern void GregorianDay (struct rtc_time *tm); +extern void tick_broadcast_ipi_handler (void );extern void generic_calibrate_decr (void );
arch/powerpc/kernel/smp.c +17 -4
@@ -35,6 +35,7 @@#include <asm/ptrace.h> #include <linux/atomic.h> #include <asm/irq.h> +#include <asm/hw_irq.h> #include <asm/page.h> #include <asm/pgtable.h> #include <asm/prom.h>
@@ -145,9 +146,9 @@ static irqreturn_t reschedule_action(int irq, void *data)return IRQ_HANDLED ; } -static irqreturn_t unused_action (int irq,void *data) +static irqreturn_t tick_broadcast_ipi_action (int irq,void *data) { -/* This slot is unused and hence available for use, if needed */ +tick_broadcast_ipi_handler ();return IRQ_HANDLED ; }
@@ -168,14 +169,14 @@ static irqreturn_t debug_ipi_action(int irq, void *data)static irq_handler_t smp_ipi_action[] = { [PPC_MSG_CALL_FUNCTION ] = call_function_action, [PPC_MSG_RESCHEDULE ] = reschedule_action, - [PPC_MSG_UNUSED ] = unused_action, + [PPC_MSG_TICK_BROADCAST ] = tick_broadcast_ipi_action, [PPC_MSG_DEBUGGER_BREAK ] = debug_ipi_action, };const char *smp_ipi_name[] = { [PPC_MSG_CALL_FUNCTION ] ="ipi call function" , [PPC_MSG_RESCHEDULE ] ="ipi reschedule" , - [PPC_MSG_UNUSED ] ="ipi unused" , + [PPC_MSG_TICK_BROADCAST ] ="ipi tick-broadcast" , [PPC_MSG_DEBUGGER_BREAK ] ="ipi debugger" , };
@@ -251,6 +252,8 @@ irqreturn_t smp_ipi_demux(void)generic_smp_call_function_interrupt ();if (all &IPI_MESSAGE (PPC_MSG_RESCHEDULE ))scheduler_ipi (); +if (all &IPI_MESSAGE (PPC_MSG_TICK_BROADCAST )) +tick_broadcast_ipi_handler ();if (all &IPI_MESSAGE (PPC_MSG_DEBUGGER_BREAK ))debug_ipi_action (0 ,NULL ); }while (info->messages);
@@ -289,6 +292,16 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)do_message_pass (cpu,PPC_MSG_CALL_FUNCTION ); } +#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST +void tick_broadcast (const struct cpumask *mask) +{ +unsigned int cpu; + +for_each_cpu (cpu, mask) +do_message_pass (cpu,PPC_MSG_TICK_BROADCAST ); +} +#endif +#if defined(CONFIG_DEBUGGER ) || defined(CONFIG_KEXEC )void smp_send_debugger_break (void ) {
arch/powerpc/kernel/time.c +5 -0
@@ -825,6 +825,11 @@ static void decrementer_set_mode(enum clock_event_mode mode,decrementer_set_next_event (DECREMENTER_MAX , dev); } +/* Interrupt handler for the timer broadcast IPI */ +void tick_broadcast_ipi_handler (void ) +{ +} +static void register_decrementer_clockevent (int cpu) {struct clock_event_device *dec = &per_cpu (decrementers, cpu);
arch/powerpc/platforms/cell/interrupt.c +1 -1
@@ -215,7 +215,7 @@ void iic_request_IPIs(void) {iic_request_ipi (PPC_MSG_CALL_FUNCTION );iic_request_ipi (PPC_MSG_RESCHEDULE ); -iic_request_ipi (PPC_MSG_UNUSED ); +iic_request_ipi (PPC_MSG_TICK_BROADCAST );iic_request_ipi (PPC_MSG_DEBUGGER_BREAK ); }
arch/powerpc/platforms/ps3/smp.c +1 -1
@@ -76,7 +76,7 @@ static int __init ps3_smp_probe(void)BUILD_BUG_ON (PPC_MSG_CALL_FUNCTION !=0 );BUILD_BUG_ON (PPC_MSG_RESCHEDULE !=1 ); -BUILD_BUG_ON (PPC_MSG_UNUSED !=2 ); +BUILD_BUG_ON (PPC_MSG_TICK_BROADCAST !=2 );BUILD_BUG_ON (PPC_MSG_DEBUGGER_BREAK !=3 );for (i =0 ; i <MSG_COUNT ; i++) {
PATCH 3/7 cpuidle/ppc: Split timer_interrupt() into timer handling and interrupt handling routines
In reply to Preeti U MurthySplit timer_interrupt(), which is the local timer interrupt handler on ppc into routines called during regular interrupt handling and __timer_interrupt(), which takes care of running local timers and collecting time related stats.
This will enable callers interested only in running expired local timers to directly call into __timer_interupt(). One of the use cases of this is the tick broadcast IPI handling in which the sleeping CPUs need to handle the local timers that have expired.
---
arch/powerpc/kernel/time.c | 81 +++++++++++++++++++++++++------------------- 1 file changed, 46 insertions(+), 35 deletions(-)
arch/powerpc/kernel/time.c +46 -35
@@ -478,6 +478,47 @@ void arch_irq_work_raise(void)#endif /* CONFIG_IRQ_WORK */ +void __timer_interrupt (void ) +{ +struct pt_regs *regs =get_irq_regs (); +u64 *next_tb = &__get_cpu_var (decrementers_next_tb); +struct clock_event_device *evt = &__get_cpu_var (decrementers); +u64 now; + +trace_timer_interrupt_entry (regs); + +if (test_irq_work_pending ()) { +clear_irq_work_pending (); +irq_work_run (); + } + + now =get_tb_or_rtc (); +if (now >= *next_tb) { + *next_tb = ~(u64 )0 ; +if (evt->event_handler) + evt->event_handler (evt); +__get_cpu_var (irq_stat).timer_irqs_event++; + }else { + now = *next_tb - now; +if (now <=DECREMENTER_MAX ) +set_dec ((int )now); +/* We may have raced with new irq work */ +if (test_irq_work_pending ()) +set_dec (1 ); +__get_cpu_var (irq_stat).timer_irqs_others++; + } + +#ifdef CONFIG_PPC64 +/* collect purr register values often, for accurate calculations */ +if (firmware_has_feature (FW_FEATURE_SPLPAR )) { +struct cpu_usage *cu = &__get_cpu_var (cpu_usage_array); + cu->current_tb =mfspr (SPRN_PURR ); + } +#endif + +trace_timer_interrupt_exit (regs); +} +/* * timer_interrupt - gets called when the decrementer overflows, * with interrupts disabled.
@@ -486,8 +527,6 @@ void timer_interrupt(struct pt_regs * regs) {struct pt_regs *old_regs;u64 *next_tb = &__get_cpu_var (decrementers_next_tb); -struct clock_event_device *evt = &__get_cpu_var (decrementers); -u64 now;/* Ensure a positive value is written to the decrementer, or else * some CPUs will continue to take decrementer exceptions.
@@ -519,39 +558,7 @@ void timer_interrupt(struct pt_regs * regs) old_regs =set_irq_regs (regs);irq_enter (); -trace_timer_interrupt_entry (regs); - -if (test_irq_work_pending ()) { -clear_irq_work_pending (); -irq_work_run (); - } - - now =get_tb_or_rtc (); -if (now >= *next_tb) { - *next_tb = ~(u64 )0 ; -if (evt->event_handler) - evt->event_handler (evt); -__get_cpu_var (irq_stat).timer_irqs_event++; - }else { - now = *next_tb - now; -if (now <=DECREMENTER_MAX ) -set_dec ((int )now); -/* We may have raced with new irq work */ -if (test_irq_work_pending ()) -set_dec (1 ); -__get_cpu_var (irq_stat).timer_irqs_others++; - } - -#ifdef CONFIG_PPC64 -/* collect purr register values often, for accurate calculations */ -if (firmware_has_feature (FW_FEATURE_SPLPAR )) { -struct cpu_usage *cu = &__get_cpu_var (cpu_usage_array); - cu->current_tb =mfspr (SPRN_PURR ); - } -#endif - -trace_timer_interrupt_exit (regs); - +__timer_interrupt ();irq_exit ();set_irq_regs (old_regs); }
@@ -828,6 +835,10 @@ static void decrementer_set_mode(enum clock_event_mode mode,/* Interrupt handler for the timer broadcast IPI */ void tick_broadcast_ipi_handler (void ) { +u64 *next_tb = &__get_cpu_var (decrementers_next_tb); + + *next_tb =get_tb_or_rtc (); +__timer_interrupt (); }static void register_decrementer_clockevent (int cpu)
PATCH 4/7 powernv/cpuidle: Add context management for Fast Sleep
In reply to Preeti U MurthyFrom: Vaidyanathan Srinivasan <[email protected]>
Before adding Fast-Sleep into the cpuidle framework, some low level support needs to be added to enable it. This includes saving and restoring of certain registers at entry and exit time of this state respectively just like we do in the NAP idle state.
---
arch/powerpc/include/asm/processor.h | 1 + arch/powerpc/kernel/exceptions-64s.S | 10 ++++- arch/powerpc/kernel/idle_power7.S | 63 ++++++++++++++++++++++++---------- 3 files changed, 53 insertions(+), 21 deletions(-)
arch/powerpc/include/asm/processor.h +1 -0
@@ -450,6 +450,7 @@ enum idle_boot_override {IDLE_NO_OVERRIDE = 0, IDLE_POWERSAVE_OFF};extern int powersave_nap;/* set if nap mode can be used in idle loop */ extern void power7_nap (void ); +extern void power7_sleep (void );extern void flush_instruction_cache (void );extern void hard_reset_now (void );extern void poweroff_now (void );
arch/powerpc/kernel/exceptions-64s.S +8 -2
@@ -121,9 +121,10 @@ BEGIN_FTR_SECTION cmpwi cr1,r13,2 /* Total loss of HV state is fatal, we could try to use the * PIR to locate a PACA, then use an emergency stack etc... - * but for now, let's just stay stuck here + * OPAL v3 based powernv platforms have new idle states + * which fall in this catagory. */ - bgt cr1,. + bgt cr1,8f GET_PACA(r13) #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
@@ -141,6 +142,11 @@ BEGIN_FTR_SECTION beq cr1,2f b .power7_wakeup_noloss 2: b .power7_wakeup_loss + + /* Fast Sleep wakeup on PowerNV */ +8: GET_PACA(r13) + b .power7_wakeup_loss + 9: END_FTR_SECTION_IFSET(CPU_FTR_HVMODE | CPU_FTR_ARCH_206) #endif /* CONFIG_PPC_P7_NAP */
arch/powerpc/kernel/idle_power7.S +44 -19
84 lines not on this page · raw message
PATCH 5/7 powermgt: Add OPAL call to resync timebase on wakeup
In reply to Preeti U MurthyFrom: Vaidyanathan Srinivasan <[email protected]>
During "Fast-sleep" and deeper power savings state, decrementer and timebase could be stopped making it out of sync with rest of the cores in the system.
Add a firmware call to request platform to resync timebase using low level platform methods.
---
arch/powerpc/include/asm/opal.h | 2 ++ arch/powerpc/kernel/exceptions-64s.S | 2 +- arch/powerpc/kernel/idle_power7.S | 27 ++++++++++++++++++++++++ arch/powerpc/platforms/powernv/opal-wrappers.S | 1 + 4 files changed, 31 insertions(+), 1 deletion(-)
arch/powerpc/include/asm/opal.h +2 -0
@@ -154,6 +154,7 @@ extern int opal_enter_rtas(struct rtas_args *args,#define OPAL_FLASH_VALIDATE 76#define OPAL_FLASH_MANAGE 77#define OPAL_FLASH_UPDATE 78 +#define OPAL_RESYNC_TIMEBASE 79#define OPAL_GET_MSG 85#define OPAL_CHECK_ASYNC_COMPLETION 86#define OPAL_SYNC_HOST_REBOOT 87
@@ -865,6 +866,7 @@ extern void opal_flash_init(void);extern int opal_machine_check (struct pt_regs *regs);extern void opal_shutdown (void ); +extern int opal_resync_timebase (void );extern void opal_lpc_init (void );
arch/powerpc/kernel/exceptions-64s.S +1 -1
@@ -145,7 +145,7 @@ BEGIN_FTR_SECTION /* Fast Sleep wakeup on PowerNV */ 8: GET_PACA(r13) - b .power7_wakeup_loss + b .power7_wakeup_tb_loss 9: END_FTR_SECTION_IFSET(CPU_FTR_HVMODE | CPU_FTR_ARCH_206)
arch/powerpc/kernel/idle_power7.S +27 -0
@@ -17,6 +17,7 @@ #include <asm/ppc-opcode.h> #include <asm/hw_irq.h> #include <asm/kvm_book3s_asm.h> +#include <asm/opal.h> #undef DEBUG
@@ -125,6 +126,32 @@ _GLOBAL(power7_sleep) b power7_powersave_common /* No return */ +_GLOBAL(power7_wakeup_tb_loss) + ld r2,PACATOC(r13); + ld r1,PACAR1(r13) + + /* Time base re-sync */ + li r0,OPAL_RESYNC_TIMEBASE + LOAD_REG_ADDR(r11,opal); + ld r12,8(r11); + ld r2,0(r11); + mtctr r12 + bctrl + + /* TODO: Check r3 for failure */ + + REST_NVGPRS(r1) + REST_GPR(2, r1) + ld r3,_CCR(r1) + ld r4,_MSR(r1) + ld r5,_NIP(r1) + addi r1,r1,INT_FRAME_SIZE + mtcr r3 + mfspr r3,SPRN_SRR1 /* Return SRR1 */ + mtspr SPRN_SRR1,r4 + mtspr SPRN_SRR0,r5 + rfid + _GLOBAL(power7_wakeup_loss) ld r1,PACAR1(r13) REST_NVGPRS(r1)
arch/powerpc/platforms/powernv/opal-wrappers.S +1 -0
@@ -126,6 +126,7 @@ OPAL_CALL(opal_return_cpu, OPAL_RETURN_CPU); OPAL_CALL(opal_validate_flash, OPAL_FLASH_VALIDATE); OPAL_CALL(opal_manage_flash, OPAL_FLASH_MANAGE); OPAL_CALL(opal_update_flash, OPAL_FLASH_UPDATE); +OPAL_CALL(opal_resync_timebase, OPAL_RESYNC_TIMEBASE); OPAL_CALL(opal_get_msg, OPAL_GET_MSG); OPAL_CALL(opal_check_completion, OPAL_CHECK_ASYNC_COMPLETION); OPAL_CALL(opal_sync_host_reboot, OPAL_SYNC_HOST_REBOOT);
PATCH 6/7 cpuidle/powernv: Add "Fast-Sleep" CPU idle state
In reply to Preeti U MurthyFast sleep is one of the deep idle states on Power8 in which local timers of CPUs stop. On PowerPC we do not have an external clock device which can handle wakeup of such CPUs. Now that we have the support in the tick broadcast framework for archs that do not sport such a device and the low level support for fast sleep, enable it in the cpuidle framework on PowerNV.
---
arch/powerpc/Kconfig | 2 ++ arch/powerpc/kernel/time.c | 4 +++- drivers/cpuidle/cpuidle-powernv.c | 34 ++++++++++++++++++++++++++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-)
arch/powerpc/Kconfig +2 -0
@@ -130,6 +130,8 @@ config PPC select GENERIC_CMOS_UPDATE select GENERIC_TIME_VSYSCALL_OLD select GENERIC_CLOCKEVENTS + select GENERIC_CLOCKEVENTS_BROADCAST if SMP + select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST select GENERIC_STRNCPY_FROM_USER select GENERIC_STRNLEN_USER select HAVE_MOD_ARCH_SPECIFIC
arch/powerpc/kernel/time.c +3 -1
@@ -42,6 +42,7 @@#include <linux/timex.h> #include <linux/kernel_stat.h> #include <linux/time.h> +#include <linux/clockchips.h> #include <linux/init.h> #include <linux/profile.h> #include <linux/cpu.h>
@@ -106,7 +107,7 @@ struct clock_event_device decrementer_clockevent = { .irq = 0, .set_next_event = decrementer_set_next_event, .set_mode = decrementer_set_mode, - .features = CLOCK_EVT_FEAT_ONESHOT, + .features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_C3STOP, };EXPORT_SYMBOL (decrementer_clockevent);
@@ -944,6 +945,7 @@ void __init time_init(void)clocksource_init ();init_decrementer_clockevent (); +tick_setup_hrtimer_broadcast (); }
drivers/cpuidle/cpuidle-powernv.c +34 -0
@@ -11,6 +11,7 @@#include <linux/cpuidle.h> #include <linux/cpu.h> #include <linux/notifier.h> +#include <linux/clockchips.h> #include <asm/machdep.h> #include <asm/firmware.h>
@@ -49,6 +50,32 @@ static int nap_loop(struct cpuidle_device *dev,return index; } +static int fastsleep_loop (struct cpuidle_device *dev, +struct cpuidle_driver *drv, +int index) +{ +unsigned long old_lpcr =mfspr (SPRN_LPCR ); +unsigned long new_lpcr; + +if (unlikely (system_state <SYSTEM_RUNNING )) +return index; + + new_lpcr = old_lpcr; + new_lpcr &= ~(LPCR_MER |LPCR_PECE );/* lpcr[mer] must be 0 */ + +/* exit powersave upon external interrupt, but not decrementer +* interrupt. +*/ + new_lpcr |=LPCR_PECE0 ; + +mtspr (SPRN_LPCR , new_lpcr); +power7_sleep (); + +mtspr (SPRN_LPCR , old_lpcr); + +return index; +} +/* * States for dedicated partition case. */
@@ -67,6 +94,13 @@ static struct cpuidle_state powernv_states[] = { .exit_latency = 10, .target_residency = 100, .enter = &nap_loop }, + { /* Fastsleep */ + .name = "fastsleep", + .desc = "fastsleep", + .flags = CPUIDLE_FLAG_TIME_VALID, + .exit_latency = 10, + .target_residency = 100, + .enter = &fastsleep_loop }, }; static int powernv_cpuidle_add_cpu_notifier(struct notifier_block *n,
PATCH 7/7 cpuidle/powernv: Parse device tree to setup idle states
In reply to Preeti U MurthyAdd deep idle states such as nap and fast sleep to the cpuidle state table only if they are discovered from the device tree during cpuidle initialization.
---
drivers/cpuidle/cpuidle-powernv.c | 82 +++++++++++++++++++++++++++++-------- 1 file changed, 65 insertions(+), 17 deletions(-)
drivers/cpuidle/cpuidle-powernv.c +65 -17
@@ -12,10 +12,17 @@#include <linux/cpu.h> #include <linux/notifier.h> #include <linux/clockchips.h> +#include <linux/of.h> #include <asm/machdep.h> #include <asm/firmware.h> +/* Flags and constants used in PowerNV platform */ + +#define MAX_POWERNV_IDLE_STATES 8 +#define IDLE_USE_INST_NAP 0x00010000/* Use nap instruction */ +#define IDLE_USE_INST_SLEEP 0x00020000/* Use sleep instruction */ +struct cpuidle_driver powernv_idle_driver = { .name ="powernv_idle" , .owner =THIS_MODULE ,
@@ -79,7 +86,7 @@ static int fastsleep_loop(struct cpuidle_device *dev,/* * States for dedicated partition case. */ -static struct cpuidle_state powernv_states[] = { +static struct cpuidle_state powernv_states[MAX_POWERNV_IDLE_STATES ] = { {/* Snooze */ .name ="snooze" , .desc ="snooze" ,
@@ -87,20 +94,6 @@ static struct cpuidle_state powernv_states[] = { .exit_latency = 0, .target_residency = 0, .enter = &snooze_loop }, - { /* NAP */ - .name = "NAP", - .desc = "NAP", - .flags = CPUIDLE_FLAG_TIME_VALID, - .exit_latency = 10, - .target_residency = 100, - .enter = &nap_loop }, - { /* Fastsleep */ - .name = "fastsleep", - .desc = "fastsleep", - .flags = CPUIDLE_FLAG_TIME_VALID, - .exit_latency = 10, - .target_residency = 100, - .enter = &fastsleep_loop }, }; static int powernv_cpuidle_add_cpu_notifier(struct notifier_block *n,
@@ -161,19 +154,74 @@ static int powernv_cpuidle_driver_init(void)return 0 ; } +static int powernv_add_idle_states (void ) +{ +struct device_node *power_mgt; +struct property *prop; +int nr_idle_states =1 ;/* Snooze */ +int dt_idle_states; +u32 *flags; +int i; + +/* Currently we have snooze statically defined */ + + power_mgt =of_find_node_by_path ("/ibm,opal/power-mgt" ); +if (!power_mgt) { +pr_warn ("opal: PowerMgmt Node not found\n" ); +return nr_idle_states; + } + + prop =of_find_property (power_mgt,"ibm,cpu-idle-state-flags" ,NULL ); +if (!prop) { +pr_warn ("DT-PowerMgmt: missing ibm,cpu-idle-state-flags\n" ); +return nr_idle_states; + } + + dt_idle_states = prop->length /sizeof (u32); + flags = (u32 *) prop->value; + +for (i =0 ; i < dt_idle_states; i++) { + +if (flags[i] &IDLE_USE_INST_NAP ) { +/* Add NAP state */ +strcpy (powernv_states[nr_idle_states].name,"Nap" ); +strcpy (powernv_states[nr_idle_states].desc,"Nap" ); + powernv_states[nr_idle_states].flags =CPUIDLE_FLAG_TIME_VALID ; + powernv_states[nr_idle_states].exit_latency =10 ; + powernv_states[nr_idle_states].target_residency =100 ; + powernv_states[nr_idle_states].enter = &nap_loop; + nr_idle_states++; + } + +if (flags[i] &IDLE_USE_INST_SLEEP ) { +/* Add FASTSLEEP state */ +strcpy (powernv_states[nr_idle_states].name,"FastSleep" ); +strcpy (powernv_states[nr_idle_states].desc,"FastSleep" ); + powernv_states[nr_idle_states].flags = +CPUIDLE_FLAG_TIME_VALID |CPUIDLE_FLAG_TIMER_STOP ; + powernv_states[nr_idle_states].exit_latency =300 ; + powernv_states[nr_idle_states].target_residency =1000000 ; + powernv_states[nr_idle_states].enter = &fastsleep_loop; + nr_idle_states++; + } + } + +return nr_idle_states; +} +/* * powernv_idle_probe() * Choose state table for shared versus dedicated partition */ static int powernv_idle_probe (void ) { -if (cpuidle_disable !=IDLE_NO_OVERRIDE )return -ENODEV ;if (firmware_has_feature (FW_FEATURE_OPALv3)) { cpuidle_state_table = powernv_states; - max_idle_state =ARRAY_SIZE (powernv_states); +/* Device tree can indicate more idle states */ + max_idle_state =powernv_add_idle_states (); }else return -ENODEV ;