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