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