arch/powerpc/kvm/book3s_hv_rm_xics.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2012 Michael Ellerman, IBM Corporation.
   4  * Copyright 2012 Benjamin Herrenschmidt, IBM Corporation
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/kvm_host.h>
   9 #include <linux/err.h>
  10 #include <linux/kernel_stat.h>
  11 #include <linux/pgtable.h>
  12
  13 #include <asm/kvm_book3s.h>
  14 #include <asm/kvm_ppc.h>
  15 #include <asm/hvcall.h>
  16 #include <asm/xics.h>
  17 #include <asm/synch.h>
  18 #include <asm/cputhreads.h>
  19 #include <asm/ppc-opcode.h>
  20 #include <asm/pnv-pci.h>
  21 #include <asm/opal.h>
  22 #include <asm/smp.h>
  23
  24 #include "book3s_xics.h"
  25
  26 #define DEBUG_PASSUP
  27
  28 int h_ipi_redirect = 1;
  29 EXPORT_SYMBOL(h_ipi_redirect);
  30 int kvm_irq_bypass = 1;
  31 EXPORT_SYMBOL(kvm_irq_bypass);
  32
  33 static void icp_rm_deliver_irq(struct kvmppc_xics *xics, struct kvmppc_icp *icp,
  34                             u32 new_irq, bool check_resend);
  35 static int xics_opal_set_server(unsigned int hw_irq, int server_cpu);
  36
  37 /* -- ICS routines -- */
  38 static void ics_rm_check_resend(struct kvmppc_xics *xics,
  39                                 struct kvmppc_ics *ics, struct kvmppc_icp *icp)
  40 {
  41         int i;
  42
  43         for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
  44                 struct ics_irq_state *state = &ics->irq_state[i];
  45                 if (state->resend)
  46                         icp_rm_deliver_irq(xics, icp, state->number, true);
  47         }
  48
  49 }
  50
  51 /* -- ICP routines -- */
  52
  53 #ifdef CONFIG_SMP
  54 static inline void icp_send_hcore_msg(int hcore, struct kvm_vcpu *vcpu)
  55 {
  56         int hcpu;
  57
  58         hcpu = hcore << threads_shift;
  59         kvmppc_host_rm_ops_hv->rm_core[hcore].rm_data = vcpu;
  60         smp_muxed_ipi_set_message(hcpu, PPC_MSG_RM_HOST_ACTION);
  61         kvmppc_set_host_ipi(hcpu);
  62         smp_mb();
  63         kvmhv_rm_send_ipi(hcpu);
  64 }
  65 #else
  66 static inline void icp_send_hcore_msg(int hcore, struct kvm_vcpu *vcpu) { }
  67 #endif
  68
  69 /*
  70  * We start the search from our current CPU Id in the core map
  71  * and go in a circle until we get back to our ID looking for a
  72  * core that is running in host context and that hasn't already
  73  * been targeted for another rm_host_ops.
  74  *
  75  * In the future, could consider using a fairer algorithm (one
  76  * that distributes the IPIs better)
  77  *
  78  * Returns -1, if no CPU could be found in the host
  79  * Else, returns a CPU Id which has been reserved for use
  80  */
  81 static inline int grab_next_hostcore(int start,
  82                 struct kvmppc_host_rm_core *rm_core, int max, int action)
  83 {
  84         bool success;
  85         int core;
  86         union kvmppc_rm_state old, new;
  87
  88         for (core = start + 1; core < max; core++)  {
  89                 old = new = READ_ONCE(rm_core[core].rm_state);
  90
  91                 if (!old.in_host || old.rm_action)
  92                         continue;
  93
  94                 /* Try to grab this host core if not taken already. */
  95                 new.rm_action = action;
  96
  97                 success = cmpxchg64(&rm_core[core].rm_state.raw,
  98                                                 old.raw, new.raw) == old.raw;
  99                 if (success) {
 100                         /*
 101                          * Make sure that the store to the rm_action is made
 102                          * visible before we return to caller (and the
 103                          * subsequent store to rm_data) to synchronize with
 104                          * the IPI handler.
 105                          */
 106                         smp_wmb();
 107                         return core;
 108                 }
 109         }
 110
 111         return -1;
 112 }
 113
 114 static inline int find_available_hostcore(int action)
 115 {
 116         int core;
 117         int my_core = smp_processor_id() >> threads_shift;
 118         struct kvmppc_host_rm_core *rm_core = kvmppc_host_rm_ops_hv->rm_core;
 119
 120         core = grab_next_hostcore(my_core, rm_core, cpu_nr_cores(), action);
 121         if (core == -1)
 122                 core = grab_next_hostcore(core, rm_core, my_core, action);
 123
 124         return core;
 125 }
 126
 127 static void icp_rm_set_vcpu_irq(struct kvm_vcpu *vcpu,
 128                                 struct kvm_vcpu *this_vcpu)
 129 {
 130         struct kvmppc_icp *this_icp = this_vcpu->arch.icp;
 131         int cpu;
 132         int hcore;
 133
 134         /* Mark the target VCPU as having an interrupt pending */
 135         vcpu->stat.queue_intr++;
 136         set_bit(BOOK3S_IRQPRIO_EXTERNAL, &vcpu->arch.pending_exceptions);
 137
 138         /* Kick self ? Just set MER and return */
 139         if (vcpu == this_vcpu) {
 140                 mtspr(SPRN_LPCR, mfspr(SPRN_LPCR) | LPCR_MER);
 141                 return;
 142         }
 143
 144         /*
 145          * Check if the core is loaded,
 146          * if not, find an available host core to post to wake the VCPU,
 147          * if we can't find one, set up state to eventually return too hard.
 148          */
 149         cpu = vcpu->arch.thread_cpu;
 150         if (cpu < 0 || cpu >= nr_cpu_ids) {
 151                 hcore = -1;
 152                 if (kvmppc_host_rm_ops_hv && h_ipi_redirect)
 153                         hcore = find_available_hostcore(XICS_RM_KICK_VCPU);
 154                 if (hcore != -1) {
 155                         icp_send_hcore_msg(hcore, vcpu);
 156                 } else {
 157                         this_icp->rm_action |= XICS_RM_KICK_VCPU;
 158                         this_icp->rm_kick_target = vcpu;
 159                 }
 160                 return;
 161         }
 162
 163         smp_mb();
 164         kvmhv_rm_send_ipi(cpu);
 165 }
 166
 167 static void icp_rm_clr_vcpu_irq(struct kvm_vcpu *vcpu)
 168 {
 169         /* Note: Only called on self ! */
 170         clear_bit(BOOK3S_IRQPRIO_EXTERNAL, &vcpu->arch.pending_exceptions);
 171         mtspr(SPRN_LPCR, mfspr(SPRN_LPCR) & ~LPCR_MER);
 172 }
 173
 174 static inline bool icp_rm_try_update(struct kvmppc_icp *icp,
 175                                      union kvmppc_icp_state old,
 176                                      union kvmppc_icp_state new)
 177 {
 178         struct kvm_vcpu *this_vcpu = local_paca->kvm_hstate.kvm_vcpu;
 179         bool success;
 180
 181         /* Calculate new output value */
 182         new.out_ee = (new.xisr && (new.pending_pri < new.cppr));
 183
 184         /* Attempt atomic update */
 185         success = cmpxchg64(&icp->state.raw, old.raw, new.raw) == old.raw;
 186         if (!success)
 187                 goto bail;
 188
 189         /*
 190          * Check for output state update
 191          *
 192          * Note that this is racy since another processor could be updating
 193          * the state already. This is why we never clear the interrupt output
 194          * here, we only ever set it. The clear only happens prior to doing
 195          * an update and only by the processor itself. Currently we do it
 196          * in Accept (H_XIRR) and Up_Cppr (H_XPPR).
 197          *
 198          * We also do not try to figure out whether the EE state has changed,
 199          * we unconditionally set it if the new state calls for it. The reason
 200          * for that is that we opportunistically remove the pending interrupt
 201          * flag when raising CPPR, so we need to set it back here if an
 202          * interrupt is still pending.
 203          */
 204         if (new.out_ee)
 205                 icp_rm_set_vcpu_irq(icp->vcpu, this_vcpu);
 206
 207         /* Expose the state change for debug purposes */
 208         this_vcpu->arch.icp->rm_dbgstate = new;
 209         this_vcpu->arch.icp->rm_dbgtgt = icp->vcpu;
 210
 211  bail:
 212         return success;
 213 }
 214
 215 static inline int check_too_hard(struct kvmppc_xics *xics,
 216                                  struct kvmppc_icp *icp)
 217 {
 218         return (xics->real_mode_dbg || icp->rm_action) ? H_TOO_HARD : H_SUCCESS;
 219 }
 220
 221 static void icp_rm_check_resend(struct kvmppc_xics *xics,
 222                              struct kvmppc_icp *icp)
 223 {
 224         u32 icsid;
 225
 226         /* Order this load with the test for need_resend in the caller */
 227         smp_rmb();
 228         for_each_set_bit(icsid, icp->resend_map, xics->max_icsid + 1) {
 229                 struct kvmppc_ics *ics = xics->ics[icsid];
 230
 231                 if (!test_and_clear_bit(icsid, icp->resend_map))
 232                         continue;
 233                 if (!ics)
 234                         continue;
 235                 ics_rm_check_resend(xics, ics, icp);
 236         }
 237 }
 238
 239 static bool icp_rm_try_to_deliver(struct kvmppc_icp *icp, u32 irq, u8 priority,
 240                                u32 *reject)
 241 {
 242         union kvmppc_icp_state old_state, new_state;
 243         bool success;
 244
 245         do {
 246                 old_state = new_state = READ_ONCE(icp->state);
 247
 248                 *reject = 0;
 249
 250                 /* See if we can deliver */
 251                 success = new_state.cppr > priority &&
 252                         new_state.mfrr > priority &&
 253                         new_state.pending_pri > priority;
 254
 255                 /*
 256                  * If we can, check for a rejection and perform the
 257                  * delivery
 258                  */
 259                 if (success) {
 260                         *reject = new_state.xisr;
 261                         new_state.xisr = irq;
 262                         new_state.pending_pri = priority;
 263                 } else {
 264                         /*
 265                          * If we failed to deliver we set need_resend
 266                          * so a subsequent CPPR state change causes us
 267                          * to try a new delivery.
 268                          */
 269                         new_state.need_resend = true;
 270                 }
 271
 272         } while (!icp_rm_try_update(icp, old_state, new_state));
 273
 274         return success;
 275 }
 276
 277 static void icp_rm_deliver_irq(struct kvmppc_xics *xics, struct kvmppc_icp *icp,
 278                             u32 new_irq, bool check_resend)
 279 {
 280         struct ics_irq_state *state;
 281         struct kvmppc_ics *ics;
 282         u32 reject;
 283         u16 src;
 284
 285         /*
 286          * This is used both for initial delivery of an interrupt and
 287          * for subsequent rejection.
 288          *
 289          * Rejection can be racy vs. resends. We have evaluated the
 290          * rejection in an atomic ICP transaction which is now complete,
 291          * so potentially the ICP can already accept the interrupt again.
 292          *
 293          * So we need to retry the delivery. Essentially the reject path
 294          * boils down to a failed delivery. Always.
 295          *
 296          * Now the interrupt could also have moved to a different target,
 297          * thus we may need to re-do the ICP lookup as well
 298          */
 299
 300  again:
 301         /* Get the ICS state and lock it */
 302         ics = kvmppc_xics_find_ics(xics, new_irq, &src);
 303         if (!ics) {
 304                 /* Unsafe increment, but this does not need to be accurate */
 305                 xics->err_noics++;
 306                 return;
 307         }
 308         state = &ics->irq_state[src];
 309
 310         /* Get a lock on the ICS */
 311         arch_spin_lock(&ics->lock);
 312
 313         /* Get our server */
 314         if (!icp || state->server != icp->server_num) {
 315                 icp = kvmppc_xics_find_server(xics->kvm, state->server);
 316                 if (!icp) {
 317                         /* Unsafe increment again*/
 318                         xics->err_noicp++;
 319                         goto out;
 320                 }
 321         }
 322
 323         if (check_resend)
 324                 if (!state->resend)
 325                         goto out;
 326
 327         /* Clear the resend bit of that interrupt */
 328         state->resend = 0;
 329
 330         /*
 331          * If masked, bail out
 332          *
 333          * Note: PAPR doesn't mention anything about masked pending
 334          * when doing a resend, only when doing a delivery.
 335          *
 336          * However that would have the effect of losing a masked
 337          * interrupt that was rejected and isn't consistent with
 338          * the whole masked_pending business which is about not
 339          * losing interrupts that occur while masked.
 340          *
 341          * I don't differentiate normal deliveries and resends, this
 342          * implementation will differ from PAPR and not lose such
 343          * interrupts.
 344          */
 345         if (state->priority == MASKED) {
 346                 state->masked_pending = 1;
 347                 goto out;
 348         }
 349
 350         /*
 351          * Try the delivery, this will set the need_resend flag
 352          * in the ICP as part of the atomic transaction if the
 353          * delivery is not possible.
 354          *
 355          * Note that if successful, the new delivery might have itself
 356          * rejected an interrupt that was "delivered" before we took the
 357          * ics spin lock.
 358          *
 359          * In this case we do the whole sequence all over again for the
 360          * new guy. We cannot assume that the rejected interrupt is less
 361          * favored than the new one, and thus doesn't need to be delivered,
 362          * because by the time we exit icp_rm_try_to_deliver() the target
 363          * processor may well have already consumed & completed it, and thus
 364          * the rejected interrupt might actually be already acceptable.
 365          */
 366         if (icp_rm_try_to_deliver(icp, new_irq, state->priority, &reject)) {
 367                 /*
 368                  * Delivery was successful, did we reject somebody else ?
 369                  */
 370                 if (reject && reject != XICS_IPI) {
 371                         arch_spin_unlock(&ics->lock);
 372                         icp->n_reject++;
 373                         new_irq = reject;
 374                         check_resend = 0;
 375                         goto again;
 376                 }
 377         } else {
 378                 /*
 379                  * We failed to deliver the interrupt we need to set the
 380                  * resend map bit and mark the ICS state as needing a resend
 381                  */
 382                 state->resend = 1;
 383
 384                 /*
 385                  * Make sure when checking resend, we don't miss the resend
 386                  * if resend_map bit is seen and cleared.
 387                  */
 388                 smp_wmb();
 389                 set_bit(ics->icsid, icp->resend_map);
 390
 391                 /*
 392                  * If the need_resend flag got cleared in the ICP some time
 393                  * between icp_rm_try_to_deliver() atomic update and now, then
 394                  * we know it might have missed the resend_map bit. So we
 395                  * retry
 396                  */
 397                 smp_mb();
 398                 if (!icp->state.need_resend) {
 399                         state->resend = 0;
 400                         arch_spin_unlock(&ics->lock);
 401                         check_resend = 0;
 402                         goto again;
 403                 }
 404         }
 405  out:
 406         arch_spin_unlock(&ics->lock);
 407 }
 408
 409 static void icp_rm_down_cppr(struct kvmppc_xics *xics, struct kvmppc_icp *icp,
 410                              u8 new_cppr)
 411 {
 412         union kvmppc_icp_state old_state, new_state;
 413         bool resend;
 414
 415         /*
 416          * This handles several related states in one operation:
 417          *
 418          * ICP State: Down_CPPR
 419          *
 420          * Load CPPR with new value and if the XISR is 0
 421          * then check for resends:
 422          *
 423          * ICP State: Resend
 424          *
 425          * If MFRR is more favored than CPPR, check for IPIs
 426          * and notify ICS of a potential resend. This is done
 427          * asynchronously (when used in real mode, we will have
 428          * to exit here).
 429          *
 430          * We do not handle the complete Check_IPI as documented
 431          * here. In the PAPR, this state will be used for both
 432          * Set_MFRR and Down_CPPR. However, we know that we aren't
 433          * changing the MFRR state here so we don't need to handle
 434          * the case of an MFRR causing a reject of a pending irq,
 435          * this will have been handled when the MFRR was set in the
 436          * first place.
 437          *
 438          * Thus we don't have to handle rejects, only resends.
 439          *
 440          * When implementing real mode for HV KVM, resend will lead to
 441          * a H_TOO_HARD return and the whole transaction will be handled
 442          * in virtual mode.
 443          */
 444         do {
 445                 old_state = new_state = READ_ONCE(icp->state);
 446
 447                 /* Down_CPPR */
 448                 new_state.cppr = new_cppr;
 449
 450                 /*
 451                  * Cut down Resend / Check_IPI / IPI
 452                  *
 453                  * The logic is that we cannot have a pending interrupt
 454                  * trumped by an IPI at this point (see above), so we
 455                  * know that either the pending interrupt is already an
 456                  * IPI (in which case we don't care to override it) or
 457                  * it's either more favored than us or non existent
 458                  */
 459                 if (new_state.mfrr < new_cppr &&
 460                     new_state.mfrr <= new_state.pending_pri) {
 461                         new_state.pending_pri = new_state.mfrr;
 462                         new_state.xisr = XICS_IPI;
 463                 }
 464
 465                 /* Latch/clear resend bit */
 466                 resend = new_state.need_resend;
 467                 new_state.need_resend = 0;
 468
 469         } while (!icp_rm_try_update(icp, old_state, new_state));
 470
 471         /*
 472          * Now handle resend checks. Those are asynchronous to the ICP
 473          * state update in HW (ie bus transactions) so we can handle them
 474          * separately here as well.
 475          */
 476         if (resend) {
 477                 icp->n_check_resend++;
 478                 icp_rm_check_resend(xics, icp);
 479         }
 480 }
 481
 482
 483 unsigned long xics_rm_h_xirr(struct kvm_vcpu *vcpu)
 484 {
 485         union kvmppc_icp_state old_state, new_state;
 486         struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
 487         struct kvmppc_icp *icp = vcpu->arch.icp;
 488         u32 xirr;
 489
 490         if (!xics || !xics->real_mode)
 491                 return H_TOO_HARD;
 492
 493         /* First clear the interrupt */
 494         icp_rm_clr_vcpu_irq(icp->vcpu);
 495
 496         /*
 497          * ICP State: Accept_Interrupt
 498          *
 499          * Return the pending interrupt (if any) along with the
 500          * current CPPR, then clear the XISR & set CPPR to the
 501          * pending priority
 502          */
 503         do {
 504                 old_state = new_state = READ_ONCE(icp->state);
 505
 506                 xirr = old_state.xisr | (((u32)old_state.cppr) << 24);
 507                 if (!old_state.xisr)
 508                         break;
 509                 new_state.cppr = new_state.pending_pri;
 510                 new_state.pending_pri = 0xff;
 511                 new_state.xisr = 0;
 512
 513         } while (!icp_rm_try_update(icp, old_state, new_state));
 514
 515         /* Return the result in GPR4 */
 516         vcpu->arch.regs.gpr[4] = xirr;
 517
 518         return check_too_hard(xics, icp);
 519 }
 520
 521 int xics_rm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,
 522                   unsigned long mfrr)
 523 {
 524         union kvmppc_icp_state old_state, new_state;
 525         struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
 526         struct kvmppc_icp *icp, *this_icp = vcpu->arch.icp;
 527         u32 reject;
 528         bool resend;
 529         bool local;
 530
 531         if (!xics || !xics->real_mode)
 532                 return H_TOO_HARD;
 533
 534         local = this_icp->server_num == server;
 535         if (local)
 536                 icp = this_icp;
 537         else
 538                 icp = kvmppc_xics_find_server(vcpu->kvm, server);
 539         if (!icp)
 540                 return H_PARAMETER;
 541
 542         /*
 543          * ICP state: Set_MFRR
 544          *
 545          * If the CPPR is more favored than the new MFRR, then
 546          * nothing needs to be done as there can be no XISR to
 547          * reject.
 548          *
 549          * ICP state: Check_IPI
 550          *
 551          * If the CPPR is less favored, then we might be replacing
 552          * an interrupt, and thus need to possibly reject it.
 553          *
 554          * ICP State: IPI
 555          *
 556          * Besides rejecting any pending interrupts, we also
 557          * update XISR and pending_pri to mark IPI as pending.
 558          *
 559          * PAPR does not describe this state, but if the MFRR is being
 560          * made less favored than its earlier value, there might be
 561          * a previously-rejected interrupt needing to be resent.
 562          * Ideally, we would want to resend only if
 563          *      prio(pending_interrupt) < mfrr &&
 564          *      prio(pending_interrupt) < cppr
 565          * where pending interrupt is the one that was rejected. But
 566          * we don't have that state, so we simply trigger a resend
 567          * whenever the MFRR is made less favored.
 568          */
 569         do {
 570                 old_state = new_state = READ_ONCE(icp->state);
 571
 572                 /* Set_MFRR */
 573                 new_state.mfrr = mfrr;
 574
 575                 /* Check_IPI */
 576                 reject = 0;
 577                 resend = false;
 578                 if (mfrr < new_state.cppr) {
 579                         /* Reject a pending interrupt if not an IPI */
 580                         if (mfrr <= new_state.pending_pri) {
 581                                 reject = new_state.xisr;
 582                                 new_state.pending_pri = mfrr;
 583                                 new_state.xisr = XICS_IPI;
 584                         }
 585                 }
 586
 587                 if (mfrr > old_state.mfrr) {
 588                         resend = new_state.need_resend;
 589                         new_state.need_resend = 0;
 590                 }
 591         } while (!icp_rm_try_update(icp, old_state, new_state));
 592
 593         /* Handle reject in real mode */
 594         if (reject && reject != XICS_IPI) {
 595                 this_icp->n_reject++;
 596                 icp_rm_deliver_irq(xics, icp, reject, false);
 597         }
 598
 599         /* Handle resends in real mode */
 600         if (resend) {
 601                 this_icp->n_check_resend++;
 602                 icp_rm_check_resend(xics, icp);
 603         }
 604
 605         return check_too_hard(xics, this_icp);
 606 }
 607
 608 int xics_rm_h_cppr(struct kvm_vcpu *vcpu, unsigned long cppr)
 609 {
 610         union kvmppc_icp_state old_state, new_state;
 611         struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
 612         struct kvmppc_icp *icp = vcpu->arch.icp;
 613         u32 reject;
 614
 615         if (!xics || !xics->real_mode)
 616                 return H_TOO_HARD;
 617
 618         /*
 619          * ICP State: Set_CPPR
 620          *
 621          * We can safely compare the new value with the current
 622          * value outside of the transaction as the CPPR is only
 623          * ever changed by the processor on itself
 624          */
 625         if (cppr > icp->state.cppr) {
 626                 icp_rm_down_cppr(xics, icp, cppr);
 627                 goto bail;
 628         } else if (cppr == icp->state.cppr)
 629                 return H_SUCCESS;
 630
 631         /*
 632          * ICP State: Up_CPPR
 633          *
 634          * The processor is raising its priority, this can result
 635          * in a rejection of a pending interrupt:
 636          *
 637          * ICP State: Reject_Current
 638          *
 639          * We can remove EE from the current processor, the update
 640          * transaction will set it again if needed
 641          */
 642         icp_rm_clr_vcpu_irq(icp->vcpu);
 643
 644         do {
 645                 old_state = new_state = READ_ONCE(icp->state);
 646
 647                 reject = 0;
 648                 new_state.cppr = cppr;
 649
 650                 if (cppr <= new_state.pending_pri) {
 651                         reject = new_state.xisr;
 652                         new_state.xisr = 0;
 653                         new_state.pending_pri = 0xff;
 654                 }
 655
 656         } while (!icp_rm_try_update(icp, old_state, new_state));
 657
 658         /*
 659          * Check for rejects. They are handled by doing a new delivery
 660          * attempt (see comments in icp_rm_deliver_irq).
 661          */
 662         if (reject && reject != XICS_IPI) {
 663                 icp->n_reject++;
 664                 icp_rm_deliver_irq(xics, icp, reject, false);
 665         }
 666  bail:
 667         return check_too_hard(xics, icp);
 668 }
 669
 670 static int ics_rm_eoi(struct kvm_vcpu *vcpu, u32 irq)
 671 {
 672         struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
 673         struct kvmppc_icp *icp = vcpu->arch.icp;
 674         struct kvmppc_ics *ics;
 675         struct ics_irq_state *state;
 676         u16 src;
 677         u32 pq_old, pq_new;
 678
 679         /*
 680          * ICS EOI handling: For LSI, if P bit is still set, we need to
 681          * resend it.
 682          *
 683          * For MSI, we move Q bit into P (and clear Q). If it is set,
 684          * resend it.
 685          */
 686
 687         ics = kvmppc_xics_find_ics(xics, irq, &src);
 688         if (!ics)
 689                 goto bail;
 690
 691         state = &ics->irq_state[src];
 692
 693         if (state->lsi)
 694                 pq_new = state->pq_state;
 695         else
 696                 do {
 697                         pq_old = state->pq_state;
 698                         pq_new = pq_old >> 1;
 699                 } while (cmpxchg(&state->pq_state, pq_old, pq_new) != pq_old);
 700
 701         if (pq_new & PQ_PRESENTED)
 702                 icp_rm_deliver_irq(xics, NULL, irq, false);
 703
 704         if (!hlist_empty(&vcpu->kvm->irq_ack_notifier_list)) {
 705                 icp->rm_action |= XICS_RM_NOTIFY_EOI;
 706                 icp->rm_eoied_irq = irq;
 707         }
 708
 709         /* Handle passthrough interrupts */
 710         if (state->host_irq) {
 711                 ++vcpu->stat.pthru_all;
 712                 if (state->intr_cpu != -1) {
 713                         int pcpu = raw_smp_processor_id();
 714
 715                         pcpu = cpu_first_thread_sibling(pcpu);
 716                         ++vcpu->stat.pthru_host;
 717                         if (state->intr_cpu != pcpu) {
 718                                 ++vcpu->stat.pthru_bad_aff;
 719                                 xics_opal_set_server(state->host_irq, pcpu);
 720                         }
 721                         state->intr_cpu = -1;
 722                 }
 723         }
 724
 725  bail:
 726         return check_too_hard(xics, icp);
 727 }
 728
 729 int xics_rm_h_eoi(struct kvm_vcpu *vcpu, unsigned long xirr)
 730 {
 731         struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
 732         struct kvmppc_icp *icp = vcpu->arch.icp;
 733         u32 irq = xirr & 0x00ffffff;
 734
 735         if (!xics || !xics->real_mode)
 736                 return H_TOO_HARD;
 737
 738         /*
 739          * ICP State: EOI
 740          *
 741          * Note: If EOI is incorrectly used by SW to lower the CPPR
 742          * value (ie more favored), we do not check for rejection of
 743          * a pending interrupt, this is a SW error and PAPR specifies
 744          * that we don't have to deal with it.
 745          *
 746          * The sending of an EOI to the ICS is handled after the
 747          * CPPR update
 748          *
 749          * ICP State: Down_CPPR which we handle
 750          * in a separate function as it's shared with H_CPPR.
 751          */
 752         icp_rm_down_cppr(xics, icp, xirr >> 24);
 753
 754         /* IPIs have no EOI */
 755         if (irq == XICS_IPI)
 756                 return check_too_hard(xics, icp);
 757
 758         return ics_rm_eoi(vcpu, irq);
 759 }
 760
 761 static unsigned long eoi_rc;
 762
 763 static void icp_eoi(struct irq_data *d, u32 hwirq, __be32 xirr, bool *again)
 764 {
 765         void __iomem *xics_phys;
 766         int64_t rc;
 767
 768         rc = pnv_opal_pci_msi_eoi(d);
 769
 770         if (rc)
 771                 eoi_rc = rc;
 772
 773         iosync();
 774
 775         /* EOI it */
 776         xics_phys = local_paca->kvm_hstate.xics_phys;
 777         if (xics_phys) {
 778                 __raw_rm_writel(xirr, xics_phys + XICS_XIRR);
 779         } else {
 780                 rc = opal_int_eoi(be32_to_cpu(xirr));
 781                 *again = rc > 0;
 782         }
 783 }
 784
 785 static int xics_opal_set_server(unsigned int hw_irq, int server_cpu)
 786 {
 787         unsigned int mangle_cpu = get_hard_smp_processor_id(server_cpu) << 2;
 788
 789         return opal_set_xive(hw_irq, mangle_cpu, DEFAULT_PRIORITY);
 790 }
 791
 792 /*
 793  * Increment a per-CPU 32-bit unsigned integer variable.
 794  * Safe to call in real-mode. Handles vmalloc'ed addresses
 795  *
 796  * ToDo: Make this work for any integral type
 797  */
 798
 799 static inline void this_cpu_inc_rm(unsigned int __percpu *addr)
 800 {
 801         unsigned long l;
 802         unsigned int *raddr;
 803         int cpu = smp_processor_id();
 804
 805         raddr = per_cpu_ptr(addr, cpu);
 806         l = (unsigned long)raddr;
 807
 808         if (get_region_id(l) == VMALLOC_REGION_ID) {
 809                 l = vmalloc_to_phys(raddr);
 810                 raddr = (unsigned int *)l;
 811         }
 812         ++*raddr;
 813 }
 814
 815 /*
 816  * We don't try to update the flags in the irq_desc 'istate' field in
 817  * here as would happen in the normal IRQ handling path for several reasons:
 818  *  - state flags represent internal IRQ state and are not expected to be
 819  *    updated outside the IRQ subsystem
 820  *  - more importantly, these are useful for edge triggered interrupts,
 821  *    IRQ probing, etc., but we are only handling MSI/MSIx interrupts here
 822  *    and these states shouldn't apply to us.
 823  *
 824  * However, we do update irq_stats - we somewhat duplicate the code in
 825  * kstat_incr_irqs_this_cpu() for this since this function is defined
 826  * in irq/internal.h which we don't want to include here.
 827  * The only difference is that desc->kstat_irqs is an allocated per CPU
 828  * variable and could have been vmalloc'ed, so we can't directly
 829  * call __this_cpu_inc() on it. The kstat structure is a static
 830  * per CPU variable and it should be accessible by real-mode KVM.
 831  *
 832  */
 833 static void kvmppc_rm_handle_irq_desc(struct irq_desc *desc)
 834 {
 835         this_cpu_inc_rm(desc->kstat_irqs);
 836         __this_cpu_inc(kstat.irqs_sum);
 837 }
 838
 839 long kvmppc_deliver_irq_passthru(struct kvm_vcpu *vcpu,
 840                                  __be32 xirr,
 841                                  struct kvmppc_irq_map *irq_map,
 842                                  struct kvmppc_passthru_irqmap *pimap,
 843                                  bool *again)
 844 {
 845         struct kvmppc_xics *xics;
 846         struct kvmppc_icp *icp;
 847         struct kvmppc_ics *ics;
 848         struct ics_irq_state *state;
 849         u32 irq;
 850         u16 src;
 851         u32 pq_old, pq_new;
 852
 853         irq = irq_map->v_hwirq;
 854         xics = vcpu->kvm->arch.xics;
 855         icp = vcpu->arch.icp;
 856
 857         kvmppc_rm_handle_irq_desc(irq_map->desc);
 858
 859         ics = kvmppc_xics_find_ics(xics, irq, &src);
 860         if (!ics)
 861                 return 2;
 862
 863         state = &ics->irq_state[src];
 864
 865         /* only MSIs register bypass producers, so it must be MSI here */
 866         do {
 867                 pq_old = state->pq_state;
 868                 pq_new = ((pq_old << 1) & 3) | PQ_PRESENTED;
 869         } while (cmpxchg(&state->pq_state, pq_old, pq_new) != pq_old);
 870
 871         /* Test P=1, Q=0, this is the only case where we present */
 872         if (pq_new == PQ_PRESENTED)
 873                 icp_rm_deliver_irq(xics, icp, irq, false);
 874
 875         /* EOI the interrupt */
 876         icp_eoi(irq_desc_get_irq_data(irq_map->desc), irq_map->r_hwirq, xirr, again);
 877
 878         if (check_too_hard(xics, icp) == H_TOO_HARD)
 879                 return 2;
 880         else
 881                 return -2;
 882 }
 883
 884 /*  --- Non-real mode XICS-related built-in routines ---  */
 885
 886 /**
 887  * Host Operations poked by RM KVM
 888  */
 889 static void rm_host_ipi_action(int action, void *data)
 890 {
 891         switch (action) {
 892         case XICS_RM_KICK_VCPU:
 893                 kvmppc_host_rm_ops_hv->vcpu_kick(data);
 894                 break;
 895         default:
 896                 WARN(1, "Unexpected rm_action=%d data=%p\n", action, data);
 897                 break;
 898         }
 899
 900 }
 901
 902 void kvmppc_xics_ipi_action(void)
 903 {
 904         int core;
 905         unsigned int cpu = smp_processor_id();
 906         struct kvmppc_host_rm_core *rm_corep;
 907
 908         core = cpu >> threads_shift;
 909         rm_corep = &kvmppc_host_rm_ops_hv->rm_core[core];
 910
 911         if (rm_corep->rm_data) {
 912                 rm_host_ipi_action(rm_corep->rm_state.rm_action,
 913                                                         rm_corep->rm_data);
 914                 /* Order these stores against the real mode KVM */
 915                 rm_corep->rm_data = NULL;
 916                 smp_wmb();
 917                 rm_corep->rm_state.rm_action = 0;
 918         }
 919 }