xref: /openbmc/qemu/target/ppc/kvm_ppc.h (revision 05caa062)
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