1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _ASM_POWERPC_PLPAR_WRAPPERS_H
3 #define _ASM_POWERPC_PLPAR_WRAPPERS_H
4
5 #ifdef CONFIG_PPC_PSERIES
6
7 #include <linux/string.h>
8 #include <linux/irqflags.h>
9 #include <linux/delay.h>
10
11 #include <asm/hvcall.h>
12 #include <asm/paca.h>
13 #include <asm/lppaca.h>
14 #include <asm/page.h>
15
poll_pending(void)16 static inline long poll_pending(void)
17 {
18 return plpar_hcall_norets(H_POLL_PENDING);
19 }
20
get_cede_latency_hint(void)21 static inline u8 get_cede_latency_hint(void)
22 {
23 return get_lppaca()->cede_latency_hint;
24 }
25
set_cede_latency_hint(u8 latency_hint)26 static inline void set_cede_latency_hint(u8 latency_hint)
27 {
28 get_lppaca()->cede_latency_hint = latency_hint;
29 }
30
cede_processor(void)31 static inline long cede_processor(void)
32 {
33 /*
34 * We cannot call tracepoints inside RCU idle regions which
35 * means we must not trace H_CEDE.
36 */
37 return plpar_hcall_norets_notrace(H_CEDE);
38 }
39
extended_cede_processor(unsigned long latency_hint)40 static inline long extended_cede_processor(unsigned long latency_hint)
41 {
42 long rc;
43 u8 old_latency_hint = get_cede_latency_hint();
44
45 set_cede_latency_hint(latency_hint);
46
47 rc = cede_processor();
48
49 /* Ensure that H_CEDE returns with IRQs on */
50 if (WARN_ON(IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG) && !(mfmsr() & MSR_EE)))
51 __hard_irq_enable();
52
53 set_cede_latency_hint(old_latency_hint);
54
55 return rc;
56 }
57
vpa_call(unsigned long flags,unsigned long cpu,unsigned long vpa)58 static inline long vpa_call(unsigned long flags, unsigned long cpu,
59 unsigned long vpa)
60 {
61 flags = flags << H_VPA_FUNC_SHIFT;
62
63 return plpar_hcall_norets(H_REGISTER_VPA, flags, cpu, vpa);
64 }
65
unregister_vpa(unsigned long cpu)66 static inline long unregister_vpa(unsigned long cpu)
67 {
68 return vpa_call(H_VPA_DEREG_VPA, cpu, 0);
69 }
70
register_vpa(unsigned long cpu,unsigned long vpa)71 static inline long register_vpa(unsigned long cpu, unsigned long vpa)
72 {
73 return vpa_call(H_VPA_REG_VPA, cpu, vpa);
74 }
75
unregister_slb_shadow(unsigned long cpu)76 static inline long unregister_slb_shadow(unsigned long cpu)
77 {
78 return vpa_call(H_VPA_DEREG_SLB, cpu, 0);
79 }
80
register_slb_shadow(unsigned long cpu,unsigned long vpa)81 static inline long register_slb_shadow(unsigned long cpu, unsigned long vpa)
82 {
83 return vpa_call(H_VPA_REG_SLB, cpu, vpa);
84 }
85
unregister_dtl(unsigned long cpu)86 static inline long unregister_dtl(unsigned long cpu)
87 {
88 return vpa_call(H_VPA_DEREG_DTL, cpu, 0);
89 }
90
register_dtl(unsigned long cpu,unsigned long vpa)91 static inline long register_dtl(unsigned long cpu, unsigned long vpa)
92 {
93 return vpa_call(H_VPA_REG_DTL, cpu, vpa);
94 }
95
96 extern void vpa_init(int cpu);
97
plpar_pte_enter(unsigned long flags,unsigned long hpte_group,unsigned long hpte_v,unsigned long hpte_r,unsigned long * slot)98 static inline long plpar_pte_enter(unsigned long flags,
99 unsigned long hpte_group, unsigned long hpte_v,
100 unsigned long hpte_r, unsigned long *slot)
101 {
102 long rc;
103 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
104
105 rc = plpar_hcall(H_ENTER, retbuf, flags, hpte_group, hpte_v, hpte_r);
106
107 *slot = retbuf[0];
108
109 return rc;
110 }
111
plpar_pte_remove(unsigned long flags,unsigned long ptex,unsigned long avpn,unsigned long * old_pteh_ret,unsigned long * old_ptel_ret)112 static inline long plpar_pte_remove(unsigned long flags, unsigned long ptex,
113 unsigned long avpn, unsigned long *old_pteh_ret,
114 unsigned long *old_ptel_ret)
115 {
116 long rc;
117 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
118
119 rc = plpar_hcall(H_REMOVE, retbuf, flags, ptex, avpn);
120
121 *old_pteh_ret = retbuf[0];
122 *old_ptel_ret = retbuf[1];
123
124 return rc;
125 }
126
127 /* plpar_pte_remove_raw can be called in real mode. It calls plpar_hcall_raw */
plpar_pte_remove_raw(unsigned long flags,unsigned long ptex,unsigned long avpn,unsigned long * old_pteh_ret,unsigned long * old_ptel_ret)128 static inline long plpar_pte_remove_raw(unsigned long flags, unsigned long ptex,
129 unsigned long avpn, unsigned long *old_pteh_ret,
130 unsigned long *old_ptel_ret)
131 {
132 long rc;
133 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
134
135 rc = plpar_hcall_raw(H_REMOVE, retbuf, flags, ptex, avpn);
136
137 *old_pteh_ret = retbuf[0];
138 *old_ptel_ret = retbuf[1];
139
140 return rc;
141 }
142
plpar_pte_read(unsigned long flags,unsigned long ptex,unsigned long * old_pteh_ret,unsigned long * old_ptel_ret)143 static inline long plpar_pte_read(unsigned long flags, unsigned long ptex,
144 unsigned long *old_pteh_ret, unsigned long *old_ptel_ret)
145 {
146 long rc;
147 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
148
149 rc = plpar_hcall(H_READ, retbuf, flags, ptex);
150
151 *old_pteh_ret = retbuf[0];
152 *old_ptel_ret = retbuf[1];
153
154 return rc;
155 }
156
157 /* plpar_pte_read_raw can be called in real mode. It calls plpar_hcall_raw */
plpar_pte_read_raw(unsigned long flags,unsigned long ptex,unsigned long * old_pteh_ret,unsigned long * old_ptel_ret)158 static inline long plpar_pte_read_raw(unsigned long flags, unsigned long ptex,
159 unsigned long *old_pteh_ret, unsigned long *old_ptel_ret)
160 {
161 long rc;
162 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
163
164 rc = plpar_hcall_raw(H_READ, retbuf, flags, ptex);
165
166 *old_pteh_ret = retbuf[0];
167 *old_ptel_ret = retbuf[1];
168
169 return rc;
170 }
171
172 /*
173 * ptes must be 8*sizeof(unsigned long)
174 */
plpar_pte_read_4(unsigned long flags,unsigned long ptex,unsigned long * ptes)175 static inline long plpar_pte_read_4(unsigned long flags, unsigned long ptex,
176 unsigned long *ptes)
177
178 {
179 long rc;
180 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
181
182 rc = plpar_hcall9(H_READ, retbuf, flags | H_READ_4, ptex);
183
184 memcpy(ptes, retbuf, 8*sizeof(unsigned long));
185
186 return rc;
187 }
188
189 /*
190 * plpar_pte_read_4_raw can be called in real mode.
191 * ptes must be 8*sizeof(unsigned long)
192 */
plpar_pte_read_4_raw(unsigned long flags,unsigned long ptex,unsigned long * ptes)193 static inline long plpar_pte_read_4_raw(unsigned long flags, unsigned long ptex,
194 unsigned long *ptes)
195
196 {
197 long rc;
198 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
199
200 rc = plpar_hcall9_raw(H_READ, retbuf, flags | H_READ_4, ptex);
201
202 memcpy(ptes, retbuf, 8*sizeof(unsigned long));
203
204 return rc;
205 }
206
plpar_pte_protect(unsigned long flags,unsigned long ptex,unsigned long avpn)207 static inline long plpar_pte_protect(unsigned long flags, unsigned long ptex,
208 unsigned long avpn)
209 {
210 return plpar_hcall_norets(H_PROTECT, flags, ptex, avpn);
211 }
212
plpar_resize_hpt_prepare(unsigned long flags,unsigned long shift)213 static inline long plpar_resize_hpt_prepare(unsigned long flags,
214 unsigned long shift)
215 {
216 return plpar_hcall_norets(H_RESIZE_HPT_PREPARE, flags, shift);
217 }
218
plpar_resize_hpt_commit(unsigned long flags,unsigned long shift)219 static inline long plpar_resize_hpt_commit(unsigned long flags,
220 unsigned long shift)
221 {
222 return plpar_hcall_norets(H_RESIZE_HPT_COMMIT, flags, shift);
223 }
224
plpar_tce_get(unsigned long liobn,unsigned long ioba,unsigned long * tce_ret)225 static inline long plpar_tce_get(unsigned long liobn, unsigned long ioba,
226 unsigned long *tce_ret)
227 {
228 long rc;
229 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
230
231 rc = plpar_hcall(H_GET_TCE, retbuf, liobn, ioba);
232
233 *tce_ret = retbuf[0];
234
235 return rc;
236 }
237
plpar_tce_put(unsigned long liobn,unsigned long ioba,unsigned long tceval)238 static inline long plpar_tce_put(unsigned long liobn, unsigned long ioba,
239 unsigned long tceval)
240 {
241 return plpar_hcall_norets(H_PUT_TCE, liobn, ioba, tceval);
242 }
243
plpar_tce_put_indirect(unsigned long liobn,unsigned long ioba,unsigned long page,unsigned long count)244 static inline long plpar_tce_put_indirect(unsigned long liobn,
245 unsigned long ioba, unsigned long page, unsigned long count)
246 {
247 return plpar_hcall_norets(H_PUT_TCE_INDIRECT, liobn, ioba, page, count);
248 }
249
plpar_tce_stuff(unsigned long liobn,unsigned long ioba,unsigned long tceval,unsigned long count)250 static inline long plpar_tce_stuff(unsigned long liobn, unsigned long ioba,
251 unsigned long tceval, unsigned long count)
252 {
253 return plpar_hcall_norets(H_STUFF_TCE, liobn, ioba, tceval, count);
254 }
255
256 /* Set various resource mode parameters */
plpar_set_mode(unsigned long mflags,unsigned long resource,unsigned long value1,unsigned long value2)257 static inline long plpar_set_mode(unsigned long mflags, unsigned long resource,
258 unsigned long value1, unsigned long value2)
259 {
260 return plpar_hcall_norets(H_SET_MODE, mflags, resource, value1, value2);
261 }
262
263 /*
264 * Enable relocation on exceptions on this partition
265 *
266 * Note: this call has a partition wide scope and can take a while to complete.
267 * If it returns H_LONG_BUSY_* it should be retried periodically until it
268 * returns H_SUCCESS.
269 */
enable_reloc_on_exceptions(void)270 static inline long enable_reloc_on_exceptions(void)
271 {
272 /* mflags = 3: Exceptions at 0xC000000000004000 */
273 return plpar_set_mode(3, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0);
274 }
275
276 /*
277 * Disable relocation on exceptions on this partition
278 *
279 * Note: this call has a partition wide scope and can take a while to complete.
280 * If it returns H_LONG_BUSY_* it should be retried periodically until it
281 * returns H_SUCCESS.
282 */
disable_reloc_on_exceptions(void)283 static inline long disable_reloc_on_exceptions(void) {
284 return plpar_set_mode(0, H_SET_MODE_RESOURCE_ADDR_TRANS_MODE, 0, 0);
285 }
286
287 /*
288 * Take exceptions in big endian mode on this partition
289 *
290 * Note: this call has a partition wide scope and can take a while to complete.
291 * If it returns H_LONG_BUSY_* it should be retried periodically until it
292 * returns H_SUCCESS.
293 */
enable_big_endian_exceptions(void)294 static inline long enable_big_endian_exceptions(void)
295 {
296 /* mflags = 0: big endian exceptions */
297 return plpar_set_mode(0, H_SET_MODE_RESOURCE_LE, 0, 0);
298 }
299
300 /*
301 * Take exceptions in little endian mode on this partition
302 *
303 * Note: this call has a partition wide scope and can take a while to complete.
304 * If it returns H_LONG_BUSY_* it should be retried periodically until it
305 * returns H_SUCCESS.
306 */
enable_little_endian_exceptions(void)307 static inline long enable_little_endian_exceptions(void)
308 {
309 /* mflags = 1: little endian exceptions */
310 return plpar_set_mode(1, H_SET_MODE_RESOURCE_LE, 0, 0);
311 }
312
plpar_set_ciabr(unsigned long ciabr)313 static inline long plpar_set_ciabr(unsigned long ciabr)
314 {
315 return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_CIABR, ciabr, 0);
316 }
317
plpar_set_watchpoint0(unsigned long dawr0,unsigned long dawrx0)318 static inline long plpar_set_watchpoint0(unsigned long dawr0, unsigned long dawrx0)
319 {
320 return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_DAWR0, dawr0, dawrx0);
321 }
322
plpar_set_watchpoint1(unsigned long dawr1,unsigned long dawrx1)323 static inline long plpar_set_watchpoint1(unsigned long dawr1, unsigned long dawrx1)
324 {
325 return plpar_set_mode(0, H_SET_MODE_RESOURCE_SET_DAWR1, dawr1, dawrx1);
326 }
327
plpar_signal_sys_reset(long cpu)328 static inline long plpar_signal_sys_reset(long cpu)
329 {
330 return plpar_hcall_norets(H_SIGNAL_SYS_RESET, cpu);
331 }
332
plpar_get_cpu_characteristics(struct h_cpu_char_result * p)333 static inline long plpar_get_cpu_characteristics(struct h_cpu_char_result *p)
334 {
335 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
336 long rc;
337
338 rc = plpar_hcall(H_GET_CPU_CHARACTERISTICS, retbuf);
339 if (rc == H_SUCCESS) {
340 p->character = retbuf[0];
341 p->behaviour = retbuf[1];
342 }
343
344 return rc;
345 }
346
plpar_guest_create(unsigned long flags,unsigned long * guest_id)347 static inline long plpar_guest_create(unsigned long flags, unsigned long *guest_id)
348 {
349 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
350 unsigned long token;
351 long rc;
352
353 token = -1UL;
354 do {
355 rc = plpar_hcall(H_GUEST_CREATE, retbuf, flags, token);
356 if (rc == H_SUCCESS)
357 *guest_id = retbuf[0];
358
359 if (rc == H_BUSY) {
360 token = retbuf[0];
361 cond_resched();
362 }
363
364 if (H_IS_LONG_BUSY(rc)) {
365 token = retbuf[0];
366 msleep(get_longbusy_msecs(rc));
367 rc = H_BUSY;
368 }
369
370 } while (rc == H_BUSY);
371
372 return rc;
373 }
374
plpar_guest_create_vcpu(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id)375 static inline long plpar_guest_create_vcpu(unsigned long flags,
376 unsigned long guest_id,
377 unsigned long vcpu_id)
378 {
379 long rc;
380
381 do {
382 rc = plpar_hcall_norets(H_GUEST_CREATE_VCPU, 0, guest_id, vcpu_id);
383
384 if (rc == H_BUSY)
385 cond_resched();
386
387 if (H_IS_LONG_BUSY(rc)) {
388 msleep(get_longbusy_msecs(rc));
389 rc = H_BUSY;
390 }
391
392 } while (rc == H_BUSY);
393
394 return rc;
395 }
396
plpar_guest_set_state(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,unsigned long data_buffer,unsigned long data_size,unsigned long * failed_index)397 static inline long plpar_guest_set_state(unsigned long flags,
398 unsigned long guest_id,
399 unsigned long vcpu_id,
400 unsigned long data_buffer,
401 unsigned long data_size,
402 unsigned long *failed_index)
403 {
404 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
405 long rc;
406
407 while (true) {
408 rc = plpar_hcall(H_GUEST_SET_STATE, retbuf, flags, guest_id,
409 vcpu_id, data_buffer, data_size);
410
411 if (rc == H_BUSY) {
412 cpu_relax();
413 continue;
414 }
415
416 if (H_IS_LONG_BUSY(rc)) {
417 mdelay(get_longbusy_msecs(rc));
418 continue;
419 }
420
421 if (rc == H_INVALID_ELEMENT_ID)
422 *failed_index = retbuf[0];
423 else if (rc == H_INVALID_ELEMENT_SIZE)
424 *failed_index = retbuf[0];
425 else if (rc == H_INVALID_ELEMENT_VALUE)
426 *failed_index = retbuf[0];
427
428 break;
429 }
430
431 return rc;
432 }
433
plpar_guest_get_state(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,unsigned long data_buffer,unsigned long data_size,unsigned long * failed_index)434 static inline long plpar_guest_get_state(unsigned long flags,
435 unsigned long guest_id,
436 unsigned long vcpu_id,
437 unsigned long data_buffer,
438 unsigned long data_size,
439 unsigned long *failed_index)
440 {
441 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
442 long rc;
443
444 while (true) {
445 rc = plpar_hcall(H_GUEST_GET_STATE, retbuf, flags, guest_id,
446 vcpu_id, data_buffer, data_size);
447
448 if (rc == H_BUSY) {
449 cpu_relax();
450 continue;
451 }
452
453 if (H_IS_LONG_BUSY(rc)) {
454 mdelay(get_longbusy_msecs(rc));
455 continue;
456 }
457
458 if (rc == H_INVALID_ELEMENT_ID)
459 *failed_index = retbuf[0];
460 else if (rc == H_INVALID_ELEMENT_SIZE)
461 *failed_index = retbuf[0];
462 else if (rc == H_INVALID_ELEMENT_VALUE)
463 *failed_index = retbuf[0];
464
465 break;
466 }
467
468 return rc;
469 }
470
plpar_guest_run_vcpu(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,int * trap,unsigned long * failed_index)471 static inline long plpar_guest_run_vcpu(unsigned long flags, unsigned long guest_id,
472 unsigned long vcpu_id, int *trap,
473 unsigned long *failed_index)
474 {
475 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
476 long rc;
477
478 rc = plpar_hcall(H_GUEST_RUN_VCPU, retbuf, flags, guest_id, vcpu_id);
479 if (rc == H_SUCCESS)
480 *trap = retbuf[0];
481 else if (rc == H_INVALID_ELEMENT_ID)
482 *failed_index = retbuf[0];
483 else if (rc == H_INVALID_ELEMENT_SIZE)
484 *failed_index = retbuf[0];
485 else if (rc == H_INVALID_ELEMENT_VALUE)
486 *failed_index = retbuf[0];
487
488 return rc;
489 }
490
plpar_guest_delete(unsigned long flags,u64 guest_id)491 static inline long plpar_guest_delete(unsigned long flags, u64 guest_id)
492 {
493 long rc;
494
495 do {
496 rc = plpar_hcall_norets(H_GUEST_DELETE, flags, guest_id);
497 if (rc == H_BUSY)
498 cond_resched();
499
500 if (H_IS_LONG_BUSY(rc)) {
501 msleep(get_longbusy_msecs(rc));
502 rc = H_BUSY;
503 }
504
505 } while (rc == H_BUSY);
506
507 return rc;
508 }
509
plpar_guest_set_capabilities(unsigned long flags,unsigned long capabilities)510 static inline long plpar_guest_set_capabilities(unsigned long flags,
511 unsigned long capabilities)
512 {
513 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
514 long rc;
515
516 do {
517 rc = plpar_hcall(H_GUEST_SET_CAPABILITIES, retbuf, flags, capabilities);
518 if (rc == H_BUSY)
519 cond_resched();
520
521 if (H_IS_LONG_BUSY(rc)) {
522 msleep(get_longbusy_msecs(rc));
523 rc = H_BUSY;
524 }
525 } while (rc == H_BUSY);
526
527 return rc;
528 }
529
plpar_guest_get_capabilities(unsigned long flags,unsigned long * capabilities)530 static inline long plpar_guest_get_capabilities(unsigned long flags,
531 unsigned long *capabilities)
532 {
533 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
534 long rc;
535
536 do {
537 rc = plpar_hcall(H_GUEST_GET_CAPABILITIES, retbuf, flags);
538 if (rc == H_BUSY)
539 cond_resched();
540
541 if (H_IS_LONG_BUSY(rc)) {
542 msleep(get_longbusy_msecs(rc));
543 rc = H_BUSY;
544 }
545 } while (rc == H_BUSY);
546
547 if (rc == H_SUCCESS)
548 *capabilities = retbuf[0];
549
550 return rc;
551 }
552
553 /*
554 * Wrapper to H_RPT_INVALIDATE hcall that handles return values appropriately
555 *
556 * - Returns H_SUCCESS on success
557 * - For H_BUSY return value, we retry the hcall.
558 * - For any other hcall failures, attempt a full flush once before
559 * resorting to BUG().
560 *
561 * Note: This hcall is expected to fail only very rarely. The correct
562 * error recovery of killing the process/guest will be eventually
563 * needed.
564 */
pseries_rpt_invalidate(u64 pid,u64 target,u64 type,u64 page_sizes,u64 start,u64 end)565 static inline long pseries_rpt_invalidate(u64 pid, u64 target, u64 type,
566 u64 page_sizes, u64 start, u64 end)
567 {
568 long rc;
569 unsigned long all;
570
571 while (true) {
572 rc = plpar_hcall_norets(H_RPT_INVALIDATE, pid, target, type,
573 page_sizes, start, end);
574 if (rc == H_BUSY) {
575 cpu_relax();
576 continue;
577 } else if (rc == H_SUCCESS)
578 return rc;
579
580 /* Flush request failed, try with a full flush once */
581 if (type & H_RPTI_TYPE_NESTED)
582 all = H_RPTI_TYPE_NESTED | H_RPTI_TYPE_NESTED_ALL;
583 else
584 all = H_RPTI_TYPE_ALL;
585 retry:
586 rc = plpar_hcall_norets(H_RPT_INVALIDATE, pid, target,
587 all, page_sizes, 0, -1UL);
588 if (rc == H_BUSY) {
589 cpu_relax();
590 goto retry;
591 } else if (rc == H_SUCCESS)
592 return rc;
593
594 BUG();
595 }
596 }
597
598 #else /* !CONFIG_PPC_PSERIES */
599
plpar_set_ciabr(unsigned long ciabr)600 static inline long plpar_set_ciabr(unsigned long ciabr)
601 {
602 return 0;
603 }
604
plpar_pte_read_4(unsigned long flags,unsigned long ptex,unsigned long * ptes)605 static inline long plpar_pte_read_4(unsigned long flags, unsigned long ptex,
606 unsigned long *ptes)
607 {
608 return 0;
609 }
610
pseries_rpt_invalidate(u64 pid,u64 target,u64 type,u64 page_sizes,u64 start,u64 end)611 static inline long pseries_rpt_invalidate(u64 pid, u64 target, u64 type,
612 u64 page_sizes, u64 start, u64 end)
613 {
614 return 0;
615 }
616
plpar_guest_create_vcpu(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id)617 static inline long plpar_guest_create_vcpu(unsigned long flags,
618 unsigned long guest_id,
619 unsigned long vcpu_id)
620 {
621 return 0;
622 }
623
plpar_guest_get_state(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,unsigned long data_buffer,unsigned long data_size,unsigned long * failed_index)624 static inline long plpar_guest_get_state(unsigned long flags,
625 unsigned long guest_id,
626 unsigned long vcpu_id,
627 unsigned long data_buffer,
628 unsigned long data_size,
629 unsigned long *failed_index)
630 {
631 return 0;
632 }
633
plpar_guest_set_state(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,unsigned long data_buffer,unsigned long data_size,unsigned long * failed_index)634 static inline long plpar_guest_set_state(unsigned long flags,
635 unsigned long guest_id,
636 unsigned long vcpu_id,
637 unsigned long data_buffer,
638 unsigned long data_size,
639 unsigned long *failed_index)
640 {
641 return 0;
642 }
643
plpar_guest_run_vcpu(unsigned long flags,unsigned long guest_id,unsigned long vcpu_id,int * trap,unsigned long * failed_index)644 static inline long plpar_guest_run_vcpu(unsigned long flags, unsigned long guest_id,
645 unsigned long vcpu_id, int *trap,
646 unsigned long *failed_index)
647 {
648 return 0;
649 }
650
plpar_guest_create(unsigned long flags,unsigned long * guest_id)651 static inline long plpar_guest_create(unsigned long flags, unsigned long *guest_id)
652 {
653 return 0;
654 }
655
plpar_guest_delete(unsigned long flags,u64 guest_id)656 static inline long plpar_guest_delete(unsigned long flags, u64 guest_id)
657 {
658 return 0;
659 }
660
plpar_guest_get_capabilities(unsigned long flags,unsigned long * capabilities)661 static inline long plpar_guest_get_capabilities(unsigned long flags,
662 unsigned long *capabilities)
663 {
664 return 0;
665 }
666
plpar_guest_set_capabilities(unsigned long flags,unsigned long capabilities)667 static inline long plpar_guest_set_capabilities(unsigned long flags,
668 unsigned long capabilities)
669 {
670 return 0;
671 }
672
673 #endif /* CONFIG_PPC_PSERIES */
674
675 #endif /* _ASM_POWERPC_PLPAR_WRAPPERS_H */
676