diff mbox series

[RFC,v2,29/29] target/ppc: move the p*_interrupt_powersave methods to excp_helper.c

Message ID 20220927201544.4088567-30-matheus.ferst@eldorado.org.br
State Changes Requested
Headers show
Series PowerPC interrupt rework | expand

Commit Message

Matheus K. Ferst Sept. 27, 2022, 8:15 p.m. UTC
Move the methods to excp_helper.c and make them static.

Signed-off-by: Matheus Ferst <matheus.ferst@eldorado.org.br>
---
 target/ppc/cpu_init.c    | 102 ---------------------------------------
 target/ppc/excp_helper.c | 102 +++++++++++++++++++++++++++++++++++++++
 target/ppc/internal.h    |   6 ---
 3 files changed, 102 insertions(+), 108 deletions(-)

Comments

Fabiano Rosas Oct. 3, 2022, 2:13 p.m. UTC | #1
Matheus Ferst <matheus.ferst@eldorado.org.br> writes:

> Move the methods to excp_helper.c and make them static.
>
> Signed-off-by: Matheus Ferst <matheus.ferst@eldorado.org.br>

Reviewed-by: Fabiano Rosas <farosas@linux.ibm.com>

> ---
>  target/ppc/cpu_init.c    | 102 ---------------------------------------
>  target/ppc/excp_helper.c | 102 +++++++++++++++++++++++++++++++++++++++
>  target/ppc/internal.h    |   6 ---
>  3 files changed, 102 insertions(+), 108 deletions(-)
>
> diff --git a/target/ppc/cpu_init.c b/target/ppc/cpu_init.c
> index 4d0064c7a5..a9c2726d51 100644
> --- a/target/ppc/cpu_init.c
> +++ b/target/ppc/cpu_init.c
> @@ -5960,30 +5960,6 @@ static bool ppc_pvr_match_power7(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
>      return true;
>  }
>  
> -int p7_interrupt_powersave(CPUPPCState *env)
> -{
> -    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> -        (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
> -        return PPC_INTERRUPT_EXT;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> -        (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
> -        return PPC_INTERRUPT_DECR;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> -        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> -        return PPC_INTERRUPT_MCK;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> -        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> -        return PPC_INTERRUPT_HMI;
> -    }
> -    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> -        return PPC_INTERRUPT_RESET;
> -    }
> -    return 0;
> -}
> -
>  POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data)
>  {
>      DeviceClass *dc = DEVICE_CLASS(oc);
> @@ -6120,38 +6096,6 @@ static bool ppc_pvr_match_power8(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
>      return true;
>  }
>  
> -int p8_interrupt_powersave(CPUPPCState *env)
> -{
> -    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
> -        return PPC_INTERRUPT_EXT;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
> -        return PPC_INTERRUPT_DECR;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> -        return PPC_INTERRUPT_MCK;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> -        return PPC_INTERRUPT_HMI;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
> -        return PPC_INTERRUPT_DOORBELL;
> -    }
> -    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> -        (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
> -        return PPC_INTERRUPT_HDOORBELL;
> -    }
> -    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> -        return PPC_INTERRUPT_RESET;
> -    }
> -    return 0;
> -}
> -
>  POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)
>  {
>      DeviceClass *dc = DEVICE_CLASS(oc);
> @@ -6325,52 +6269,6 @@ static bool ppc_pvr_match_power9(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
>      return false;
>  }
>  
> -int p9_interrupt_powersave(CPUPPCState *env)
> -{
> -    /* External Exception */
> -    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> -        (env->spr[SPR_LPCR] & LPCR_EEE)) {
> -        bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> -        if (!heic || !FIELD_EX64_HV(env->msr) ||
> -            FIELD_EX64(env->msr, MSR, PR)) {
> -            return PPC_INTERRUPT_EXT;
> -        }
> -    }
> -    /* Decrementer Exception */
> -    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> -        (env->spr[SPR_LPCR] & LPCR_DEE)) {
> -        return PPC_INTERRUPT_DECR;
> -    }
> -    /* Machine Check or Hypervisor Maintenance Exception */
> -    if (env->spr[SPR_LPCR] & LPCR_OEE) {
> -        if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> -            return PPC_INTERRUPT_MCK;
> -        }
> -        if (env->pending_interrupts & PPC_INTERRUPT_HMI) {
> -            return PPC_INTERRUPT_HMI;
> -        }
> -    }
> -    /* Privileged Doorbell Exception */
> -    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> -        (env->spr[SPR_LPCR] & LPCR_PDEE)) {
> -        return PPC_INTERRUPT_DOORBELL;
> -    }
> -    /* Hypervisor Doorbell Exception */
> -    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> -        (env->spr[SPR_LPCR] & LPCR_HDEE)) {
> -        return PPC_INTERRUPT_HDOORBELL;
> -    }
> -    /* Hypervisor virtualization exception */
> -    if ((env->pending_interrupts & PPC_INTERRUPT_HVIRT) &&
> -        (env->spr[SPR_LPCR] & LPCR_HVEE)) {
> -        return PPC_INTERRUPT_HVIRT;
> -    }
> -    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> -        return PPC_INTERRUPT_RESET;
> -    }
> -    return 0;
> -}
> -
>  POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)
>  {
>      DeviceClass *dc = DEVICE_CLASS(oc);
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index 9708f82b30..57937956e4 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -1686,6 +1686,30 @@ void ppc_cpu_do_interrupt(CPUState *cs)
>       PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL | PPC_INTERRUPT_HDOORBELL | \
>       PPC_INTERRUPT_THERM | PPC_INTERRUPT_EBB)
>  
> +static int p7_interrupt_powersave(CPUPPCState *env)
> +{
> +    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> +        (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
> +        return PPC_INTERRUPT_EXT;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> +        (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
> +        return PPC_INTERRUPT_DECR;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> +        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> +        return PPC_INTERRUPT_MCK;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> +        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> +        return PPC_INTERRUPT_HMI;
> +    }
> +    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> +        return PPC_INTERRUPT_RESET;
> +    }
> +    return 0;
> +}
> +
>  static int p7_next_unmasked_interrupt(CPUPPCState *env)
>  {
>      PowerPCCPU *cpu = env_archcpu(env);
> @@ -1751,6 +1775,38 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
>      PPC_INTERRUPT_FIT | PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL |    \
>      PPC_INTERRUPT_HDOORBELL | PPC_INTERRUPT_THERM)
>  
> +static int p8_interrupt_powersave(CPUPPCState *env)
> +{
> +    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
> +        return PPC_INTERRUPT_EXT;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
> +        return PPC_INTERRUPT_DECR;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> +        return PPC_INTERRUPT_MCK;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> +        return PPC_INTERRUPT_HMI;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
> +        return PPC_INTERRUPT_DOORBELL;
> +    }
> +    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> +        (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
> +        return PPC_INTERRUPT_HDOORBELL;
> +    }
> +    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> +        return PPC_INTERRUPT_RESET;
> +    }
> +    return 0;
> +}
> +
>  static int p8_next_unmasked_interrupt(CPUPPCState *env)
>  {
>      PowerPCCPU *cpu = env_archcpu(env);
> @@ -1820,6 +1876,52 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
>       PPC_INTERRUPT_WDT | PPC_INTERRUPT_CDOORBELL | PPC_INTERRUPT_FIT |  \
>       PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
>  
> +static int p9_interrupt_powersave(CPUPPCState *env)
> +{
> +    /* External Exception */
> +    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> +        (env->spr[SPR_LPCR] & LPCR_EEE)) {
> +        bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> +        if (!heic || !FIELD_EX64_HV(env->msr) ||
> +            FIELD_EX64(env->msr, MSR, PR)) {
> +            return PPC_INTERRUPT_EXT;
> +        }
> +    }
> +    /* Decrementer Exception */
> +    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> +        (env->spr[SPR_LPCR] & LPCR_DEE)) {
> +        return PPC_INTERRUPT_DECR;
> +    }
> +    /* Machine Check or Hypervisor Maintenance Exception */
> +    if (env->spr[SPR_LPCR] & LPCR_OEE) {
> +        if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> +            return PPC_INTERRUPT_MCK;
> +        }
> +        if (env->pending_interrupts & PPC_INTERRUPT_HMI) {
> +            return PPC_INTERRUPT_HMI;
> +        }
> +    }
> +    /* Privileged Doorbell Exception */
> +    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> +        (env->spr[SPR_LPCR] & LPCR_PDEE)) {
> +        return PPC_INTERRUPT_DOORBELL;
> +    }
> +    /* Hypervisor Doorbell Exception */
> +    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> +        (env->spr[SPR_LPCR] & LPCR_HDEE)) {
> +        return PPC_INTERRUPT_HDOORBELL;
> +    }
> +    /* Hypervisor virtualization exception */
> +    if ((env->pending_interrupts & PPC_INTERRUPT_HVIRT) &&
> +        (env->spr[SPR_LPCR] & LPCR_HVEE)) {
> +        return PPC_INTERRUPT_HVIRT;
> +    }
> +    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> +        return PPC_INTERRUPT_RESET;
> +    }
> +    return 0;
> +}
> +
>  static int p9_next_unmasked_interrupt(CPUPPCState *env)
>  {
>      PowerPCCPU *cpu = env_archcpu(env);
> diff --git a/target/ppc/internal.h b/target/ppc/internal.h
> index 25827ebf6f..337a362205 100644
> --- a/target/ppc/internal.h
> +++ b/target/ppc/internal.h
> @@ -306,10 +306,4 @@ static inline int ger_pack_masks(int pmsk, int ymsk, int xmsk)
>      return msk;
>  }
>  
> -#if defined(TARGET_PPC64)
> -int p9_interrupt_powersave(CPUPPCState *env);
> -int p8_interrupt_powersave(CPUPPCState *env);
> -int p7_interrupt_powersave(CPUPPCState *env);
> -#endif
> -
>  #endif /* PPC_INTERNAL_H */
diff mbox series

Patch

diff --git a/target/ppc/cpu_init.c b/target/ppc/cpu_init.c
index 4d0064c7a5..a9c2726d51 100644
--- a/target/ppc/cpu_init.c
+++ b/target/ppc/cpu_init.c
@@ -5960,30 +5960,6 @@  static bool ppc_pvr_match_power7(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
     return true;
 }
 
-int p7_interrupt_powersave(CPUPPCState *env)
-{
-    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
-        (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
-        return PPC_INTERRUPT_EXT;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
-        (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
-        return PPC_INTERRUPT_DECR;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
-        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
-        return PPC_INTERRUPT_MCK;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
-        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
-        return PPC_INTERRUPT_HMI;
-    }
-    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
-        return PPC_INTERRUPT_RESET;
-    }
-    return 0;
-}
-
 POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(oc);
@@ -6120,38 +6096,6 @@  static bool ppc_pvr_match_power8(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
     return true;
 }
 
-int p8_interrupt_powersave(CPUPPCState *env)
-{
-    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
-        return PPC_INTERRUPT_EXT;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
-        return PPC_INTERRUPT_DECR;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
-        return PPC_INTERRUPT_MCK;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
-        return PPC_INTERRUPT_HMI;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
-        return PPC_INTERRUPT_DOORBELL;
-    }
-    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
-        (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
-        return PPC_INTERRUPT_HDOORBELL;
-    }
-    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
-        return PPC_INTERRUPT_RESET;
-    }
-    return 0;
-}
-
 POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(oc);
@@ -6325,52 +6269,6 @@  static bool ppc_pvr_match_power9(PowerPCCPUClass *pcc, uint32_t pvr, bool best)
     return false;
 }
 
-int p9_interrupt_powersave(CPUPPCState *env)
-{
-    /* External Exception */
-    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
-        (env->spr[SPR_LPCR] & LPCR_EEE)) {
-        bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
-        if (!heic || !FIELD_EX64_HV(env->msr) ||
-            FIELD_EX64(env->msr, MSR, PR)) {
-            return PPC_INTERRUPT_EXT;
-        }
-    }
-    /* Decrementer Exception */
-    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
-        (env->spr[SPR_LPCR] & LPCR_DEE)) {
-        return PPC_INTERRUPT_DECR;
-    }
-    /* Machine Check or Hypervisor Maintenance Exception */
-    if (env->spr[SPR_LPCR] & LPCR_OEE) {
-        if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
-            return PPC_INTERRUPT_MCK;
-        }
-        if (env->pending_interrupts & PPC_INTERRUPT_HMI) {
-            return PPC_INTERRUPT_HMI;
-        }
-    }
-    /* Privileged Doorbell Exception */
-    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
-        (env->spr[SPR_LPCR] & LPCR_PDEE)) {
-        return PPC_INTERRUPT_DOORBELL;
-    }
-    /* Hypervisor Doorbell Exception */
-    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
-        (env->spr[SPR_LPCR] & LPCR_HDEE)) {
-        return PPC_INTERRUPT_HDOORBELL;
-    }
-    /* Hypervisor virtualization exception */
-    if ((env->pending_interrupts & PPC_INTERRUPT_HVIRT) &&
-        (env->spr[SPR_LPCR] & LPCR_HVEE)) {
-        return PPC_INTERRUPT_HVIRT;
-    }
-    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
-        return PPC_INTERRUPT_RESET;
-    }
-    return 0;
-}
-
 POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(oc);
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index 9708f82b30..57937956e4 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -1686,6 +1686,30 @@  void ppc_cpu_do_interrupt(CPUState *cs)
      PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL | PPC_INTERRUPT_HDOORBELL | \
      PPC_INTERRUPT_THERM | PPC_INTERRUPT_EBB)
 
+static int p7_interrupt_powersave(CPUPPCState *env)
+{
+    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
+        (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
+        return PPC_INTERRUPT_EXT;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
+        (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
+        return PPC_INTERRUPT_DECR;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
+        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
+        return PPC_INTERRUPT_MCK;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
+        (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
+        return PPC_INTERRUPT_HMI;
+    }
+    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+        return PPC_INTERRUPT_RESET;
+    }
+    return 0;
+}
+
 static int p7_next_unmasked_interrupt(CPUPPCState *env)
 {
     PowerPCCPU *cpu = env_archcpu(env);
@@ -1751,6 +1775,38 @@  static int p7_next_unmasked_interrupt(CPUPPCState *env)
     PPC_INTERRUPT_FIT | PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL |    \
     PPC_INTERRUPT_HDOORBELL | PPC_INTERRUPT_THERM)
 
+static int p8_interrupt_powersave(CPUPPCState *env)
+{
+    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
+        return PPC_INTERRUPT_EXT;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
+        return PPC_INTERRUPT_DECR;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
+        return PPC_INTERRUPT_MCK;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
+        return PPC_INTERRUPT_HMI;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
+        return PPC_INTERRUPT_DOORBELL;
+    }
+    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
+        (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
+        return PPC_INTERRUPT_HDOORBELL;
+    }
+    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+        return PPC_INTERRUPT_RESET;
+    }
+    return 0;
+}
+
 static int p8_next_unmasked_interrupt(CPUPPCState *env)
 {
     PowerPCCPU *cpu = env_archcpu(env);
@@ -1820,6 +1876,52 @@  static int p8_next_unmasked_interrupt(CPUPPCState *env)
      PPC_INTERRUPT_WDT | PPC_INTERRUPT_CDOORBELL | PPC_INTERRUPT_FIT |  \
      PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
 
+static int p9_interrupt_powersave(CPUPPCState *env)
+{
+    /* External Exception */
+    if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
+        (env->spr[SPR_LPCR] & LPCR_EEE)) {
+        bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+        if (!heic || !FIELD_EX64_HV(env->msr) ||
+            FIELD_EX64(env->msr, MSR, PR)) {
+            return PPC_INTERRUPT_EXT;
+        }
+    }
+    /* Decrementer Exception */
+    if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
+        (env->spr[SPR_LPCR] & LPCR_DEE)) {
+        return PPC_INTERRUPT_DECR;
+    }
+    /* Machine Check or Hypervisor Maintenance Exception */
+    if (env->spr[SPR_LPCR] & LPCR_OEE) {
+        if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+            return PPC_INTERRUPT_MCK;
+        }
+        if (env->pending_interrupts & PPC_INTERRUPT_HMI) {
+            return PPC_INTERRUPT_HMI;
+        }
+    }
+    /* Privileged Doorbell Exception */
+    if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
+        (env->spr[SPR_LPCR] & LPCR_PDEE)) {
+        return PPC_INTERRUPT_DOORBELL;
+    }
+    /* Hypervisor Doorbell Exception */
+    if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
+        (env->spr[SPR_LPCR] & LPCR_HDEE)) {
+        return PPC_INTERRUPT_HDOORBELL;
+    }
+    /* Hypervisor virtualization exception */
+    if ((env->pending_interrupts & PPC_INTERRUPT_HVIRT) &&
+        (env->spr[SPR_LPCR] & LPCR_HVEE)) {
+        return PPC_INTERRUPT_HVIRT;
+    }
+    if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+        return PPC_INTERRUPT_RESET;
+    }
+    return 0;
+}
+
 static int p9_next_unmasked_interrupt(CPUPPCState *env)
 {
     PowerPCCPU *cpu = env_archcpu(env);
diff --git a/target/ppc/internal.h b/target/ppc/internal.h
index 25827ebf6f..337a362205 100644
--- a/target/ppc/internal.h
+++ b/target/ppc/internal.h
@@ -306,10 +306,4 @@  static inline int ger_pack_masks(int pmsk, int ymsk, int xmsk)
     return msk;
 }
 
-#if defined(TARGET_PPC64)
-int p9_interrupt_powersave(CPUPPCState *env);
-int p8_interrupt_powersave(CPUPPCState *env);
-int p7_interrupt_powersave(CPUPPCState *env);
-#endif
-
 #endif /* PPC_INTERNAL_H */