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 POWERPC_CPU_TYPE_NAME("host") 13 14 #ifdef CONFIG_KVM 15 16 uint32_t kvmppc_get_tbfreq(void); 17 uint64_t kvmppc_get_clockfreq(void); 18 bool kvmppc_get_host_model(char **buf); 19 bool kvmppc_get_host_serial(char **buf); 20 int kvmppc_get_hasidle(CPUPPCState *env); 21 int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len); 22 int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level); 23 void kvmppc_enable_logical_ci_hcalls(void); 24 void kvmppc_enable_set_mode_hcall(void); 25 void kvmppc_enable_clear_ref_mod_hcalls(void); 26 void kvmppc_enable_h_page_init(void); 27 void kvmppc_set_papr(PowerPCCPU *cpu); 28 int kvmppc_set_compat(PowerPCCPU *cpu, uint32_t compat_pvr); 29 void kvmppc_set_mpic_proxy(PowerPCCPU *cpu, int mpic_proxy); 30 int kvmppc_smt_threads(void); 31 void kvmppc_hint_smt_possible(Error **errp); 32 int kvmppc_set_smt_threads(int smt); 33 int kvmppc_clear_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits); 34 int kvmppc_or_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits); 35 int kvmppc_set_tcr(PowerPCCPU *cpu); 36 int kvmppc_booke_watchdog_enable(PowerPCCPU *cpu); 37 target_ulong kvmppc_configure_v3_mmu(PowerPCCPU *cpu, 38 bool radix, bool gtse, 39 uint64_t proc_tbl); 40 #ifndef CONFIG_USER_ONLY 41 bool kvmppc_spapr_use_multitce(void); 42 int kvmppc_spapr_enable_inkernel_multitce(void); 43 void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t page_shift, 44 uint64_t bus_offset, uint32_t nb_table, 45 int *pfd, bool need_vfio); 46 int kvmppc_remove_spapr_tce(void *table, int pfd, uint32_t window_size); 47 int kvmppc_reset_htab(int shift_hint); 48 uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift); 49 bool kvmppc_has_cap_spapr_vfio(void); 50 #endif /* !CONFIG_USER_ONLY */ 51 bool kvmppc_has_cap_epr(void); 52 int kvmppc_define_rtas_kernel_token(uint32_t token, const char *function); 53 int kvmppc_get_htab_fd(bool write, uint64_t index, Error **errp); 54 int kvmppc_save_htab(QEMUFile *f, int fd, size_t bufsize, int64_t max_ns); 55 int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index, 56 uint16_t n_valid, uint16_t n_invalid); 57 void kvmppc_read_hptes(ppc_hash_pte64_t *hptes, hwaddr ptex, int n); 58 void kvmppc_write_hpte(hwaddr ptex, uint64_t pte0, uint64_t pte1); 59 bool kvmppc_has_cap_fixup_hcalls(void); 60 bool kvmppc_has_cap_htm(void); 61 bool kvmppc_has_cap_mmu_radix(void); 62 bool kvmppc_has_cap_mmu_hash_v3(void); 63 bool kvmppc_has_cap_xive(void); 64 int kvmppc_get_cap_safe_cache(void); 65 int kvmppc_get_cap_safe_bounds_check(void); 66 int kvmppc_get_cap_safe_indirect_branch(void); 67 int kvmppc_get_cap_count_cache_flush_assist(void); 68 bool kvmppc_has_cap_nested_kvm_hv(void); 69 int kvmppc_set_cap_nested_kvm_hv(int enable); 70 int kvmppc_get_cap_large_decr(void); 71 int kvmppc_enable_cap_large_decr(PowerPCCPU *cpu, int enable); 72 int kvmppc_enable_hwrng(void); 73 int kvmppc_put_books_sregs(PowerPCCPU *cpu); 74 PowerPCCPUClass *kvm_ppc_get_host_cpu_class(void); 75 void kvmppc_check_papr_resize_hpt(Error **errp); 76 int kvmppc_resize_hpt_prepare(PowerPCCPU *cpu, target_ulong flags, int shift); 77 int kvmppc_resize_hpt_commit(PowerPCCPU *cpu, target_ulong flags, int shift); 78 bool kvmppc_pvr_workaround_required(PowerPCCPU *cpu); 79 80 bool kvmppc_hpt_needs_host_contiguous_pages(void); 81 void kvm_check_mmu(PowerPCCPU *cpu, Error **errp); 82 void kvmppc_set_reg_ppc_online(PowerPCCPU *cpu, unsigned int online); 83 void kvmppc_set_reg_tb_offset(PowerPCCPU *cpu, int64_t tb_offset); 84 85 #else 86 87 static inline uint32_t kvmppc_get_tbfreq(void) 88 { 89 return 0; 90 } 91 92 static inline bool kvmppc_get_host_model(char **buf) 93 { 94 return false; 95 } 96 97 static inline bool kvmppc_get_host_serial(char **buf) 98 { 99 return false; 100 } 101 102 static inline uint64_t kvmppc_get_clockfreq(void) 103 { 104 return 0; 105 } 106 107 static inline uint32_t kvmppc_get_vmx(void) 108 { 109 return 0; 110 } 111 112 static inline uint32_t kvmppc_get_dfp(void) 113 { 114 return 0; 115 } 116 117 static inline int kvmppc_get_hasidle(CPUPPCState *env) 118 { 119 return 0; 120 } 121 122 static inline int kvmppc_get_hypercall(CPUPPCState *env, 123 uint8_t *buf, int buf_len) 124 { 125 return -1; 126 } 127 128 static inline int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level) 129 { 130 return -1; 131 } 132 133 static inline void kvmppc_enable_logical_ci_hcalls(void) 134 { 135 } 136 137 static inline void kvmppc_enable_set_mode_hcall(void) 138 { 139 } 140 141 static inline void kvmppc_enable_clear_ref_mod_hcalls(void) 142 { 143 } 144 145 static inline void kvmppc_enable_h_page_init(void) 146 { 147 } 148 149 static inline void kvmppc_set_papr(PowerPCCPU *cpu) 150 { 151 } 152 153 static inline int kvmppc_set_compat(PowerPCCPU *cpu, uint32_t compat_pvr) 154 { 155 return 0; 156 } 157 158 static inline void kvmppc_set_mpic_proxy(PowerPCCPU *cpu, int mpic_proxy) 159 { 160 } 161 162 static inline int kvmppc_smt_threads(void) 163 { 164 return 1; 165 } 166 167 static inline void kvmppc_hint_smt_possible(Error **errp) 168 { 169 return; 170 } 171 172 static inline int kvmppc_set_smt_threads(int smt) 173 { 174 return 0; 175 } 176 177 static inline int kvmppc_or_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits) 178 { 179 return 0; 180 } 181 182 static inline int kvmppc_clear_tsr_bits(PowerPCCPU *cpu, uint32_t tsr_bits) 183 { 184 return 0; 185 } 186 187 static inline int kvmppc_set_tcr(PowerPCCPU *cpu) 188 { 189 return 0; 190 } 191 192 static inline int kvmppc_booke_watchdog_enable(PowerPCCPU *cpu) 193 { 194 return -1; 195 } 196 197 static inline target_ulong kvmppc_configure_v3_mmu(PowerPCCPU *cpu, 198 bool radix, bool gtse, 199 uint64_t proc_tbl) 200 { 201 return 0; 202 } 203 204 static inline void kvmppc_set_reg_ppc_online(PowerPCCPU *cpu, 205 unsigned int online) 206 { 207 return; 208 } 209 210 static inline void kvmppc_set_reg_tb_offset(PowerPCCPU *cpu, int64_t tb_offset) 211 { 212 } 213 214 #ifndef CONFIG_USER_ONLY 215 static inline bool kvmppc_spapr_use_multitce(void) 216 { 217 return false; 218 } 219 220 static inline int kvmppc_spapr_enable_inkernel_multitce(void) 221 { 222 return -1; 223 } 224 225 static inline void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t page_shift, 226 uint64_t bus_offset, 227 uint32_t nb_table, 228 int *pfd, bool need_vfio) 229 { 230 return NULL; 231 } 232 233 static inline int kvmppc_remove_spapr_tce(void *table, int pfd, 234 uint32_t nb_table) 235 { 236 return -1; 237 } 238 239 static inline int kvmppc_reset_htab(int shift_hint) 240 { 241 return 0; 242 } 243 244 static inline uint64_t kvmppc_rma_size(uint64_t current_size, 245 unsigned int hash_shift) 246 { 247 return ram_size; 248 } 249 250 static inline bool kvmppc_hpt_needs_host_contiguous_pages(void) 251 { 252 return false; 253 } 254 255 static inline void kvm_check_mmu(PowerPCCPU *cpu, Error **errp) 256 { 257 } 258 259 static inline bool kvmppc_has_cap_spapr_vfio(void) 260 { 261 return false; 262 } 263 264 #endif /* !CONFIG_USER_ONLY */ 265 266 static inline bool kvmppc_has_cap_epr(void) 267 { 268 return false; 269 } 270 271 static inline int kvmppc_define_rtas_kernel_token(uint32_t token, 272 const char *function) 273 { 274 return -1; 275 } 276 277 static inline int kvmppc_get_htab_fd(bool write, uint64_t index, Error **errp) 278 { 279 return -1; 280 } 281 282 static inline int kvmppc_save_htab(QEMUFile *f, int fd, size_t bufsize, 283 int64_t max_ns) 284 { 285 abort(); 286 } 287 288 static inline int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index, 289 uint16_t n_valid, uint16_t n_invalid) 290 { 291 abort(); 292 } 293 294 static inline void kvmppc_read_hptes(ppc_hash_pte64_t *hptes, 295 hwaddr ptex, int n) 296 { 297 abort(); 298 } 299 300 static inline void kvmppc_write_hpte(hwaddr ptex, uint64_t pte0, uint64_t pte1) 301 { 302 abort(); 303 } 304 305 static inline bool kvmppc_has_cap_fixup_hcalls(void) 306 { 307 abort(); 308 } 309 310 static inline bool kvmppc_has_cap_htm(void) 311 { 312 return false; 313 } 314 315 static inline bool kvmppc_has_cap_mmu_radix(void) 316 { 317 return false; 318 } 319 320 static inline bool kvmppc_has_cap_mmu_hash_v3(void) 321 { 322 return false; 323 } 324 325 static inline bool kvmppc_has_cap_xive(void) 326 { 327 return false; 328 } 329 330 static inline int kvmppc_get_cap_safe_cache(void) 331 { 332 return 0; 333 } 334 335 static inline int kvmppc_get_cap_safe_bounds_check(void) 336 { 337 return 0; 338 } 339 340 static inline int kvmppc_get_cap_safe_indirect_branch(void) 341 { 342 return 0; 343 } 344 345 static inline int kvmppc_get_cap_count_cache_flush_assist(void) 346 { 347 return 0; 348 } 349 350 static inline bool kvmppc_has_cap_nested_kvm_hv(void) 351 { 352 return false; 353 } 354 355 static inline int kvmppc_set_cap_nested_kvm_hv(int enable) 356 { 357 return -1; 358 } 359 360 static inline int kvmppc_get_cap_large_decr(void) 361 { 362 return 0; 363 } 364 365 static inline int kvmppc_enable_cap_large_decr(PowerPCCPU *cpu, int enable) 366 { 367 return -1; 368 } 369 370 static inline int kvmppc_enable_hwrng(void) 371 { 372 return -1; 373 } 374 375 static inline int kvmppc_put_books_sregs(PowerPCCPU *cpu) 376 { 377 abort(); 378 } 379 380 static inline PowerPCCPUClass *kvm_ppc_get_host_cpu_class(void) 381 { 382 return NULL; 383 } 384 385 static inline void kvmppc_check_papr_resize_hpt(Error **errp) 386 { 387 return; 388 } 389 390 static inline int kvmppc_resize_hpt_prepare(PowerPCCPU *cpu, 391 target_ulong flags, int shift) 392 { 393 return -ENOSYS; 394 } 395 396 static inline int kvmppc_resize_hpt_commit(PowerPCCPU *cpu, 397 target_ulong flags, int shift) 398 { 399 return -ENOSYS; 400 } 401 402 static inline bool kvmppc_pvr_workaround_required(PowerPCCPU *cpu) 403 { 404 return false; 405 } 406 407 #endif 408 409 #ifndef CONFIG_KVM 410 411 #define kvmppc_eieio() do { } while (0) 412 413 static inline void kvmppc_dcbst_range(PowerPCCPU *cpu, uint8_t *addr, int len) 414 { 415 } 416 417 static inline void kvmppc_icbi_range(PowerPCCPU *cpu, uint8_t *addr, int len) 418 { 419 } 420 421 #else /* CONFIG_KVM */ 422 423 #define kvmppc_eieio() \ 424 do { \ 425 if (kvm_enabled()) { \ 426 asm volatile("eieio" : : : "memory"); \ 427 } \ 428 } while (0) 429 430 /* Store data cache blocks back to memory */ 431 static inline void kvmppc_dcbst_range(PowerPCCPU *cpu, uint8_t *addr, int len) 432 { 433 uint8_t *p; 434 435 for (p = addr; p < addr + len; p += cpu->env.dcache_line_size) { 436 asm volatile("dcbst 0,%0" : : "r"(p) : "memory"); 437 } 438 } 439 440 /* Invalidate instruction cache blocks */ 441 static inline void kvmppc_icbi_range(PowerPCCPU *cpu, uint8_t *addr, int len) 442 { 443 uint8_t *p; 444 445 for (p = addr; p < addr + len; p += cpu->env.icache_line_size) { 446 asm volatile("icbi 0,%0" : : "r"(p)); 447 } 448 } 449 450 #endif /* CONFIG_KVM */ 451 452 #endif /* KVM_PPC_H */ 453