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