qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

kvm_ppc.h (11169B)

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