u32 *priority);
 extern int kvmppc_xive_int_on(struct kvm *kvm, u32 irq);
 extern int kvmppc_xive_int_off(struct kvm *kvm, u32 irq);
-extern void kvmppc_xive_init_module(void);
-extern void kvmppc_xive_exit_module(void);
 
 extern int kvmppc_xive_connect_vcpu(struct kvm_device *dev,
                                    struct kvm_vcpu *vcpu, u32 cpu);
 extern int kvmppc_xive_native_connect_vcpu(struct kvm_device *dev,
                                           struct kvm_vcpu *vcpu, u32 cpu);
 extern void kvmppc_xive_native_cleanup_vcpu(struct kvm_vcpu *vcpu);
-extern void kvmppc_xive_native_init_module(void);
-extern void kvmppc_xive_native_exit_module(void);
 extern int kvmppc_xive_native_get_vp(struct kvm_vcpu *vcpu,
                                     union kvmppc_one_reg *val);
 extern int kvmppc_xive_native_set_vp(struct kvm_vcpu *vcpu,
                                       u32 *priority) { return -1; }
 static inline int kvmppc_xive_int_on(struct kvm *kvm, u32 irq) { return -1; }
 static inline int kvmppc_xive_int_off(struct kvm *kvm, u32 irq) { return -1; }
-static inline void kvmppc_xive_init_module(void) { }
-static inline void kvmppc_xive_exit_module(void) { }
 
 static inline int kvmppc_xive_connect_vcpu(struct kvm_device *dev,
                                           struct kvm_vcpu *vcpu, u32 cpu) { return -EBUSY; }
 static inline int kvmppc_xive_native_connect_vcpu(struct kvm_device *dev,
                          struct kvm_vcpu *vcpu, u32 cpu) { return -EBUSY; }
 static inline void kvmppc_xive_native_cleanup_vcpu(struct kvm_vcpu *vcpu) { }
-static inline void kvmppc_xive_native_init_module(void) { }
-static inline void kvmppc_xive_native_exit_module(void) { }
 static inline int kvmppc_xive_native_get_vp(struct kvm_vcpu *vcpu,
                                            union kvmppc_one_reg *val)
 { return 0; }
                           unsigned long tce_value, unsigned long npages);
 long int kvmppc_rm_h_confer(struct kvm_vcpu *vcpu, int target,
                             unsigned int yield_count);
-long kvmppc_h_random(struct kvm_vcpu *vcpu);
+long kvmppc_rm_h_random(struct kvm_vcpu *vcpu);
 void kvmhv_commence_exit(int trap);
 void kvmppc_realmode_machine_check(struct kvm_vcpu *vcpu);
 void kvmppc_subcore_enter_guest(void);
 
 #ifdef CONFIG_KVM_XICS
 #ifdef CONFIG_KVM_XIVE
        if (xics_on_xive()) {
-               kvmppc_xive_init_module();
                kvm_register_device_ops(&kvm_xive_ops, KVM_DEV_TYPE_XICS);
-               if (kvmppc_xive_native_supported()) {
-                       kvmppc_xive_native_init_module();
+               if (kvmppc_xive_native_supported())
                        kvm_register_device_ops(&kvm_xive_native_ops,
                                                KVM_DEV_TYPE_XIVE);
-               }
        } else
 #endif
                kvm_register_device_ops(&kvm_xics_ops, KVM_DEV_TYPE_XICS);
 
 static void kvmppc_book3s_exit(void)
 {
-#ifdef CONFIG_KVM_XICS
-       if (xics_on_xive()) {
-               kvmppc_xive_exit_module();
-               kvmppc_xive_native_exit_module();
-       }
-#endif
 #ifdef CONFIG_KVM_BOOK3S_32_HANDLER
        kvmppc_book3s_exit_pr();
 #endif
 
        /* udbg_printf("H_PUT_TCE(): liobn=0x%lx ioba=0x%lx, tce=0x%lx\n", */
        /*          liobn, ioba, tce); */
 
-       /* For radix, we might be in virtual mode, so punt */
-       if (kvm_is_radix(vcpu->kvm))
-               return H_TOO_HARD;
-
        stt = kvmppc_find_table(vcpu->kvm, liobn);
        if (!stt)
                return H_TOO_HARD;
        bool prereg = false;
        struct kvmppc_spapr_tce_iommu_table *stit;
 
-       /* For radix, we might be in virtual mode, so punt */
-       if (kvm_is_radix(vcpu->kvm))
-               return H_TOO_HARD;
-
        /*
         * used to check for invalidations in progress
         */
        long i, ret;
        struct kvmppc_spapr_tce_iommu_table *stit;
 
-       /* For radix, we might be in virtual mode, so punt */
-       if (kvm_is_radix(vcpu->kvm))
-               return H_TOO_HARD;
-
        stt = kvmppc_find_table(vcpu->kvm, liobn);
        if (!stt)
                return H_TOO_HARD;
 
 #include "book3s_xics.h"
 #include "book3s_xive.h"
 
-/*
- * The XIVE module will populate these when it loads
- */
-unsigned long (*__xive_vm_h_xirr)(struct kvm_vcpu *vcpu);
-unsigned long (*__xive_vm_h_ipoll)(struct kvm_vcpu *vcpu, unsigned long server);
-int (*__xive_vm_h_ipi)(struct kvm_vcpu *vcpu, unsigned long server,
-                      unsigned long mfrr);
-int (*__xive_vm_h_cppr)(struct kvm_vcpu *vcpu, unsigned long cppr);
-int (*__xive_vm_h_eoi)(struct kvm_vcpu *vcpu, unsigned long xirr);
-EXPORT_SYMBOL_GPL(__xive_vm_h_xirr);
-EXPORT_SYMBOL_GPL(__xive_vm_h_ipoll);
-EXPORT_SYMBOL_GPL(__xive_vm_h_ipi);
-EXPORT_SYMBOL_GPL(__xive_vm_h_cppr);
-EXPORT_SYMBOL_GPL(__xive_vm_h_eoi);
-
 /*
  * Hash page table alignment on newer cpus(CPU_FTR_ARCH_206)
  * should be power of 2.
 }
 EXPORT_SYMBOL_GPL(kvmppc_hwrng_present);
 
-long kvmppc_h_random(struct kvm_vcpu *vcpu)
+long kvmppc_rm_h_random(struct kvm_vcpu *vcpu)
 {
-       int r;
-
-       /* Only need to do the expensive mfmsr() on radix */
-       if (kvm_is_radix(vcpu->kvm) && (mfmsr() & MSR_IR))
-               r = powernv_get_random_long(&vcpu->arch.regs.gpr[4]);
-       else
-               r = powernv_get_random_real_mode(&vcpu->arch.regs.gpr[4]);
-       if (r)
+       if (powernv_get_random_real_mode(&vcpu->arch.regs.gpr[4]))
                return H_SUCCESS;
 
        return H_HARDWARE;
 }
 
 #ifdef CONFIG_KVM_XICS
-static inline bool is_rm(void)
-{
-       return !(mfmsr() & MSR_DR);
-}
-
 unsigned long kvmppc_rm_h_xirr(struct kvm_vcpu *vcpu)
 {
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_xirr(vcpu);
-               if (unlikely(!__xive_vm_h_xirr))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_xirr(vcpu);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_xirr(vcpu);
+       else
                return xics_rm_h_xirr(vcpu);
 }
 
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
        vcpu->arch.regs.gpr[5] = get_tb();
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_xirr(vcpu);
-               if (unlikely(!__xive_vm_h_xirr))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_xirr(vcpu);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_xirr(vcpu);
+       else
                return xics_rm_h_xirr(vcpu);
 }
 
 {
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_ipoll(vcpu, server);
-               if (unlikely(!__xive_vm_h_ipoll))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_ipoll(vcpu, server);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_ipoll(vcpu, server);
+       else
                return H_TOO_HARD;
 }
 
 {
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_ipi(vcpu, server, mfrr);
-               if (unlikely(!__xive_vm_h_ipi))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_ipi(vcpu, server, mfrr);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_ipi(vcpu, server, mfrr);
+       else
                return xics_rm_h_ipi(vcpu, server, mfrr);
 }
 
 {
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_cppr(vcpu, cppr);
-               if (unlikely(!__xive_vm_h_cppr))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_cppr(vcpu, cppr);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_cppr(vcpu, cppr);
+       else
                return xics_rm_h_cppr(vcpu, cppr);
 }
 
 {
        if (!kvmppc_xics_enabled(vcpu))
                return H_TOO_HARD;
-       if (xics_on_xive()) {
-               if (is_rm())
-                       return xive_rm_h_eoi(vcpu, xirr);
-               if (unlikely(!__xive_vm_h_eoi))
-                       return H_NOT_AVAILABLE;
-               return __xive_vm_h_eoi(vcpu, xirr);
-       } else
+       if (xics_on_xive())
+               return xive_rm_h_eoi(vcpu, xirr);
+       else
                return xics_rm_h_eoi(vcpu, xirr);
 }
 #endif /* CONFIG_KVM_XICS */
 
 #else
        .long   0               /* 0x2fc - H_XIRR_X*/
 #endif
-       .long   DOTSYM(kvmppc_h_random) - hcall_real_table
+       .long   DOTSYM(kvmppc_rm_h_random) - hcall_real_table
        .globl  hcall_real_table_end
 hcall_real_table_end:
 
 
        .get_attr = xive_get_attr,
        .has_attr = xive_has_attr,
 };
-
-void kvmppc_xive_init_module(void)
-{
-       __xive_vm_h_xirr = xive_vm_h_xirr;
-       __xive_vm_h_ipoll = xive_vm_h_ipoll;
-       __xive_vm_h_ipi = xive_vm_h_ipi;
-       __xive_vm_h_cppr = xive_vm_h_cppr;
-       __xive_vm_h_eoi = xive_vm_h_eoi;
-}
-
-void kvmppc_xive_exit_module(void)
-{
-       __xive_vm_h_xirr = NULL;
-       __xive_vm_h_ipoll = NULL;
-       __xive_vm_h_ipi = NULL;
-       __xive_vm_h_cppr = NULL;
-       __xive_vm_h_eoi = NULL;
-}
 
 extern int xive_rm_h_cppr(struct kvm_vcpu *vcpu, unsigned long cppr);
 extern int xive_rm_h_eoi(struct kvm_vcpu *vcpu, unsigned long xirr);
 
-extern unsigned long (*__xive_vm_h_xirr)(struct kvm_vcpu *vcpu);
-extern unsigned long (*__xive_vm_h_ipoll)(struct kvm_vcpu *vcpu, unsigned long server);
-extern int (*__xive_vm_h_ipi)(struct kvm_vcpu *vcpu, unsigned long server,
-                             unsigned long mfrr);
-extern int (*__xive_vm_h_cppr)(struct kvm_vcpu *vcpu, unsigned long cppr);
-extern int (*__xive_vm_h_eoi)(struct kvm_vcpu *vcpu, unsigned long xirr);
-
 /*
  * Common Xive routines for XICS-over-XIVE and XIVE native
  */
 
        .has_attr = kvmppc_xive_native_has_attr,
        .mmap = kvmppc_xive_native_mmap,
 };
-
-void kvmppc_xive_native_init_module(void)
-{
-       ;
-}
-
-void kvmppc_xive_native_exit_module(void)
-{
-       ;
-}