MIPS: Hang more efficiently on halt/powerdown/restart

The generic MIPS implementations of halting, powering down or restarting
the system all hang using a busy loop as a last resort. We have many
platforms which avoid this loop by implementing their own, many using
some variation upon executing a wait instruction to lower CPU power
usage if we reach this point.

In order to prepare for cleaning up these various custom implementations
of the same thing, this patch makes the generic machine_halt(),
machine_power_off() & machine_restart() functions each make use of the
wait instruction to lower CPU power usage in cases where we know that
the wait instruction is available. If wait isn't known to be supported
then we fall back to calling cpu_wait(), and if we don't have a
cpu_wait() callback then we effectively continue using a busy loop.

In effect the new machine_hang() function provides a superset of the
functionality that the various platforms currently provide differing
subsets of.

Signed-off-by: Paul Burton <paul.burton@mips.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/17178/
Signed-off-by: James Hogan <jhogan@kernel.org>

diff --git a/arch/mips/kernel/reset.c b/arch/mips/kernel/reset.c
index 7c746d3458e71a93594760866f3933e6351bcc5a..6288780b779e7c451f19f9160e0823ac1decb2ff 100644 (file)
--- a/arch/mips/kernel/reset.c
+++ b/arch/mips/kernel/reset.c
@@ -13,6 +13,9 @@
 #include <linux/reboot.h>
 #include <linux/delay.h>
 
+#include <asm/compiler.h>
+#include <asm/idle.h>
+#include <asm/mipsregs.h>
 #include <asm/reboot.h>
 
 /*
@@ -26,6 +29,62 @@ void (*pm_power_off)(void);
 
 EXPORT_SYMBOL(pm_power_off);
 
+static void machine_hang(void)
+{
+       /*
+        * We're hanging the system so we don't want to be interrupted anymore.
+        * Any interrupt handlers that ran would at best be useless & at worst
+        * go awry because the system isn't in a functional state.
+        */
+       local_irq_disable();
+
+       /*
+        * Mask all interrupts, giving us a better chance of remaining in the
+        * low power wait state.
+        */
+       clear_c0_status(ST0_IM);
+
+       while (true) {
+               if (cpu_has_mips_r) {
+                       /*
+                        * We know that the wait instruction is supported so
+                        * make use of it directly, leaving interrupts
+                        * disabled.
+                        */
+                       asm volatile(
+                               ".set   push\n\t"
+                               ".set   " MIPS_ISA_ARCH_LEVEL "\n\t"
+                               "wait\n\t"
+                               ".set   pop");
+               } else if (cpu_wait) {
+                       /*
+                        * Try the cpu_wait() callback. This isn't ideal since
+                        * it'll re-enable interrupts, but that ought to be
+                        * harmless given that they're all masked.
+                        */
+                       cpu_wait();
+                       local_irq_disable();
+               } else {
+                       /*
+                        * We're going to burn some power running round the
+                        * loop, but we don't really have a choice. This isn't
+                        * a path we should expect to run for long during
+                        * typical use anyway.
+                        */
+               }
+
+               /*
+                * In most modern MIPS CPUs interrupts will cause the wait
+                * instruction to graduate even when disabled, and in some
+                * cases even when masked. In order to prevent a timer
+                * interrupt from continuously taking us out of the low power
+                * wait state, we clear any pending timer interrupt here.
+                */
+               if (cpu_has_counter)
+                       write_c0_compare(0);
+       }
+}
+
 void machine_restart(char *command)
 {
        if (_machine_restart)
@@ -38,8 +97,7 @@ void machine_restart(char *command)
        do_kernel_restart(command);
        mdelay(1000);
        pr_emerg("Reboot failed -- System halted\n");
-       local_irq_disable();
-       while (1);
+       machine_hang();
 }
 
 void machine_halt(void)
@@ -51,8 +109,7 @@ void machine_halt(void)
        preempt_disable();
        smp_send_stop();
 #endif
-       local_irq_disable();
-       while (1);
+       machine_hang();
 }
 
 void machine_power_off(void)
@@ -64,6 +121,5 @@ void machine_power_off(void)
        preempt_disable();
        smp_send_stop();
 #endif
-       local_irq_disable();
-       while (1);
+       machine_hang();
 }