GNU Linux-libre 5.15.72-gnu
[releases.git] / arch / powerpc / kvm / book3s_xive_template.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2017 Benjamin Herrenschmidt, IBM Corporation
4  */
5
6 /* File to be included by other .c files */
7
8 #define XGLUE(a,b) a##b
9 #define GLUE(a,b) XGLUE(a,b)
10
11 /* Dummy interrupt used when taking interrupts out of a queue in H_CPPR */
12 #define XICS_DUMMY      1
13
14 static void GLUE(X_PFX,ack_pending)(struct kvmppc_xive_vcpu *xc)
15 {
16         u8 cppr;
17         u16 ack;
18
19         /*
20          * Ensure any previous store to CPPR is ordered vs.
21          * the subsequent loads from PIPR or ACK.
22          */
23         eieio();
24
25         /* Perform the acknowledge OS to register cycle. */
26         ack = be16_to_cpu(__x_readw(__x_tima + TM_SPC_ACK_OS_REG));
27
28         /* Synchronize subsequent queue accesses */
29         mb();
30
31         /* XXX Check grouping level */
32
33         /* Anything ? */
34         if (!((ack >> 8) & TM_QW1_NSR_EO))
35                 return;
36
37         /* Grab CPPR of the most favored pending interrupt */
38         cppr = ack & 0xff;
39         if (cppr < 8)
40                 xc->pending |= 1 << cppr;
41
42 #ifdef XIVE_RUNTIME_CHECKS
43         /* Check consistency */
44         if (cppr >= xc->hw_cppr)
45                 pr_warn("KVM-XIVE: CPU %d odd ack CPPR, got %d at %d\n",
46                         smp_processor_id(), cppr, xc->hw_cppr);
47 #endif
48
49         /*
50          * Update our image of the HW CPPR. We don't yet modify
51          * xc->cppr, this will be done as we scan for interrupts
52          * in the queues.
53          */
54         xc->hw_cppr = cppr;
55 }
56
57 static u8 GLUE(X_PFX,esb_load)(struct xive_irq_data *xd, u32 offset)
58 {
59         u64 val;
60
61         if (offset == XIVE_ESB_SET_PQ_10 && xd->flags & XIVE_IRQ_FLAG_STORE_EOI)
62                 offset |= XIVE_ESB_LD_ST_MO;
63
64         val =__x_readq(__x_eoi_page(xd) + offset);
65 #ifdef __LITTLE_ENDIAN__
66         val >>= 64-8;
67 #endif
68         return (u8)val;
69 }
70
71
72 static void GLUE(X_PFX,source_eoi)(u32 hw_irq, struct xive_irq_data *xd)
73 {
74         /* If the XIVE supports the new "store EOI facility, use it */
75         if (xd->flags & XIVE_IRQ_FLAG_STORE_EOI)
76                 __x_writeq(0, __x_eoi_page(xd) + XIVE_ESB_STORE_EOI);
77         else if (xd->flags & XIVE_IRQ_FLAG_LSI) {
78                 /*
79                  * For LSIs the HW EOI cycle is used rather than PQ bits,
80                  * as they are automatically re-triggred in HW when still
81                  * pending.
82                  */
83                 __x_readq(__x_eoi_page(xd) + XIVE_ESB_LOAD_EOI);
84         } else {
85                 uint64_t eoi_val;
86
87                 /*
88                  * Otherwise for EOI, we use the special MMIO that does
89                  * a clear of both P and Q and returns the old Q,
90                  * except for LSIs where we use the "EOI cycle" special
91                  * load.
92                  *
93                  * This allows us to then do a re-trigger if Q was set
94                  * rather than synthetizing an interrupt in software
95                  */
96                 eoi_val = GLUE(X_PFX,esb_load)(xd, XIVE_ESB_SET_PQ_00);
97
98                 /* Re-trigger if needed */
99                 if ((eoi_val & 1) && __x_trig_page(xd))
100                         __x_writeq(0, __x_trig_page(xd));
101         }
102 }
103
104 enum {
105         scan_fetch,
106         scan_poll,
107         scan_eoi,
108 };
109
110 static u32 GLUE(X_PFX,scan_interrupts)(struct kvmppc_xive_vcpu *xc,
111                                        u8 pending, int scan_type)
112 {
113         u32 hirq = 0;
114         u8 prio = 0xff;
115
116         /* Find highest pending priority */
117         while ((xc->mfrr != 0xff || pending != 0) && hirq == 0) {
118                 struct xive_q *q;
119                 u32 idx, toggle;
120                 __be32 *qpage;
121
122                 /*
123                  * If pending is 0 this will return 0xff which is what
124                  * we want
125                  */
126                 prio = ffs(pending) - 1;
127
128                 /* Don't scan past the guest cppr */
129                 if (prio >= xc->cppr || prio > 7) {
130                         if (xc->mfrr < xc->cppr) {
131                                 prio = xc->mfrr;
132                                 hirq = XICS_IPI;
133                         }
134                         break;
135                 }
136
137                 /* Grab queue and pointers */
138                 q = &xc->queues[prio];
139                 idx = q->idx;
140                 toggle = q->toggle;
141
142                 /*
143                  * Snapshot the queue page. The test further down for EOI
144                  * must use the same "copy" that was used by __xive_read_eq
145                  * since qpage can be set concurrently and we don't want
146                  * to miss an EOI.
147                  */
148                 qpage = READ_ONCE(q->qpage);
149
150 skip_ipi:
151                 /*
152                  * Try to fetch from the queue. Will return 0 for a
153                  * non-queueing priority (ie, qpage = 0).
154                  */
155                 hirq = __xive_read_eq(qpage, q->msk, &idx, &toggle);
156
157                 /*
158                  * If this was a signal for an MFFR change done by
159                  * H_IPI we skip it. Additionally, if we were fetching
160                  * we EOI it now, thus re-enabling reception of a new
161                  * such signal.
162                  *
163                  * We also need to do that if prio is 0 and we had no
164                  * page for the queue. In this case, we have non-queued
165                  * IPI that needs to be EOId.
166                  *
167                  * This is safe because if we have another pending MFRR
168                  * change that wasn't observed above, the Q bit will have
169                  * been set and another occurrence of the IPI will trigger.
170                  */
171                 if (hirq == XICS_IPI || (prio == 0 && !qpage)) {
172                         if (scan_type == scan_fetch) {
173                                 GLUE(X_PFX,source_eoi)(xc->vp_ipi,
174                                                        &xc->vp_ipi_data);
175                                 q->idx = idx;
176                                 q->toggle = toggle;
177                         }
178                         /* Loop back on same queue with updated idx/toggle */
179 #ifdef XIVE_RUNTIME_CHECKS
180                         WARN_ON(hirq && hirq != XICS_IPI);
181 #endif
182                         if (hirq)
183                                 goto skip_ipi;
184                 }
185
186                 /* If it's the dummy interrupt, continue searching */
187                 if (hirq == XICS_DUMMY)
188                         goto skip_ipi;
189
190                 /* Clear the pending bit if the queue is now empty */
191                 if (!hirq) {
192                         pending &= ~(1 << prio);
193
194                         /*
195                          * Check if the queue count needs adjusting due to
196                          * interrupts being moved away.
197                          */
198                         if (atomic_read(&q->pending_count)) {
199                                 int p = atomic_xchg(&q->pending_count, 0);
200                                 if (p) {
201 #ifdef XIVE_RUNTIME_CHECKS
202                                         WARN_ON(p > atomic_read(&q->count));
203 #endif
204                                         atomic_sub(p, &q->count);
205                                 }
206                         }
207                 }
208
209                 /*
210                  * If the most favoured prio we found pending is less
211                  * favored (or equal) than a pending IPI, we return
212                  * the IPI instead.
213                  */
214                 if (prio >= xc->mfrr && xc->mfrr < xc->cppr) {
215                         prio = xc->mfrr;
216                         hirq = XICS_IPI;
217                         break;
218                 }
219
220                 /* If fetching, update queue pointers */
221                 if (scan_type == scan_fetch) {
222                         q->idx = idx;
223                         q->toggle = toggle;
224                 }
225         }
226
227         /* If we are just taking a "peek", do nothing else */
228         if (scan_type == scan_poll)
229                 return hirq;
230
231         /* Update the pending bits */
232         xc->pending = pending;
233
234         /*
235          * If this is an EOI that's it, no CPPR adjustment done here,
236          * all we needed was cleanup the stale pending bits and check
237          * if there's anything left.
238          */
239         if (scan_type == scan_eoi)
240                 return hirq;
241
242         /*
243          * If we found an interrupt, adjust what the guest CPPR should
244          * be as if we had just fetched that interrupt from HW.
245          *
246          * Note: This can only make xc->cppr smaller as the previous
247          * loop will only exit with hirq != 0 if prio is lower than
248          * the current xc->cppr. Thus we don't need to re-check xc->mfrr
249          * for pending IPIs.
250          */
251         if (hirq)
252                 xc->cppr = prio;
253         /*
254          * If it was an IPI the HW CPPR might have been lowered too much
255          * as the HW interrupt we use for IPIs is routed to priority 0.
256          *
257          * We re-sync it here.
258          */
259         if (xc->cppr != xc->hw_cppr) {
260                 xc->hw_cppr = xc->cppr;
261                 __x_writeb(xc->cppr, __x_tima + TM_QW1_OS + TM_CPPR);
262         }
263
264         return hirq;
265 }
266
267 X_STATIC unsigned long GLUE(X_PFX,h_xirr)(struct kvm_vcpu *vcpu)
268 {
269         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
270         u8 old_cppr;
271         u32 hirq;
272
273         pr_devel("H_XIRR\n");
274
275         xc->GLUE(X_STAT_PFX,h_xirr)++;
276
277         /* First collect pending bits from HW */
278         GLUE(X_PFX,ack_pending)(xc);
279
280         pr_devel(" new pending=0x%02x hw_cppr=%d cppr=%d\n",
281                  xc->pending, xc->hw_cppr, xc->cppr);
282
283         /* Grab previous CPPR and reverse map it */
284         old_cppr = xive_prio_to_guest(xc->cppr);
285
286         /* Scan for actual interrupts */
287         hirq = GLUE(X_PFX,scan_interrupts)(xc, xc->pending, scan_fetch);
288
289         pr_devel(" got hirq=0x%x hw_cppr=%d cppr=%d\n",
290                  hirq, xc->hw_cppr, xc->cppr);
291
292 #ifdef XIVE_RUNTIME_CHECKS
293         /* That should never hit */
294         if (hirq & 0xff000000)
295                 pr_warn("XIVE: Weird guest interrupt number 0x%08x\n", hirq);
296 #endif
297
298         /*
299          * XXX We could check if the interrupt is masked here and
300          * filter it. If we chose to do so, we would need to do:
301          *
302          *    if (masked) {
303          *        lock();
304          *        if (masked) {
305          *            old_Q = true;
306          *            hirq = 0;
307          *        }
308          *        unlock();
309          *    }
310          */
311
312         /* Return interrupt and old CPPR in GPR4 */
313         vcpu->arch.regs.gpr[4] = hirq | (old_cppr << 24);
314
315         return H_SUCCESS;
316 }
317
318 X_STATIC unsigned long GLUE(X_PFX,h_ipoll)(struct kvm_vcpu *vcpu, unsigned long server)
319 {
320         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
321         u8 pending = xc->pending;
322         u32 hirq;
323
324         pr_devel("H_IPOLL(server=%ld)\n", server);
325
326         xc->GLUE(X_STAT_PFX,h_ipoll)++;
327
328         /* Grab the target VCPU if not the current one */
329         if (xc->server_num != server) {
330                 vcpu = kvmppc_xive_find_server(vcpu->kvm, server);
331                 if (!vcpu)
332                         return H_PARAMETER;
333                 xc = vcpu->arch.xive_vcpu;
334
335                 /* Scan all priorities */
336                 pending = 0xff;
337         } else {
338                 /* Grab pending interrupt if any */
339                 __be64 qw1 = __x_readq(__x_tima + TM_QW1_OS);
340                 u8 pipr = be64_to_cpu(qw1) & 0xff;
341                 if (pipr < 8)
342                         pending |= 1 << pipr;
343         }
344
345         hirq = GLUE(X_PFX,scan_interrupts)(xc, pending, scan_poll);
346
347         /* Return interrupt and old CPPR in GPR4 */
348         vcpu->arch.regs.gpr[4] = hirq | (xc->cppr << 24);
349
350         return H_SUCCESS;
351 }
352
353 static void GLUE(X_PFX,push_pending_to_hw)(struct kvmppc_xive_vcpu *xc)
354 {
355         u8 pending, prio;
356
357         pending = xc->pending;
358         if (xc->mfrr != 0xff) {
359                 if (xc->mfrr < 8)
360                         pending |= 1 << xc->mfrr;
361                 else
362                         pending |= 0x80;
363         }
364         if (!pending)
365                 return;
366         prio = ffs(pending) - 1;
367
368         __x_writeb(prio, __x_tima + TM_SPC_SET_OS_PENDING);
369 }
370
371 static void GLUE(X_PFX,scan_for_rerouted_irqs)(struct kvmppc_xive *xive,
372                                                struct kvmppc_xive_vcpu *xc)
373 {
374         unsigned int prio;
375
376         /* For each priority that is now masked */
377         for (prio = xc->cppr; prio < KVMPPC_XIVE_Q_COUNT; prio++) {
378                 struct xive_q *q = &xc->queues[prio];
379                 struct kvmppc_xive_irq_state *state;
380                 struct kvmppc_xive_src_block *sb;
381                 u32 idx, toggle, entry, irq, hw_num;
382                 struct xive_irq_data *xd;
383                 __be32 *qpage;
384                 u16 src;
385
386                 idx = q->idx;
387                 toggle = q->toggle;
388                 qpage = READ_ONCE(q->qpage);
389                 if (!qpage)
390                         continue;
391
392                 /* For each interrupt in the queue */
393                 for (;;) {
394                         entry = be32_to_cpup(qpage + idx);
395
396                         /* No more ? */
397                         if ((entry >> 31) == toggle)
398                                 break;
399                         irq = entry & 0x7fffffff;
400
401                         /* Skip dummies and IPIs */
402                         if (irq == XICS_DUMMY || irq == XICS_IPI)
403                                 goto next;
404                         sb = kvmppc_xive_find_source(xive, irq, &src);
405                         if (!sb)
406                                 goto next;
407                         state = &sb->irq_state[src];
408
409                         /* Has it been rerouted ? */
410                         if (xc->server_num == state->act_server)
411                                 goto next;
412
413                         /*
414                          * Allright, it *has* been re-routed, kill it from
415                          * the queue.
416                          */
417                         qpage[idx] = cpu_to_be32((entry & 0x80000000) | XICS_DUMMY);
418
419                         /* Find the HW interrupt */
420                         kvmppc_xive_select_irq(state, &hw_num, &xd);
421
422                         /* If it's not an LSI, set PQ to 11 the EOI will force a resend */
423                         if (!(xd->flags & XIVE_IRQ_FLAG_LSI))
424                                 GLUE(X_PFX,esb_load)(xd, XIVE_ESB_SET_PQ_11);
425
426                         /* EOI the source */
427                         GLUE(X_PFX,source_eoi)(hw_num, xd);
428
429                 next:
430                         idx = (idx + 1) & q->msk;
431                         if (idx == 0)
432                                 toggle ^= 1;
433                 }
434         }
435 }
436
437 X_STATIC int GLUE(X_PFX,h_cppr)(struct kvm_vcpu *vcpu, unsigned long cppr)
438 {
439         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
440         struct kvmppc_xive *xive = vcpu->kvm->arch.xive;
441         u8 old_cppr;
442
443         pr_devel("H_CPPR(cppr=%ld)\n", cppr);
444
445         xc->GLUE(X_STAT_PFX,h_cppr)++;
446
447         /* Map CPPR */
448         cppr = xive_prio_from_guest(cppr);
449
450         /* Remember old and update SW state */
451         old_cppr = xc->cppr;
452         xc->cppr = cppr;
453
454         /*
455          * Order the above update of xc->cppr with the subsequent
456          * read of xc->mfrr inside push_pending_to_hw()
457          */
458         smp_mb();
459
460         if (cppr > old_cppr) {
461                 /*
462                  * We are masking less, we need to look for pending things
463                  * to deliver and set VP pending bits accordingly to trigger
464                  * a new interrupt otherwise we might miss MFRR changes for
465                  * which we have optimized out sending an IPI signal.
466                  */
467                 GLUE(X_PFX,push_pending_to_hw)(xc);
468         } else {
469                 /*
470                  * We are masking more, we need to check the queue for any
471                  * interrupt that has been routed to another CPU, take
472                  * it out (replace it with the dummy) and retrigger it.
473                  *
474                  * This is necessary since those interrupts may otherwise
475                  * never be processed, at least not until this CPU restores
476                  * its CPPR.
477                  *
478                  * This is in theory racy vs. HW adding new interrupts to
479                  * the queue. In practice this works because the interesting
480                  * cases are when the guest has done a set_xive() to move the
481                  * interrupt away, which flushes the xive, followed by the
482                  * target CPU doing a H_CPPR. So any new interrupt coming into
483                  * the queue must still be routed to us and isn't a source
484                  * of concern.
485                  */
486                 GLUE(X_PFX,scan_for_rerouted_irqs)(xive, xc);
487         }
488
489         /* Apply new CPPR */
490         xc->hw_cppr = cppr;
491         __x_writeb(cppr, __x_tima + TM_QW1_OS + TM_CPPR);
492
493         return H_SUCCESS;
494 }
495
496 X_STATIC int GLUE(X_PFX,h_eoi)(struct kvm_vcpu *vcpu, unsigned long xirr)
497 {
498         struct kvmppc_xive *xive = vcpu->kvm->arch.xive;
499         struct kvmppc_xive_src_block *sb;
500         struct kvmppc_xive_irq_state *state;
501         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
502         struct xive_irq_data *xd;
503         u8 new_cppr = xirr >> 24;
504         u32 irq = xirr & 0x00ffffff, hw_num;
505         u16 src;
506         int rc = 0;
507
508         pr_devel("H_EOI(xirr=%08lx)\n", xirr);
509
510         xc->GLUE(X_STAT_PFX,h_eoi)++;
511
512         xc->cppr = xive_prio_from_guest(new_cppr);
513
514         /*
515          * IPIs are synthetized from MFRR and thus don't need
516          * any special EOI handling. The underlying interrupt
517          * used to signal MFRR changes is EOId when fetched from
518          * the queue.
519          */
520         if (irq == XICS_IPI || irq == 0) {
521                 /*
522                  * This barrier orders the setting of xc->cppr vs.
523                  * subsquent test of xc->mfrr done inside
524                  * scan_interrupts and push_pending_to_hw
525                  */
526                 smp_mb();
527                 goto bail;
528         }
529
530         /* Find interrupt source */
531         sb = kvmppc_xive_find_source(xive, irq, &src);
532         if (!sb) {
533                 pr_devel(" source not found !\n");
534                 rc = H_PARAMETER;
535                 /* Same as above */
536                 smp_mb();
537                 goto bail;
538         }
539         state = &sb->irq_state[src];
540         kvmppc_xive_select_irq(state, &hw_num, &xd);
541
542         state->in_eoi = true;
543
544         /*
545          * This barrier orders both setting of in_eoi above vs,
546          * subsequent test of guest_priority, and the setting
547          * of xc->cppr vs. subsquent test of xc->mfrr done inside
548          * scan_interrupts and push_pending_to_hw
549          */
550         smp_mb();
551
552 again:
553         if (state->guest_priority == MASKED) {
554                 arch_spin_lock(&sb->lock);
555                 if (state->guest_priority != MASKED) {
556                         arch_spin_unlock(&sb->lock);
557                         goto again;
558                 }
559                 pr_devel(" EOI on saved P...\n");
560
561                 /* Clear old_p, that will cause unmask to perform an EOI */
562                 state->old_p = false;
563
564                 arch_spin_unlock(&sb->lock);
565         } else {
566                 pr_devel(" EOI on source...\n");
567
568                 /* Perform EOI on the source */
569                 GLUE(X_PFX,source_eoi)(hw_num, xd);
570
571                 /* If it's an emulated LSI, check level and resend */
572                 if (state->lsi && state->asserted)
573                         __x_writeq(0, __x_trig_page(xd));
574
575         }
576
577         /*
578          * This barrier orders the above guest_priority check
579          * and spin_lock/unlock with clearing in_eoi below.
580          *
581          * It also has to be a full mb() as it must ensure
582          * the MMIOs done in source_eoi() are completed before
583          * state->in_eoi is visible.
584          */
585         mb();
586         state->in_eoi = false;
587 bail:
588
589         /* Re-evaluate pending IRQs and update HW */
590         GLUE(X_PFX,scan_interrupts)(xc, xc->pending, scan_eoi);
591         GLUE(X_PFX,push_pending_to_hw)(xc);
592         pr_devel(" after scan pending=%02x\n", xc->pending);
593
594         /* Apply new CPPR */
595         xc->hw_cppr = xc->cppr;
596         __x_writeb(xc->cppr, __x_tima + TM_QW1_OS + TM_CPPR);
597
598         return rc;
599 }
600
601 X_STATIC int GLUE(X_PFX,h_ipi)(struct kvm_vcpu *vcpu, unsigned long server,
602                                unsigned long mfrr)
603 {
604         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
605
606         pr_devel("H_IPI(server=%08lx,mfrr=%ld)\n", server, mfrr);
607
608         xc->GLUE(X_STAT_PFX,h_ipi)++;
609
610         /* Find target */
611         vcpu = kvmppc_xive_find_server(vcpu->kvm, server);
612         if (!vcpu)
613                 return H_PARAMETER;
614         xc = vcpu->arch.xive_vcpu;
615
616         /* Locklessly write over MFRR */
617         xc->mfrr = mfrr;
618
619         /*
620          * The load of xc->cppr below and the subsequent MMIO store
621          * to the IPI must happen after the above mfrr update is
622          * globally visible so that:
623          *
624          * - Synchronize with another CPU doing an H_EOI or a H_CPPR
625          *   updating xc->cppr then reading xc->mfrr.
626          *
627          * - The target of the IPI sees the xc->mfrr update
628          */
629         mb();
630
631         /* Shoot the IPI if most favored than target cppr */
632         if (mfrr < xc->cppr)
633                 __x_writeq(0, __x_trig_page(&xc->vp_ipi_data));
634
635         return H_SUCCESS;
636 }