blob: dec60f58a7677b8999af2a246613e03a19b0d3bc [file] [log] [blame]
Ian Munsief204e0b2014-10-08 19:55:02 +11001/*
2 * Copyright 2014 IBM Corp.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 */
9
10#include <linux/interrupt.h>
11#include <linux/workqueue.h>
12#include <linux/sched.h>
13#include <linux/wait.h>
14#include <linux/slab.h>
15#include <linux/pid.h>
16#include <asm/cputable.h>
Michael Neulingec249dd2015-05-27 16:07:16 +100017#include <misc/cxl-base.h>
Ian Munsief204e0b2014-10-08 19:55:02 +110018
19#include "cxl.h"
Ian Munsie9bcf28c2015-01-09 20:34:36 +110020#include "trace.h"
Ian Munsief204e0b2014-10-08 19:55:02 +110021
Frederic Barrat73d55c32016-03-04 12:26:32 +010022static int afu_irq_range_start(void)
23{
24 if (cpu_has_feature(CPU_FTR_HVMODE))
25 return 1;
26 return 0;
27}
28
Ian Munsief204e0b2014-10-08 19:55:02 +110029static irqreturn_t schedule_cxl_fault(struct cxl_context *ctx, u64 dsisr, u64 dar)
30{
31 ctx->dsisr = dsisr;
32 ctx->dar = dar;
33 schedule_work(&ctx->fault_work);
34 return IRQ_HANDLED;
35}
36
Frederic Barrat6d625ed2016-03-04 12:26:31 +010037irqreturn_t cxl_irq(int irq, struct cxl_context *ctx, struct cxl_irq_info *irq_info)
Ian Munsief204e0b2014-10-08 19:55:02 +110038{
Ian Munsief204e0b2014-10-08 19:55:02 +110039 u64 dsisr, dar;
Ian Munsief204e0b2014-10-08 19:55:02 +110040
Ian Munsiebc78b052014-11-14 17:37:50 +110041 dsisr = irq_info->dsisr;
42 dar = irq_info->dar;
Ian Munsief204e0b2014-10-08 19:55:02 +110043
Ian Munsie9bcf28c2015-01-09 20:34:36 +110044 trace_cxl_psl_irq(ctx, irq, dsisr, dar);
45
Ian Munsief204e0b2014-10-08 19:55:02 +110046 pr_devel("CXL interrupt %i for afu pe: %i DSISR: %#llx DAR: %#llx\n", irq, ctx->pe, dsisr, dar);
47
48 if (dsisr & CXL_PSL_DSISR_An_DS) {
49 /*
50 * We don't inherently need to sleep to handle this, but we do
51 * need to get a ref to the task's mm, which we can't do from
52 * irq context without the potential for a deadlock since it
53 * takes the task_lock. An alternate option would be to keep a
54 * reference to the task's mm the entire time it has cxl open,
55 * but to do that we need to solve the issue where we hold a
56 * ref to the mm, but the mm can hold a ref to the fd after an
57 * mmap preventing anything from being cleaned up.
58 */
59 pr_devel("Scheduling segment miss handling for later pe: %i\n", ctx->pe);
60 return schedule_cxl_fault(ctx, dsisr, dar);
61 }
62
63 if (dsisr & CXL_PSL_DSISR_An_M)
64 pr_devel("CXL interrupt: PTE not found\n");
65 if (dsisr & CXL_PSL_DSISR_An_P)
66 pr_devel("CXL interrupt: Storage protection violation\n");
67 if (dsisr & CXL_PSL_DSISR_An_A)
68 pr_devel("CXL interrupt: AFU lock access to write through or cache inhibited storage\n");
69 if (dsisr & CXL_PSL_DSISR_An_S)
70 pr_devel("CXL interrupt: Access was afu_wr or afu_zero\n");
71 if (dsisr & CXL_PSL_DSISR_An_K)
72 pr_devel("CXL interrupt: Access not permitted by virtual page class key protection\n");
73
74 if (dsisr & CXL_PSL_DSISR_An_DM) {
75 /*
76 * In some cases we might be able to handle the fault
77 * immediately if hash_page would succeed, but we still need
78 * the task's mm, which as above we can't get without a lock
79 */
80 pr_devel("Scheduling page fault handling for later pe: %i\n", ctx->pe);
81 return schedule_cxl_fault(ctx, dsisr, dar);
82 }
83 if (dsisr & CXL_PSL_DSISR_An_ST)
84 WARN(1, "CXL interrupt: Segment Table PTE not found\n");
85 if (dsisr & CXL_PSL_DSISR_An_UR)
86 pr_devel("CXL interrupt: AURP PTE not found\n");
87 if (dsisr & CXL_PSL_DSISR_An_PE)
Frederic Barrat5be587b2016-03-04 12:26:28 +010088 return cxl_ops->handle_psl_slice_error(ctx, dsisr,
89 irq_info->errstat);
Ian Munsief204e0b2014-10-08 19:55:02 +110090 if (dsisr & CXL_PSL_DSISR_An_AE) {
Rasmus Villemoesde369532015-06-11 13:27:52 +020091 pr_devel("CXL interrupt: AFU Error 0x%016llx\n", irq_info->afu_err);
Ian Munsief204e0b2014-10-08 19:55:02 +110092
93 if (ctx->pending_afu_err) {
94 /*
95 * This shouldn't happen - the PSL treats these errors
96 * as fatal and will have reset the AFU, so there's not
97 * much point buffering multiple AFU errors.
98 * OTOH if we DO ever see a storm of these come in it's
99 * probably best that we log them somewhere:
100 */
101 dev_err_ratelimited(&ctx->afu->dev, "CXL AFU Error "
Rasmus Villemoesde369532015-06-11 13:27:52 +0200102 "undelivered to pe %i: 0x%016llx\n",
Ian Munsiebc78b052014-11-14 17:37:50 +1100103 ctx->pe, irq_info->afu_err);
Ian Munsief204e0b2014-10-08 19:55:02 +1100104 } else {
105 spin_lock(&ctx->lock);
Ian Munsiebc78b052014-11-14 17:37:50 +1100106 ctx->afu_err = irq_info->afu_err;
Ian Munsief204e0b2014-10-08 19:55:02 +1100107 ctx->pending_afu_err = 1;
108 spin_unlock(&ctx->lock);
109
110 wake_up_all(&ctx->wq);
111 }
112
Frederic Barrat5be587b2016-03-04 12:26:28 +0100113 cxl_ops->ack_irq(ctx, CXL_PSL_TFC_An_A, 0);
Ian Munsiea6130ed2015-02-04 19:10:38 +1100114 return IRQ_HANDLED;
Ian Munsief204e0b2014-10-08 19:55:02 +1100115 }
116 if (dsisr & CXL_PSL_DSISR_An_OC)
117 pr_devel("CXL interrupt: OS Context Warning\n");
118
119 WARN(1, "Unhandled CXL PSL IRQ\n");
120 return IRQ_HANDLED;
121}
122
Ian Munsief204e0b2014-10-08 19:55:02 +1100123static irqreturn_t cxl_irq_afu(int irq, void *data)
124{
125 struct cxl_context *ctx = data;
126 irq_hw_number_t hwirq = irqd_to_hwirq(irq_get_irq_data(irq));
Frederic Barrat73d55c32016-03-04 12:26:32 +0100127 int irq_off, afu_irq = 0;
Ian Munsief204e0b2014-10-08 19:55:02 +1100128 __u16 range;
129 int r;
130
Frederic Barrat73d55c32016-03-04 12:26:32 +0100131 /*
132 * Look for the interrupt number.
133 * On bare-metal, we know range 0 only contains the PSL
134 * interrupt so we could start counting at range 1 and initialize
135 * afu_irq at 1.
136 * In a guest, range 0 also contains AFU interrupts, so it must
137 * be counted for. Therefore we initialize afu_irq at 0 to take into
138 * account the PSL interrupt.
139 *
140 * For code-readability, it just seems easier to go over all
141 * the ranges on bare-metal and guest. The end result is the same.
142 */
143 for (r = 0; r < CXL_IRQ_RANGES; r++) {
Ian Munsief204e0b2014-10-08 19:55:02 +1100144 irq_off = hwirq - ctx->irqs.offset[r];
145 range = ctx->irqs.range[r];
146 if (irq_off >= 0 && irq_off < range) {
147 afu_irq += irq_off;
148 break;
149 }
150 afu_irq += range;
151 }
152 if (unlikely(r >= CXL_IRQ_RANGES)) {
Frederic Barrat73d55c32016-03-04 12:26:32 +0100153 WARN(1, "Received AFU IRQ out of range for pe %i (virq %i hwirq %lx)\n",
Ian Munsief204e0b2014-10-08 19:55:02 +1100154 ctx->pe, irq, hwirq);
155 return IRQ_HANDLED;
156 }
157
Ian Munsie9bcf28c2015-01-09 20:34:36 +1100158 trace_cxl_afu_irq(ctx, afu_irq, irq, hwirq);
Ian Munsief204e0b2014-10-08 19:55:02 +1100159 pr_devel("Received AFU interrupt %i for pe: %i (virq %i hwirq %lx)\n",
160 afu_irq, ctx->pe, irq, hwirq);
161
162 if (unlikely(!ctx->irq_bitmap)) {
Frederic Barrat73d55c32016-03-04 12:26:32 +0100163 WARN(1, "Received AFU IRQ for context with no IRQ bitmap\n");
Ian Munsief204e0b2014-10-08 19:55:02 +1100164 return IRQ_HANDLED;
165 }
166 spin_lock(&ctx->lock);
167 set_bit(afu_irq - 1, ctx->irq_bitmap);
168 ctx->pending_irq = true;
169 spin_unlock(&ctx->lock);
170
171 wake_up_all(&ctx->wq);
172
173 return IRQ_HANDLED;
174}
175
176unsigned int cxl_map_irq(struct cxl *adapter, irq_hw_number_t hwirq,
Michael Neuling80fa93f2014-11-14 18:09:28 +1100177 irq_handler_t handler, void *cookie, const char *name)
Ian Munsief204e0b2014-10-08 19:55:02 +1100178{
179 unsigned int virq;
180 int result;
181
182 /* IRQ Domain? */
183 virq = irq_create_mapping(NULL, hwirq);
184 if (!virq) {
185 dev_warn(&adapter->dev, "cxl_map_irq: irq_create_mapping failed\n");
186 return 0;
187 }
188
Frederic Barrat5be587b2016-03-04 12:26:28 +0100189 if (cxl_ops->setup_irq)
190 cxl_ops->setup_irq(adapter, hwirq, virq);
Ian Munsief204e0b2014-10-08 19:55:02 +1100191
192 pr_devel("hwirq %#lx mapped to virq %u\n", hwirq, virq);
193
Michael Neuling80fa93f2014-11-14 18:09:28 +1100194 result = request_irq(virq, handler, 0, name, cookie);
Ian Munsief204e0b2014-10-08 19:55:02 +1100195 if (result) {
196 dev_warn(&adapter->dev, "cxl_map_irq: request_irq failed: %i\n", result);
197 return 0;
198 }
199
200 return virq;
201}
202
203void cxl_unmap_irq(unsigned int virq, void *cookie)
204{
205 free_irq(virq, cookie);
Ian Munsief204e0b2014-10-08 19:55:02 +1100206}
207
Christophe Lombard86331862016-03-04 12:26:25 +0100208int cxl_register_one_irq(struct cxl *adapter,
209 irq_handler_t handler,
210 void *cookie,
211 irq_hw_number_t *dest_hwirq,
212 unsigned int *dest_virq,
213 const char *name)
Ian Munsief204e0b2014-10-08 19:55:02 +1100214{
215 int hwirq, virq;
216
Frederic Barrat5be587b2016-03-04 12:26:28 +0100217 if ((hwirq = cxl_ops->alloc_one_irq(adapter)) < 0)
Ian Munsief204e0b2014-10-08 19:55:02 +1100218 return hwirq;
219
Michael Neuling80fa93f2014-11-14 18:09:28 +1100220 if (!(virq = cxl_map_irq(adapter, hwirq, handler, cookie, name)))
Ian Munsief204e0b2014-10-08 19:55:02 +1100221 goto err;
222
223 *dest_hwirq = hwirq;
224 *dest_virq = virq;
225
226 return 0;
227
228err:
Frederic Barrat5be587b2016-03-04 12:26:28 +0100229 cxl_ops->release_one_irq(adapter, hwirq);
Ian Munsief204e0b2014-10-08 19:55:02 +1100230 return -ENOMEM;
231}
232
Andrew Donnellan8dde1522015-09-30 11:58:05 +1000233void afu_irq_name_free(struct cxl_context *ctx)
Michael Neuling80fa93f2014-11-14 18:09:28 +1100234{
235 struct cxl_irq_name *irq_name, *tmp;
236
237 list_for_each_entry_safe(irq_name, tmp, &ctx->irq_names, list) {
238 kfree(irq_name->name);
239 list_del(&irq_name->list);
240 kfree(irq_name);
241 }
Ian Munsief204e0b2014-10-08 19:55:02 +1100242}
243
Michael Neulingc358d84b2015-05-27 16:07:12 +1000244int afu_allocate_irqs(struct cxl_context *ctx, u32 count)
Ian Munsief204e0b2014-10-08 19:55:02 +1100245{
Michael Neuling80fa93f2014-11-14 18:09:28 +1100246 int rc, r, i, j = 1;
247 struct cxl_irq_name *irq_name;
Frederic Barrat73d55c32016-03-04 12:26:32 +0100248 int alloc_count;
249
250 /*
251 * In native mode, range 0 is reserved for the multiplexed
252 * PSL interrupt. It has been allocated when the AFU was initialized.
253 *
254 * In a guest, the PSL interrupt is not mutliplexed, but per-context,
255 * and is the first interrupt from range 0. It still needs to be
256 * allocated, so bump the count by one.
257 */
258 if (cpu_has_feature(CPU_FTR_HVMODE))
259 alloc_count = count;
260 else
261 alloc_count = count + 1;
Ian Munsief204e0b2014-10-08 19:55:02 +1100262
Frederic Barrat5be587b2016-03-04 12:26:28 +0100263 if ((rc = cxl_ops->alloc_irq_ranges(&ctx->irqs, ctx->afu->adapter,
Frederic Barrat73d55c32016-03-04 12:26:32 +0100264 alloc_count)))
Ian Munsief204e0b2014-10-08 19:55:02 +1100265 return rc;
266
Frederic Barrat73d55c32016-03-04 12:26:32 +0100267 if (cpu_has_feature(CPU_FTR_HVMODE)) {
268 /* Multiplexed PSL Interrupt */
Christophe Lombardcbffa3a2016-03-04 12:26:35 +0100269 ctx->irqs.offset[0] = ctx->afu->native->psl_hwirq;
Frederic Barrat73d55c32016-03-04 12:26:32 +0100270 ctx->irqs.range[0] = 1;
271 }
Ian Munsief204e0b2014-10-08 19:55:02 +1100272
273 ctx->irq_count = count;
274 ctx->irq_bitmap = kcalloc(BITS_TO_LONGS(count),
275 sizeof(*ctx->irq_bitmap), GFP_KERNEL);
276 if (!ctx->irq_bitmap)
Vaibhav Jaina6897f32015-08-25 11:04:48 +0530277 goto out;
Michael Neuling80fa93f2014-11-14 18:09:28 +1100278
279 /*
280 * Allocate names first. If any fail, bail out before allocating
281 * actual hardware IRQs.
282 */
Frederic Barrat73d55c32016-03-04 12:26:32 +0100283 for (r = afu_irq_range_start(); r < CXL_IRQ_RANGES; r++) {
Colin Ian Kingd3383aa2015-01-08 22:36:47 +0000284 for (i = 0; i < ctx->irqs.range[r]; i++) {
Michael Neuling80fa93f2014-11-14 18:09:28 +1100285 irq_name = kmalloc(sizeof(struct cxl_irq_name),
286 GFP_KERNEL);
287 if (!irq_name)
288 goto out;
289 irq_name->name = kasprintf(GFP_KERNEL, "cxl-%s-pe%i-%i",
290 dev_name(&ctx->afu->dev),
291 ctx->pe, j);
292 if (!irq_name->name) {
293 kfree(irq_name);
294 goto out;
295 }
296 /* Add to tail so next look get the correct order */
297 list_add_tail(&irq_name->list, &ctx->irq_names);
298 j++;
299 }
300 }
Michael Neulingc358d84b2015-05-27 16:07:12 +1000301 return 0;
302
303out:
Frederic Barrat5be587b2016-03-04 12:26:28 +0100304 cxl_ops->release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
Michael Neulingc358d84b2015-05-27 16:07:12 +1000305 afu_irq_name_free(ctx);
306 return -ENOMEM;
307}
308
Daniel Axtens3d6b0402015-08-07 13:18:18 +1000309static void afu_register_hwirqs(struct cxl_context *ctx)
Michael Neulingc358d84b2015-05-27 16:07:12 +1000310{
311 irq_hw_number_t hwirq;
312 struct cxl_irq_name *irq_name;
Frederic Barrat73d55c32016-03-04 12:26:32 +0100313 int r, i;
314 irqreturn_t (*handler)(int irq, void *data);
Michael Neuling80fa93f2014-11-14 18:09:28 +1100315
316 /* We've allocated all memory now, so let's do the irq allocations */
317 irq_name = list_first_entry(&ctx->irq_names, struct cxl_irq_name, list);
Frederic Barrat73d55c32016-03-04 12:26:32 +0100318 for (r = afu_irq_range_start(); r < CXL_IRQ_RANGES; r++) {
Ian Munsief204e0b2014-10-08 19:55:02 +1100319 hwirq = ctx->irqs.offset[r];
320 for (i = 0; i < ctx->irqs.range[r]; hwirq++, i++) {
Frederic Barrat73d55c32016-03-04 12:26:32 +0100321 if (r == 0 && i == 0)
322 /*
323 * The very first interrupt of range 0 is
324 * always the PSL interrupt, but we only
325 * need to connect a handler for guests,
326 * because there's one PSL interrupt per
327 * context.
328 * On bare-metal, the PSL interrupt is
329 * multiplexed and was setup when the AFU
330 * was configured.
331 */
332 handler = cxl_ops->psl_interrupt;
333 else
334 handler = cxl_irq_afu;
335 cxl_map_irq(ctx->afu->adapter, hwirq, handler, ctx,
336 irq_name->name);
Michael Neuling80fa93f2014-11-14 18:09:28 +1100337 irq_name = list_next_entry(irq_name, list);
Ian Munsief204e0b2014-10-08 19:55:02 +1100338 }
339 }
Ian Munsief204e0b2014-10-08 19:55:02 +1100340}
341
Michael Neulingc358d84b2015-05-27 16:07:12 +1000342int afu_register_irqs(struct cxl_context *ctx, u32 count)
343{
344 int rc;
345
346 rc = afu_allocate_irqs(ctx, count);
347 if (rc)
348 return rc;
349
350 afu_register_hwirqs(ctx);
351 return 0;
Frederic Barratd56d3012016-03-04 12:26:26 +0100352}
Michael Neulingc358d84b2015-05-27 16:07:12 +1000353
Michael Neuling64288322015-05-27 16:07:07 +1000354void afu_release_irqs(struct cxl_context *ctx, void *cookie)
Ian Munsief204e0b2014-10-08 19:55:02 +1100355{
356 irq_hw_number_t hwirq;
357 unsigned int virq;
358 int r, i;
359
Frederic Barrat73d55c32016-03-04 12:26:32 +0100360 for (r = afu_irq_range_start(); r < CXL_IRQ_RANGES; r++) {
Ian Munsief204e0b2014-10-08 19:55:02 +1100361 hwirq = ctx->irqs.offset[r];
362 for (i = 0; i < ctx->irqs.range[r]; hwirq++, i++) {
363 virq = irq_find_mapping(NULL, hwirq);
364 if (virq)
Michael Neuling64288322015-05-27 16:07:07 +1000365 cxl_unmap_irq(virq, cookie);
Ian Munsief204e0b2014-10-08 19:55:02 +1100366 }
367 }
368
Michael Neuling80fa93f2014-11-14 18:09:28 +1100369 afu_irq_name_free(ctx);
Frederic Barrat5be587b2016-03-04 12:26:28 +0100370 cxl_ops->release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
Vaibhav Jain8c7dd082015-08-14 12:28:38 +0530371
Vaibhav Jain8c7dd082015-08-14 12:28:38 +0530372 ctx->irq_count = 0;
Ian Munsief204e0b2014-10-08 19:55:02 +1100373}
Philippe Bergheaud6e0c50f2016-07-05 13:08:06 +0200374
375void cxl_afu_decode_psl_serr(struct cxl_afu *afu, u64 serr)
376{
377 dev_crit(&afu->dev,
378 "PSL Slice error received. Check AFU for root cause.\n");
379 dev_crit(&afu->dev, "PSL_SERR_An: 0x%016llx\n", serr);
380 if (serr & CXL_PSL_SERR_An_afuto)
381 dev_crit(&afu->dev, "AFU MMIO Timeout\n");
382 if (serr & CXL_PSL_SERR_An_afudis)
383 dev_crit(&afu->dev,
384 "MMIO targeted Accelerator that was not enabled\n");
385 if (serr & CXL_PSL_SERR_An_afuov)
386 dev_crit(&afu->dev, "AFU CTAG Overflow\n");
387 if (serr & CXL_PSL_SERR_An_badsrc)
388 dev_crit(&afu->dev, "Bad Interrupt Source\n");
389 if (serr & CXL_PSL_SERR_An_badctx)
390 dev_crit(&afu->dev, "Bad Context Handle\n");
391 if (serr & CXL_PSL_SERR_An_llcmdis)
392 dev_crit(&afu->dev, "LLCMD to Disabled AFU\n");
393 if (serr & CXL_PSL_SERR_An_llcmdto)
394 dev_crit(&afu->dev, "LLCMD Timeout to AFU\n");
395 if (serr & CXL_PSL_SERR_An_afupar)
396 dev_crit(&afu->dev, "AFU MMIO Parity Error\n");
397 if (serr & CXL_PSL_SERR_An_afudup)
398 dev_crit(&afu->dev, "AFU MMIO Duplicate CTAG Error\n");
399 if (serr & CXL_PSL_SERR_An_AE)
400 dev_crit(&afu->dev,
401 "AFU asserted JDONE with JERROR in AFU Directed Mode\n");
402}