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