AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 09:40:58 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

MIPS: Hang more efficiently on halt/powerdown/restart

Browse Source 
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>
This commit is contained in:
Paul Burton 2017-08-23 13:53:16 -07:00 committed by James Hogan
parent 4d73b73ff7
commit 997e93d4df
No known key found for this signature in database
GPG Key ID: 6C0B6993DE38767A
1 changed files with 62 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
arch/mips/kernel/reset.c
View File

@ -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();
}