target-ppc/kvm_ppc.h

   1 /*
   2  * Copyright 2008 IBM Corporation.
   3  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
   4  *
   5  * This work is licensed under the GNU GPL license version 2 or later.
   6  *
   7  */
   8
   9 #ifndef __KVM_PPC_H__
  10 #define __KVM_PPC_H__
  11
  12 #define TYPE_HOST_POWERPC_CPU "host-" TYPE_POWERPC_CPU
  13
  14 void kvmppc_init(void);
  15
  16 #ifdef CONFIG_KVM
  17
  18 uint32_t kvmppc_get_tbfreq(void);
  19 uint64_t kvmppc_get_clockfreq(void);
  20 uint32_t kvmppc_get_vmx(void);
  21 uint32_t kvmppc_get_dfp(void);
  22 int kvmppc_get_hasidle(CPUPPCState *env);
  23 int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len);
  24 int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level);
  25 void kvmppc_set_papr(PowerPCCPU *cpu);
  26 int kvmppc_set_compat(PowerPCCPU *cpu, uint32_t cpu_version);
  27 void kvmppc_set_mpic_proxy(PowerPCCPU *cpu, int mpic_proxy);
  28 int kvmppc_smt_threads(void);
  29 int kvmppc_clear_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits);
  30 int kvmppc_or_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits);
  31 int kvmppc_set_tcr(PowerPCCPU *cpu);
  32 int kvmppc_booke_watchdog_enable(PowerPCCPU *cpu);
  33 #ifndef CONFIG_USER_ONLY
  34 off_t kvmppc_alloc_rma(const char *name, MemoryRegion *sysmem);
  35 bool kvmppc_spapr_use_multitce(void);
  36 void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t window_size, int *pfd);
  37 int kvmppc_remove_spapr_tce(void *table, int pfd, uint32_t window_size);
  38 int kvmppc_reset_htab(int shift_hint);
  39 uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift);
  40 #endif /* !CONFIG_USER_ONLY */
  41 bool kvmppc_has_cap_epr(void);
  42 int kvmppc_define_rtas_kernel_token(uint32_t token, const char *function);
  43 bool kvmppc_has_cap_htab_fd(void);
  44 int kvmppc_get_htab_fd(bool write);
  45 int kvmppc_save_htab(QEMUFile *f, int fd, size_t bufsize, int64_t max_ns);
  46 int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index,
  47                            uint16_t n_valid, uint16_t n_invalid);
  48 uint64_t kvmppc_hash64_read_pteg(PowerPCCPU *cpu, target_ulong pte_index);
  49 void kvmppc_hash64_free_pteg(uint64_t token);
  50
  51 void kvmppc_hash64_write_pte(CPUPPCState *env, target_ulong pte_index,
  52                              target_ulong pte0, target_ulong pte1);
  53 bool kvmppc_has_cap_fixup_hcalls(void);
  54
  55 #else
  56
  57 static inline uint32_t kvmppc_get_tbfreq(void)
  58 {
  59     return 0;
  60 }
  61
  62 static inline uint64_t kvmppc_get_clockfreq(void)
  63 {
  64     return 0;
  65 }
  66
  67 static inline uint32_t kvmppc_get_vmx(void)
  68 {
  69     return 0;
  70 }
  71
  72 static inline uint32_t kvmppc_get_dfp(void)
  73 {
  74     return 0;
  75 }
  76
  77 static inline int kvmppc_get_hasidle(CPUPPCState *env)
  78 {
  79     return 0;
  80 }
  81
  82 static inline int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len)
  83 {
  84     return -1;
  85 }
  86
  87 static inline int kvmppc_read_segment_page_sizes(uint32_t *prop, int maxcells)
  88 {
  89     return -1;
  90 }
  91
  92 static inline int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level)
  93 {
  94     return -1;
  95 }
  96
  97 static inline void kvmppc_set_papr(PowerPCCPU *cpu)
  98 {
  99 }
 100
 101 static inline int kvmppc_set_compat(PowerPCCPU *cpu, uint32_t cpu_version)
 102 {
 103     return 0;
 104 }
 105
 106 static inline void kvmppc_set_mpic_proxy(PowerPCCPU *cpu, int mpic_proxy)
 107 {
 108 }
 109
 110 static inline int kvmppc_smt_threads(void)
 111 {
 112     return 1;
 113 }
 114
 115 static inline int kvmppc_or_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits)
 116 {
 117     return 0;
 118 }
 119
 120 static inline int kvmppc_clear_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits)
 121 {
 122     return 0;
 123 }
 124
 125 static inline int kvmppc_set_tcr(PowerPCCPU *cpu)
 126 {
 127     return 0;
 128 }
 129
 130 static inline int kvmppc_booke_watchdog_enable(PowerPCCPU *cpu)
 131 {
 132     return -1;
 133 }
 134
 135 #ifndef CONFIG_USER_ONLY
 136 static inline off_t kvmppc_alloc_rma(const char *name, MemoryRegion *sysmem)
 137 {
 138     return 0;
 139 }
 140
 141 static inline bool kvmppc_spapr_use_multitce(void)
 142 {
 143     return false;
 144 }
 145
 146 static inline void *kvmppc_create_spapr_tce(uint32_t liobn,
 147                                             uint32_t window_size, int *fd)
 148 {
 149     return NULL;
 150 }
 151
 152 static inline int kvmppc_remove_spapr_tce(void *table, int pfd,
 153                                           uint32_t nb_table)
 154 {
 155     return -1;
 156 }
 157
 158 static inline int kvmppc_reset_htab(int shift_hint)
 159 {
 160     return -1;
 161 }
 162
 163 static inline uint64_t kvmppc_rma_size(uint64_t current_size,
 164                                        unsigned int hash_shift)
 165 {
 166     return ram_size;
 167 }
 168
 169 static inline int kvmppc_update_sdr1(CPUPPCState *env)
 170 {
 171     return 0;
 172 }
 173
 174 #endif /* !CONFIG_USER_ONLY */
 175
 176 static inline bool kvmppc_has_cap_epr(void)
 177 {
 178     return false;
 179 }
 180
 181 static inline int kvmppc_define_rtas_kernel_token(uint32_t token,
 182                                                   const char *function)
 183 {
 184     return -1;
 185 }
 186
 187 static inline bool kvmppc_has_cap_htab_fd(void)
 188 {
 189     return false;
 190 }
 191
 192 static inline int kvmppc_get_htab_fd(bool write)
 193 {
 194     return -1;
 195 }
 196
 197 static inline int kvmppc_save_htab(QEMUFile *f, int fd, size_t bufsize,
 198                                    int64_t max_ns)
 199 {
 200     abort();
 201 }
 202
 203 static inline int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index,
 204                                          uint16_t n_valid, uint16_t n_invalid)
 205 {
 206     abort();
 207 }
 208
 209 static inline uint64_t kvmppc_hash64_read_pteg(PowerPCCPU *cpu,
 210                                                target_ulong pte_index)
 211 {
 212     abort();
 213 }
 214
 215 static inline void kvmppc_hash64_free_pteg(uint64_t token)
 216 {
 217     abort();
 218 }
 219
 220 static inline void kvmppc_hash64_write_pte(CPUPPCState *env,
 221                                            target_ulong pte_index,
 222                                            target_ulong pte0, target_ulong pte1)
 223 {
 224     abort();
 225 }
 226
 227 static inline bool kvmppc_has_cap_fixup_hcalls(void)
 228 {
 229     abort();
 230 }
 231
 232 #endif
 233
 234 #ifndef CONFIG_KVM
 235 #define kvmppc_eieio() do { } while (0)
 236 #else
 237 #define kvmppc_eieio() \
 238     do {                                          \
 239         if (kvm_enabled()) {                          \
 240             asm volatile("eieio" : : : "memory"); \
 241         } \
 242     } while (0)
 243 #endif
 244
 245 #ifndef KVM_INTERRUPT_SET
 246 #define KVM_INTERRUPT_SET -1
 247 #endif
 248
 249 #ifndef KVM_INTERRUPT_UNSET
 250 #define KVM_INTERRUPT_UNSET -2
 251 #endif
 252
 253 #ifndef KVM_INTERRUPT_SET_LEVEL
 254 #define KVM_INTERRUPT_SET_LEVEL -3
 255 #endif
 256
 257 #endif /* __KVM_PPC_H__ */