1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell OcteonTx2 RVU Devlink
3  *
4  * Copyright (C) 2020 Marvell.
5  *
6  */
7 
8 #include<linux/bitfield.h>
9 
10 #include "rvu.h"
11 #include "rvu_reg.h"
12 #include "rvu_struct.h"
13 
14 #define DRV_NAME "octeontx2-af"
15 
16 static int rvu_report_pair_start(struct devlink_fmsg *fmsg, const char *name)
17 {
18 	int err;
19 
20 	err = devlink_fmsg_pair_nest_start(fmsg, name);
21 	if (err)
22 		return err;
23 
24 	return  devlink_fmsg_obj_nest_start(fmsg);
25 }
26 
27 static int rvu_report_pair_end(struct devlink_fmsg *fmsg)
28 {
29 	int err;
30 
31 	err = devlink_fmsg_obj_nest_end(fmsg);
32 	if (err)
33 		return err;
34 
35 	return devlink_fmsg_pair_nest_end(fmsg);
36 }
37 
38 static bool rvu_common_request_irq(struct rvu *rvu, int offset,
39 				   const char *name, irq_handler_t fn)
40 {
41 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
42 	int rc;
43 
44 	sprintf(&rvu->irq_name[offset * NAME_SIZE], name);
45 	rc = request_irq(pci_irq_vector(rvu->pdev, offset), fn, 0,
46 			 &rvu->irq_name[offset * NAME_SIZE], rvu_dl);
47 	if (rc)
48 		dev_warn(rvu->dev, "Failed to register %s irq\n", name);
49 	else
50 		rvu->irq_allocated[offset] = true;
51 
52 	return rvu->irq_allocated[offset];
53 }
54 
55 static void rvu_nix_intr_work(struct work_struct *work)
56 {
57 	struct rvu_nix_health_reporters *rvu_nix_health_reporter;
58 
59 	rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, intr_work);
60 	devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_intr_reporter,
61 			      "NIX_AF_RVU Error",
62 			      rvu_nix_health_reporter->nix_event_ctx);
63 }
64 
65 static irqreturn_t rvu_nix_af_rvu_intr_handler(int irq, void *rvu_irq)
66 {
67 	struct rvu_nix_event_ctx *nix_event_context;
68 	struct rvu_devlink *rvu_dl = rvu_irq;
69 	struct rvu *rvu;
70 	int blkaddr;
71 	u64 intr;
72 
73 	rvu = rvu_dl->rvu;
74 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
75 	if (blkaddr < 0)
76 		return IRQ_NONE;
77 
78 	nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
79 	intr = rvu_read64(rvu, blkaddr, NIX_AF_RVU_INT);
80 	nix_event_context->nix_af_rvu_int = intr;
81 
82 	/* Clear interrupts */
83 	rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT, intr);
84 	rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1C, ~0ULL);
85 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->intr_work);
86 
87 	return IRQ_HANDLED;
88 }
89 
90 static void rvu_nix_gen_work(struct work_struct *work)
91 {
92 	struct rvu_nix_health_reporters *rvu_nix_health_reporter;
93 
94 	rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, gen_work);
95 	devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_gen_reporter,
96 			      "NIX_AF_GEN Error",
97 			      rvu_nix_health_reporter->nix_event_ctx);
98 }
99 
100 static irqreturn_t rvu_nix_af_rvu_gen_handler(int irq, void *rvu_irq)
101 {
102 	struct rvu_nix_event_ctx *nix_event_context;
103 	struct rvu_devlink *rvu_dl = rvu_irq;
104 	struct rvu *rvu;
105 	int blkaddr;
106 	u64 intr;
107 
108 	rvu = rvu_dl->rvu;
109 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
110 	if (blkaddr < 0)
111 		return IRQ_NONE;
112 
113 	nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
114 	intr = rvu_read64(rvu, blkaddr, NIX_AF_GEN_INT);
115 	nix_event_context->nix_af_rvu_gen = intr;
116 
117 	/* Clear interrupts */
118 	rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT, intr);
119 	rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1C, ~0ULL);
120 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->gen_work);
121 
122 	return IRQ_HANDLED;
123 }
124 
125 static void rvu_nix_err_work(struct work_struct *work)
126 {
127 	struct rvu_nix_health_reporters *rvu_nix_health_reporter;
128 
129 	rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, err_work);
130 	devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_err_reporter,
131 			      "NIX_AF_ERR Error",
132 			      rvu_nix_health_reporter->nix_event_ctx);
133 }
134 
135 static irqreturn_t rvu_nix_af_rvu_err_handler(int irq, void *rvu_irq)
136 {
137 	struct rvu_nix_event_ctx *nix_event_context;
138 	struct rvu_devlink *rvu_dl = rvu_irq;
139 	struct rvu *rvu;
140 	int blkaddr;
141 	u64 intr;
142 
143 	rvu = rvu_dl->rvu;
144 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
145 	if (blkaddr < 0)
146 		return IRQ_NONE;
147 
148 	nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
149 	intr = rvu_read64(rvu, blkaddr, NIX_AF_ERR_INT);
150 	nix_event_context->nix_af_rvu_err = intr;
151 
152 	/* Clear interrupts */
153 	rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT, intr);
154 	rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1C, ~0ULL);
155 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->err_work);
156 
157 	return IRQ_HANDLED;
158 }
159 
160 static void rvu_nix_ras_work(struct work_struct *work)
161 {
162 	struct rvu_nix_health_reporters *rvu_nix_health_reporter;
163 
164 	rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, ras_work);
165 	devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_ras_reporter,
166 			      "NIX_AF_RAS Error",
167 			      rvu_nix_health_reporter->nix_event_ctx);
168 }
169 
170 static irqreturn_t rvu_nix_af_rvu_ras_handler(int irq, void *rvu_irq)
171 {
172 	struct rvu_nix_event_ctx *nix_event_context;
173 	struct rvu_devlink *rvu_dl = rvu_irq;
174 	struct rvu *rvu;
175 	int blkaddr;
176 	u64 intr;
177 
178 	rvu = rvu_dl->rvu;
179 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
180 	if (blkaddr < 0)
181 		return IRQ_NONE;
182 
183 	nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
184 	intr = rvu_read64(rvu, blkaddr, NIX_AF_ERR_INT);
185 	nix_event_context->nix_af_rvu_ras = intr;
186 
187 	/* Clear interrupts */
188 	rvu_write64(rvu, blkaddr, NIX_AF_RAS, intr);
189 	rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1C, ~0ULL);
190 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->ras_work);
191 
192 	return IRQ_HANDLED;
193 }
194 
195 static void rvu_nix_unregister_interrupts(struct rvu *rvu)
196 {
197 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
198 	int offs, i, blkaddr;
199 
200 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
201 	if (blkaddr < 0)
202 		return;
203 
204 	offs = rvu_read64(rvu, blkaddr, NIX_PRIV_AF_INT_CFG) & 0x3ff;
205 	if (!offs)
206 		return;
207 
208 	rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1C, ~0ULL);
209 	rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1C, ~0ULL);
210 	rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1C, ~0ULL);
211 	rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1C, ~0ULL);
212 
213 	if (rvu->irq_allocated[offs + NIX_AF_INT_VEC_RVU]) {
214 		free_irq(pci_irq_vector(rvu->pdev, offs + NIX_AF_INT_VEC_RVU),
215 			 rvu_dl);
216 		rvu->irq_allocated[offs + NIX_AF_INT_VEC_RVU] = false;
217 	}
218 
219 	for (i = NIX_AF_INT_VEC_AF_ERR; i < NIX_AF_INT_VEC_CNT; i++)
220 		if (rvu->irq_allocated[offs + i]) {
221 			free_irq(pci_irq_vector(rvu->pdev, offs + i), rvu_dl);
222 			rvu->irq_allocated[offs + i] = false;
223 		}
224 }
225 
226 static int rvu_nix_register_interrupts(struct rvu *rvu)
227 {
228 	int blkaddr, base;
229 	bool rc;
230 
231 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
232 	if (blkaddr < 0)
233 		return blkaddr;
234 
235 	/* Get NIX AF MSIX vectors offset. */
236 	base = rvu_read64(rvu, blkaddr, NIX_PRIV_AF_INT_CFG) & 0x3ff;
237 	if (!base) {
238 		dev_warn(rvu->dev,
239 			 "Failed to get NIX%d NIX_AF_INT vector offsets\n",
240 			 blkaddr - BLKADDR_NIX0);
241 		return 0;
242 	}
243 	/* Register and enable NIX_AF_RVU_INT interrupt */
244 	rc = rvu_common_request_irq(rvu, base +  NIX_AF_INT_VEC_RVU,
245 				    "NIX_AF_RVU_INT",
246 				    rvu_nix_af_rvu_intr_handler);
247 	if (!rc)
248 		goto err;
249 	rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1S, ~0ULL);
250 
251 	/* Register and enable NIX_AF_GEN_INT interrupt */
252 	rc = rvu_common_request_irq(rvu, base +  NIX_AF_INT_VEC_GEN,
253 				    "NIX_AF_GEN_INT",
254 				    rvu_nix_af_rvu_gen_handler);
255 	if (!rc)
256 		goto err;
257 	rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1S, ~0ULL);
258 
259 	/* Register and enable NIX_AF_ERR_INT interrupt */
260 	rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_AF_ERR,
261 				    "NIX_AF_ERR_INT",
262 				    rvu_nix_af_rvu_err_handler);
263 	if (!rc)
264 		goto err;
265 	rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1S, ~0ULL);
266 
267 	/* Register and enable NIX_AF_RAS interrupt */
268 	rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_POISON,
269 				    "NIX_AF_RAS",
270 				    rvu_nix_af_rvu_ras_handler);
271 	if (!rc)
272 		goto err;
273 	rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1S, ~0ULL);
274 
275 	return 0;
276 err:
277 	rvu_nix_unregister_interrupts(rvu);
278 	return rc;
279 }
280 
281 static int rvu_nix_report_show(struct devlink_fmsg *fmsg, void *ctx,
282 			       enum nix_af_rvu_health health_reporter)
283 {
284 	struct rvu_nix_event_ctx *nix_event_context;
285 	u64 intr_val;
286 	int err;
287 
288 	nix_event_context = ctx;
289 	switch (health_reporter) {
290 	case NIX_AF_RVU_INTR:
291 		intr_val = nix_event_context->nix_af_rvu_int;
292 		err = rvu_report_pair_start(fmsg, "NIX_AF_RVU");
293 		if (err)
294 			return err;
295 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RVU Interrupt Reg ",
296 						nix_event_context->nix_af_rvu_int);
297 		if (err)
298 			return err;
299 		if (intr_val & BIT_ULL(0)) {
300 			err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
301 			if (err)
302 				return err;
303 		}
304 		err = rvu_report_pair_end(fmsg);
305 		if (err)
306 			return err;
307 		break;
308 	case NIX_AF_RVU_GEN:
309 		intr_val = nix_event_context->nix_af_rvu_gen;
310 		err = rvu_report_pair_start(fmsg, "NIX_AF_GENERAL");
311 		if (err)
312 			return err;
313 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX General Interrupt Reg ",
314 						nix_event_context->nix_af_rvu_gen);
315 		if (err)
316 			return err;
317 		if (intr_val & BIT_ULL(0)) {
318 			err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast pkt drop");
319 			if (err)
320 				return err;
321 		}
322 		if (intr_val & BIT_ULL(1)) {
323 			err = devlink_fmsg_string_put(fmsg, "\n\tRx mirror pkt drop");
324 			if (err)
325 				return err;
326 		}
327 		if (intr_val & BIT_ULL(4)) {
328 			err = devlink_fmsg_string_put(fmsg, "\n\tSMQ flush done");
329 			if (err)
330 				return err;
331 		}
332 		err = rvu_report_pair_end(fmsg);
333 		if (err)
334 			return err;
335 		break;
336 	case NIX_AF_RVU_ERR:
337 		intr_val = nix_event_context->nix_af_rvu_err;
338 		err = rvu_report_pair_start(fmsg, "NIX_AF_ERR");
339 		if (err)
340 			return err;
341 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX Error Interrupt Reg ",
342 						nix_event_context->nix_af_rvu_err);
343 		if (err)
344 			return err;
345 		if (intr_val & BIT_ULL(14)) {
346 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_INST_S read");
347 			if (err)
348 				return err;
349 		}
350 		if (intr_val & BIT_ULL(13)) {
351 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_RES_S write");
352 			if (err)
353 				return err;
354 		}
355 		if (intr_val & BIT_ULL(12)) {
356 			err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
357 			if (err)
358 				return err;
359 		}
360 		if (intr_val & BIT_ULL(6)) {
361 			err = devlink_fmsg_string_put(fmsg, "\n\tRx on unmapped PF_FUNC");
362 			if (err)
363 				return err;
364 		}
365 		if (intr_val & BIT_ULL(5)) {
366 			err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast replication error");
367 			if (err)
368 				return err;
369 		}
370 		if (intr_val & BIT_ULL(4)) {
371 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_RX_MCE_S read");
372 			if (err)
373 				return err;
374 		}
375 		if (intr_val & BIT_ULL(3)) {
376 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast WQE read");
377 			if (err)
378 				return err;
379 		}
380 		if (intr_val & BIT_ULL(2)) {
381 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror WQE read");
382 			if (err)
383 				return err;
384 		}
385 		if (intr_val & BIT_ULL(1)) {
386 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror pkt write");
387 			if (err)
388 				return err;
389 		}
390 		if (intr_val & BIT_ULL(0)) {
391 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast pkt write");
392 			if (err)
393 				return err;
394 		}
395 		err = rvu_report_pair_end(fmsg);
396 		if (err)
397 			return err;
398 		break;
399 	case NIX_AF_RVU_RAS:
400 		intr_val = nix_event_context->nix_af_rvu_err;
401 		err = rvu_report_pair_start(fmsg, "NIX_AF_RAS");
402 		if (err)
403 			return err;
404 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RAS Interrupt Reg ",
405 						nix_event_context->nix_af_rvu_err);
406 		if (err)
407 			return err;
408 		err = devlink_fmsg_string_put(fmsg, "\n\tPoison Data on:");
409 		if (err)
410 			return err;
411 		if (intr_val & BIT_ULL(34)) {
412 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_INST_S");
413 			if (err)
414 				return err;
415 		}
416 		if (intr_val & BIT_ULL(33)) {
417 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_RES_S");
418 			if (err)
419 				return err;
420 		}
421 		if (intr_val & BIT_ULL(32)) {
422 			err = devlink_fmsg_string_put(fmsg, "\n\tHW ctx");
423 			if (err)
424 				return err;
425 		}
426 		if (intr_val & BIT_ULL(4)) {
427 			err = devlink_fmsg_string_put(fmsg, "\n\tPacket from mirror buffer");
428 			if (err)
429 				return err;
430 		}
431 		if (intr_val & BIT_ULL(3)) {
432 			err = devlink_fmsg_string_put(fmsg, "\n\tPacket from multicast buffer");
433 
434 			if (err)
435 				return err;
436 		}
437 		if (intr_val & BIT_ULL(2)) {
438 			err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from mirror buffer");
439 			if (err)
440 				return err;
441 		}
442 		if (intr_val & BIT_ULL(1)) {
443 			err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from multicast buffer");
444 			if (err)
445 				return err;
446 		}
447 		if (intr_val & BIT_ULL(0)) {
448 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX_RX_MCE_S read");
449 			if (err)
450 				return err;
451 		}
452 		err = rvu_report_pair_end(fmsg);
453 		if (err)
454 			return err;
455 		break;
456 	default:
457 		return -EINVAL;
458 	}
459 
460 	return 0;
461 }
462 
463 static int rvu_hw_nix_intr_dump(struct devlink_health_reporter *reporter,
464 				struct devlink_fmsg *fmsg, void *ctx,
465 				struct netlink_ext_ack *netlink_extack)
466 {
467 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
468 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
469 	struct rvu_nix_event_ctx *nix_ctx;
470 
471 	nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
472 
473 	return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_INTR) :
474 		     rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_INTR);
475 }
476 
477 static int rvu_hw_nix_intr_recover(struct devlink_health_reporter *reporter,
478 				   void *ctx, struct netlink_ext_ack *netlink_extack)
479 {
480 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
481 	struct rvu_nix_event_ctx *nix_event_ctx = ctx;
482 	int blkaddr;
483 
484 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
485 	if (blkaddr < 0)
486 		return blkaddr;
487 
488 	if (nix_event_ctx->nix_af_rvu_int)
489 		rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1S, ~0ULL);
490 
491 	return 0;
492 }
493 
494 static int rvu_hw_nix_gen_dump(struct devlink_health_reporter *reporter,
495 			       struct devlink_fmsg *fmsg, void *ctx,
496 			       struct netlink_ext_ack *netlink_extack)
497 {
498 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
499 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
500 	struct rvu_nix_event_ctx *nix_ctx;
501 
502 	nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
503 
504 	return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_GEN) :
505 		     rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_GEN);
506 }
507 
508 static int rvu_hw_nix_gen_recover(struct devlink_health_reporter *reporter,
509 				  void *ctx, struct netlink_ext_ack *netlink_extack)
510 {
511 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
512 	struct rvu_nix_event_ctx *nix_event_ctx = ctx;
513 	int blkaddr;
514 
515 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
516 	if (blkaddr < 0)
517 		return blkaddr;
518 
519 	if (nix_event_ctx->nix_af_rvu_gen)
520 		rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1S, ~0ULL);
521 
522 	return 0;
523 }
524 
525 static int rvu_hw_nix_err_dump(struct devlink_health_reporter *reporter,
526 			       struct devlink_fmsg *fmsg, void *ctx,
527 			       struct netlink_ext_ack *netlink_extack)
528 {
529 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
530 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
531 	struct rvu_nix_event_ctx *nix_ctx;
532 
533 	nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
534 
535 	return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_ERR) :
536 		     rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_ERR);
537 }
538 
539 static int rvu_hw_nix_err_recover(struct devlink_health_reporter *reporter,
540 				  void *ctx, struct netlink_ext_ack *netlink_extack)
541 {
542 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
543 	struct rvu_nix_event_ctx *nix_event_ctx = ctx;
544 	int blkaddr;
545 
546 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
547 	if (blkaddr < 0)
548 		return blkaddr;
549 
550 	if (nix_event_ctx->nix_af_rvu_err)
551 		rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1S, ~0ULL);
552 
553 	return 0;
554 }
555 
556 static int rvu_hw_nix_ras_dump(struct devlink_health_reporter *reporter,
557 			       struct devlink_fmsg *fmsg, void *ctx,
558 			       struct netlink_ext_ack *netlink_extack)
559 {
560 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
561 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
562 	struct rvu_nix_event_ctx *nix_ctx;
563 
564 	nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
565 
566 	return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_RAS) :
567 		     rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_RAS);
568 }
569 
570 static int rvu_hw_nix_ras_recover(struct devlink_health_reporter *reporter,
571 				  void *ctx, struct netlink_ext_ack *netlink_extack)
572 {
573 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
574 	struct rvu_nix_event_ctx *nix_event_ctx = ctx;
575 	int blkaddr;
576 
577 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
578 	if (blkaddr < 0)
579 		return blkaddr;
580 
581 	if (nix_event_ctx->nix_af_rvu_int)
582 		rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1S, ~0ULL);
583 
584 	return 0;
585 }
586 
587 RVU_REPORTERS(hw_nix_intr);
588 RVU_REPORTERS(hw_nix_gen);
589 RVU_REPORTERS(hw_nix_err);
590 RVU_REPORTERS(hw_nix_ras);
591 
592 static void rvu_nix_health_reporters_destroy(struct rvu_devlink *rvu_dl);
593 
594 static int rvu_nix_register_reporters(struct rvu_devlink *rvu_dl)
595 {
596 	struct rvu_nix_health_reporters *rvu_reporters;
597 	struct rvu_nix_event_ctx *nix_event_context;
598 	struct rvu *rvu = rvu_dl->rvu;
599 
600 	rvu_reporters = kzalloc(sizeof(*rvu_reporters), GFP_KERNEL);
601 	if (!rvu_reporters)
602 		return -ENOMEM;
603 
604 	rvu_dl->rvu_nix_health_reporter = rvu_reporters;
605 	nix_event_context = kzalloc(sizeof(*nix_event_context), GFP_KERNEL);
606 	if (!nix_event_context)
607 		return -ENOMEM;
608 
609 	rvu_reporters->nix_event_ctx = nix_event_context;
610 	rvu_reporters->rvu_hw_nix_intr_reporter =
611 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_intr_reporter_ops, 0, rvu);
612 	if (IS_ERR(rvu_reporters->rvu_hw_nix_intr_reporter)) {
613 		dev_warn(rvu->dev, "Failed to create hw_nix_intr reporter, err=%ld\n",
614 			 PTR_ERR(rvu_reporters->rvu_hw_nix_intr_reporter));
615 		return PTR_ERR(rvu_reporters->rvu_hw_nix_intr_reporter);
616 	}
617 
618 	rvu_reporters->rvu_hw_nix_gen_reporter =
619 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_gen_reporter_ops, 0, rvu);
620 	if (IS_ERR(rvu_reporters->rvu_hw_nix_gen_reporter)) {
621 		dev_warn(rvu->dev, "Failed to create hw_nix_gen reporter, err=%ld\n",
622 			 PTR_ERR(rvu_reporters->rvu_hw_nix_gen_reporter));
623 		return PTR_ERR(rvu_reporters->rvu_hw_nix_gen_reporter);
624 	}
625 
626 	rvu_reporters->rvu_hw_nix_err_reporter =
627 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_err_reporter_ops, 0, rvu);
628 	if (IS_ERR(rvu_reporters->rvu_hw_nix_err_reporter)) {
629 		dev_warn(rvu->dev, "Failed to create hw_nix_err reporter, err=%ld\n",
630 			 PTR_ERR(rvu_reporters->rvu_hw_nix_err_reporter));
631 		return PTR_ERR(rvu_reporters->rvu_hw_nix_err_reporter);
632 	}
633 
634 	rvu_reporters->rvu_hw_nix_ras_reporter =
635 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_ras_reporter_ops, 0, rvu);
636 	if (IS_ERR(rvu_reporters->rvu_hw_nix_ras_reporter)) {
637 		dev_warn(rvu->dev, "Failed to create hw_nix_ras reporter, err=%ld\n",
638 			 PTR_ERR(rvu_reporters->rvu_hw_nix_ras_reporter));
639 		return PTR_ERR(rvu_reporters->rvu_hw_nix_ras_reporter);
640 	}
641 
642 	rvu_dl->devlink_wq = create_workqueue("rvu_devlink_wq");
643 	if (!rvu_dl->devlink_wq)
644 		goto err;
645 
646 	INIT_WORK(&rvu_reporters->intr_work, rvu_nix_intr_work);
647 	INIT_WORK(&rvu_reporters->gen_work, rvu_nix_gen_work);
648 	INIT_WORK(&rvu_reporters->err_work, rvu_nix_err_work);
649 	INIT_WORK(&rvu_reporters->ras_work, rvu_nix_ras_work);
650 
651 	return 0;
652 err:
653 	rvu_nix_health_reporters_destroy(rvu_dl);
654 	return -ENOMEM;
655 }
656 
657 static int rvu_nix_health_reporters_create(struct rvu_devlink *rvu_dl)
658 {
659 	struct rvu *rvu = rvu_dl->rvu;
660 	int err;
661 
662 	err = rvu_nix_register_reporters(rvu_dl);
663 	if (err) {
664 		dev_warn(rvu->dev, "Failed to create nix reporter, err =%d\n",
665 			 err);
666 		return err;
667 	}
668 	rvu_nix_register_interrupts(rvu);
669 
670 	return 0;
671 }
672 
673 static void rvu_nix_health_reporters_destroy(struct rvu_devlink *rvu_dl)
674 {
675 	struct rvu_nix_health_reporters *nix_reporters;
676 	struct rvu *rvu = rvu_dl->rvu;
677 
678 	nix_reporters = rvu_dl->rvu_nix_health_reporter;
679 
680 	if (!nix_reporters->rvu_hw_nix_ras_reporter)
681 		return;
682 	if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_intr_reporter))
683 		devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_intr_reporter);
684 
685 	if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_gen_reporter))
686 		devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_gen_reporter);
687 
688 	if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_err_reporter))
689 		devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_err_reporter);
690 
691 	if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_ras_reporter))
692 		devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_ras_reporter);
693 
694 	rvu_nix_unregister_interrupts(rvu);
695 	kfree(rvu_dl->rvu_nix_health_reporter->nix_event_ctx);
696 	kfree(rvu_dl->rvu_nix_health_reporter);
697 }
698 
699 static void rvu_npa_intr_work(struct work_struct *work)
700 {
701 	struct rvu_npa_health_reporters *rvu_npa_health_reporter;
702 
703 	rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, intr_work);
704 	devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_intr_reporter,
705 			      "NPA_AF_RVU Error",
706 			      rvu_npa_health_reporter->npa_event_ctx);
707 }
708 
709 static irqreturn_t rvu_npa_af_rvu_intr_handler(int irq, void *rvu_irq)
710 {
711 	struct rvu_npa_event_ctx *npa_event_context;
712 	struct rvu_devlink *rvu_dl = rvu_irq;
713 	struct rvu *rvu;
714 	int blkaddr;
715 	u64 intr;
716 
717 	rvu = rvu_dl->rvu;
718 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
719 	if (blkaddr < 0)
720 		return IRQ_NONE;
721 
722 	npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
723 	intr = rvu_read64(rvu, blkaddr, NPA_AF_RVU_INT);
724 	npa_event_context->npa_af_rvu_int = intr;
725 
726 	/* Clear interrupts */
727 	rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT, intr);
728 	rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1C, ~0ULL);
729 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->intr_work);
730 
731 	return IRQ_HANDLED;
732 }
733 
734 static void rvu_npa_gen_work(struct work_struct *work)
735 {
736 	struct rvu_npa_health_reporters *rvu_npa_health_reporter;
737 
738 	rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, gen_work);
739 	devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_gen_reporter,
740 			      "NPA_AF_GEN Error",
741 			      rvu_npa_health_reporter->npa_event_ctx);
742 }
743 
744 static irqreturn_t rvu_npa_af_gen_intr_handler(int irq, void *rvu_irq)
745 {
746 	struct rvu_npa_event_ctx *npa_event_context;
747 	struct rvu_devlink *rvu_dl = rvu_irq;
748 	struct rvu *rvu;
749 	int blkaddr;
750 	u64 intr;
751 
752 	rvu = rvu_dl->rvu;
753 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
754 	if (blkaddr < 0)
755 		return IRQ_NONE;
756 
757 	npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
758 	intr = rvu_read64(rvu, blkaddr, NPA_AF_GEN_INT);
759 	npa_event_context->npa_af_rvu_gen = intr;
760 
761 	/* Clear interrupts */
762 	rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT, intr);
763 	rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1C, ~0ULL);
764 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->gen_work);
765 
766 	return IRQ_HANDLED;
767 }
768 
769 static void rvu_npa_err_work(struct work_struct *work)
770 {
771 	struct rvu_npa_health_reporters *rvu_npa_health_reporter;
772 
773 	rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, err_work);
774 	devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_err_reporter,
775 			      "NPA_AF_ERR Error",
776 			      rvu_npa_health_reporter->npa_event_ctx);
777 }
778 
779 static irqreturn_t rvu_npa_af_err_intr_handler(int irq, void *rvu_irq)
780 {
781 	struct rvu_npa_event_ctx *npa_event_context;
782 	struct rvu_devlink *rvu_dl = rvu_irq;
783 	struct rvu *rvu;
784 	int blkaddr;
785 	u64 intr;
786 
787 	rvu = rvu_dl->rvu;
788 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
789 	if (blkaddr < 0)
790 		return IRQ_NONE;
791 	npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
792 	intr = rvu_read64(rvu, blkaddr, NPA_AF_ERR_INT);
793 	npa_event_context->npa_af_rvu_err = intr;
794 
795 	/* Clear interrupts */
796 	rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT, intr);
797 	rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1C, ~0ULL);
798 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->err_work);
799 
800 	return IRQ_HANDLED;
801 }
802 
803 static void rvu_npa_ras_work(struct work_struct *work)
804 {
805 	struct rvu_npa_health_reporters *rvu_npa_health_reporter;
806 
807 	rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, ras_work);
808 	devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_ras_reporter,
809 			      "HW NPA_AF_RAS Error reported",
810 			      rvu_npa_health_reporter->npa_event_ctx);
811 }
812 
813 static irqreturn_t rvu_npa_af_ras_intr_handler(int irq, void *rvu_irq)
814 {
815 	struct rvu_npa_event_ctx *npa_event_context;
816 	struct rvu_devlink *rvu_dl = rvu_irq;
817 	struct rvu *rvu;
818 	int blkaddr;
819 	u64 intr;
820 
821 	rvu = rvu_dl->rvu;
822 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
823 	if (blkaddr < 0)
824 		return IRQ_NONE;
825 
826 	npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
827 	intr = rvu_read64(rvu, blkaddr, NPA_AF_RAS);
828 	npa_event_context->npa_af_rvu_ras = intr;
829 
830 	/* Clear interrupts */
831 	rvu_write64(rvu, blkaddr, NPA_AF_RAS, intr);
832 	rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1C, ~0ULL);
833 	queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->ras_work);
834 
835 	return IRQ_HANDLED;
836 }
837 
838 static void rvu_npa_unregister_interrupts(struct rvu *rvu)
839 {
840 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
841 	int i, offs, blkaddr;
842 	u64 reg;
843 
844 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
845 	if (blkaddr < 0)
846 		return;
847 
848 	reg = rvu_read64(rvu, blkaddr, NPA_PRIV_AF_INT_CFG);
849 	offs = reg & 0x3FF;
850 
851 	rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1C, ~0ULL);
852 	rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1C, ~0ULL);
853 	rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1C, ~0ULL);
854 	rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1C, ~0ULL);
855 
856 	for (i = 0; i < NPA_AF_INT_VEC_CNT; i++)
857 		if (rvu->irq_allocated[offs + i]) {
858 			free_irq(pci_irq_vector(rvu->pdev, offs + i), rvu_dl);
859 			rvu->irq_allocated[offs + i] = false;
860 		}
861 }
862 
863 static int rvu_npa_register_interrupts(struct rvu *rvu)
864 {
865 	int blkaddr, base;
866 	bool rc;
867 
868 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
869 	if (blkaddr < 0)
870 		return blkaddr;
871 
872 	/* Get NPA AF MSIX vectors offset. */
873 	base = rvu_read64(rvu, blkaddr, NPA_PRIV_AF_INT_CFG) & 0x3ff;
874 	if (!base) {
875 		dev_warn(rvu->dev,
876 			 "Failed to get NPA_AF_INT vector offsets\n");
877 		return 0;
878 	}
879 
880 	/* Register and enable NPA_AF_RVU_INT interrupt */
881 	rc = rvu_common_request_irq(rvu, base +  NPA_AF_INT_VEC_RVU,
882 				    "NPA_AF_RVU_INT",
883 				    rvu_npa_af_rvu_intr_handler);
884 	if (!rc)
885 		goto err;
886 	rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1S, ~0ULL);
887 
888 	/* Register and enable NPA_AF_GEN_INT interrupt */
889 	rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_GEN,
890 				    "NPA_AF_RVU_GEN",
891 				    rvu_npa_af_gen_intr_handler);
892 	if (!rc)
893 		goto err;
894 	rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1S, ~0ULL);
895 
896 	/* Register and enable NPA_AF_ERR_INT interrupt */
897 	rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_AF_ERR,
898 				    "NPA_AF_ERR_INT",
899 				    rvu_npa_af_err_intr_handler);
900 	if (!rc)
901 		goto err;
902 	rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1S, ~0ULL);
903 
904 	/* Register and enable NPA_AF_RAS interrupt */
905 	rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_POISON,
906 				    "NPA_AF_RAS",
907 				    rvu_npa_af_ras_intr_handler);
908 	if (!rc)
909 		goto err;
910 	rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1S, ~0ULL);
911 
912 	return 0;
913 err:
914 	rvu_npa_unregister_interrupts(rvu);
915 	return rc;
916 }
917 
918 static int rvu_npa_report_show(struct devlink_fmsg *fmsg, void *ctx,
919 			       enum npa_af_rvu_health health_reporter)
920 {
921 	struct rvu_npa_event_ctx *npa_event_context;
922 	unsigned int alloc_dis, free_dis;
923 	u64 intr_val;
924 	int err;
925 
926 	npa_event_context = ctx;
927 	switch (health_reporter) {
928 	case NPA_AF_RVU_GEN:
929 		intr_val = npa_event_context->npa_af_rvu_gen;
930 		err = rvu_report_pair_start(fmsg, "NPA_AF_GENERAL");
931 		if (err)
932 			return err;
933 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA General Interrupt Reg ",
934 						npa_event_context->npa_af_rvu_gen);
935 		if (err)
936 			return err;
937 		if (intr_val & BIT_ULL(32)) {
938 			err = devlink_fmsg_string_put(fmsg, "\n\tUnmap PF Error");
939 			if (err)
940 				return err;
941 		}
942 
943 		free_dis = FIELD_GET(GENMASK(15, 0), intr_val);
944 		if (free_dis & BIT(NPA_INPQ_NIX0_RX)) {
945 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: free disabled RX");
946 			if (err)
947 				return err;
948 		}
949 		if (free_dis & BIT(NPA_INPQ_NIX0_TX)) {
950 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:free disabled TX");
951 			if (err)
952 				return err;
953 		}
954 		if (free_dis & BIT(NPA_INPQ_NIX1_RX)) {
955 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: free disabled RX");
956 			if (err)
957 				return err;
958 		}
959 		if (free_dis & BIT(NPA_INPQ_NIX1_TX)) {
960 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:free disabled TX");
961 			if (err)
962 				return err;
963 		}
964 		if (free_dis & BIT(NPA_INPQ_SSO)) {
965 			err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for SSO");
966 			if (err)
967 				return err;
968 		}
969 		if (free_dis & BIT(NPA_INPQ_TIM)) {
970 			err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for TIM");
971 			if (err)
972 				return err;
973 		}
974 		if (free_dis & BIT(NPA_INPQ_DPI)) {
975 			err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for DPI");
976 			if (err)
977 				return err;
978 		}
979 		if (free_dis & BIT(NPA_INPQ_AURA_OP)) {
980 			err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for AURA");
981 			if (err)
982 				return err;
983 		}
984 
985 		alloc_dis = FIELD_GET(GENMASK(31, 16), intr_val);
986 		if (alloc_dis & BIT(NPA_INPQ_NIX0_RX)) {
987 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: alloc disabled RX");
988 			if (err)
989 				return err;
990 		}
991 		if (alloc_dis & BIT(NPA_INPQ_NIX0_TX)) {
992 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:alloc disabled TX");
993 			if (err)
994 				return err;
995 		}
996 		if (alloc_dis & BIT(NPA_INPQ_NIX1_RX)) {
997 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: alloc disabled RX");
998 			if (err)
999 				return err;
1000 		}
1001 		if (alloc_dis & BIT(NPA_INPQ_NIX1_TX)) {
1002 			err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:alloc disabled TX");
1003 			if (err)
1004 				return err;
1005 		}
1006 		if (alloc_dis & BIT(NPA_INPQ_SSO)) {
1007 			err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for SSO");
1008 			if (err)
1009 				return err;
1010 		}
1011 		if (alloc_dis & BIT(NPA_INPQ_TIM)) {
1012 			err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for TIM");
1013 			if (err)
1014 				return err;
1015 		}
1016 		if (alloc_dis & BIT(NPA_INPQ_DPI)) {
1017 			err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for DPI");
1018 			if (err)
1019 				return err;
1020 		}
1021 		if (alloc_dis & BIT(NPA_INPQ_AURA_OP)) {
1022 			err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for AURA");
1023 			if (err)
1024 				return err;
1025 		}
1026 		err = rvu_report_pair_end(fmsg);
1027 		if (err)
1028 			return err;
1029 		break;
1030 	case NPA_AF_RVU_ERR:
1031 		err = rvu_report_pair_start(fmsg, "NPA_AF_ERR");
1032 		if (err)
1033 			return err;
1034 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA Error Interrupt Reg ",
1035 						npa_event_context->npa_af_rvu_err);
1036 		if (err)
1037 			return err;
1038 
1039 		if (npa_event_context->npa_af_rvu_err & BIT_ULL(14)) {
1040 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_INST_S read");
1041 			if (err)
1042 				return err;
1043 		}
1044 		if (npa_event_context->npa_af_rvu_err & BIT_ULL(13)) {
1045 			err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_RES_S write");
1046 			if (err)
1047 				return err;
1048 		}
1049 		if (npa_event_context->npa_af_rvu_err & BIT_ULL(12)) {
1050 			err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
1051 			if (err)
1052 				return err;
1053 		}
1054 		err = rvu_report_pair_end(fmsg);
1055 		if (err)
1056 			return err;
1057 		break;
1058 	case NPA_AF_RVU_RAS:
1059 		err = rvu_report_pair_start(fmsg, "NPA_AF_RVU_RAS");
1060 		if (err)
1061 			return err;
1062 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RAS Interrupt Reg ",
1063 						npa_event_context->npa_af_rvu_ras);
1064 		if (err)
1065 			return err;
1066 		if (npa_event_context->npa_af_rvu_ras & BIT_ULL(34)) {
1067 			err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_INST_S");
1068 			if (err)
1069 				return err;
1070 		}
1071 		if (npa_event_context->npa_af_rvu_ras & BIT_ULL(33)) {
1072 			err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_RES_S");
1073 			if (err)
1074 				return err;
1075 		}
1076 		if (npa_event_context->npa_af_rvu_ras & BIT_ULL(32)) {
1077 			err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on HW context");
1078 			if (err)
1079 				return err;
1080 		}
1081 		err = rvu_report_pair_end(fmsg);
1082 		if (err)
1083 			return err;
1084 		break;
1085 	case NPA_AF_RVU_INTR:
1086 		err = rvu_report_pair_start(fmsg, "NPA_AF_RVU");
1087 		if (err)
1088 			return err;
1089 		err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RVU Interrupt Reg ",
1090 						npa_event_context->npa_af_rvu_int);
1091 		if (err)
1092 			return err;
1093 		if (npa_event_context->npa_af_rvu_int & BIT_ULL(0)) {
1094 			err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
1095 			if (err)
1096 				return err;
1097 		}
1098 		return rvu_report_pair_end(fmsg);
1099 	default:
1100 		return -EINVAL;
1101 	}
1102 
1103 	return 0;
1104 }
1105 
1106 static int rvu_hw_npa_intr_dump(struct devlink_health_reporter *reporter,
1107 				struct devlink_fmsg *fmsg, void *ctx,
1108 				struct netlink_ext_ack *netlink_extack)
1109 {
1110 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1111 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1112 	struct rvu_npa_event_ctx *npa_ctx;
1113 
1114 	npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1115 
1116 	return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_INTR) :
1117 		     rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_INTR);
1118 }
1119 
1120 static int rvu_hw_npa_intr_recover(struct devlink_health_reporter *reporter,
1121 				   void *ctx, struct netlink_ext_ack *netlink_extack)
1122 {
1123 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1124 	struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1125 	int blkaddr;
1126 
1127 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1128 	if (blkaddr < 0)
1129 		return blkaddr;
1130 
1131 	if (npa_event_ctx->npa_af_rvu_int)
1132 		rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1S, ~0ULL);
1133 
1134 	return 0;
1135 }
1136 
1137 static int rvu_hw_npa_gen_dump(struct devlink_health_reporter *reporter,
1138 			       struct devlink_fmsg *fmsg, void *ctx,
1139 			       struct netlink_ext_ack *netlink_extack)
1140 {
1141 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1142 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1143 	struct rvu_npa_event_ctx *npa_ctx;
1144 
1145 	npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1146 
1147 	return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_GEN) :
1148 		     rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_GEN);
1149 }
1150 
1151 static int rvu_hw_npa_gen_recover(struct devlink_health_reporter *reporter,
1152 				  void *ctx, struct netlink_ext_ack *netlink_extack)
1153 {
1154 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1155 	struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1156 	int blkaddr;
1157 
1158 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1159 	if (blkaddr < 0)
1160 		return blkaddr;
1161 
1162 	if (npa_event_ctx->npa_af_rvu_gen)
1163 		rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1S, ~0ULL);
1164 
1165 	return 0;
1166 }
1167 
1168 static int rvu_hw_npa_err_dump(struct devlink_health_reporter *reporter,
1169 			       struct devlink_fmsg *fmsg, void *ctx,
1170 			       struct netlink_ext_ack *netlink_extack)
1171 {
1172 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1173 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1174 	struct rvu_npa_event_ctx *npa_ctx;
1175 
1176 	npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1177 
1178 	return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_ERR) :
1179 		     rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_ERR);
1180 }
1181 
1182 static int rvu_hw_npa_err_recover(struct devlink_health_reporter *reporter,
1183 				  void *ctx, struct netlink_ext_ack *netlink_extack)
1184 {
1185 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1186 	struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1187 	int blkaddr;
1188 
1189 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1190 	if (blkaddr < 0)
1191 		return blkaddr;
1192 
1193 	if (npa_event_ctx->npa_af_rvu_err)
1194 		rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1S, ~0ULL);
1195 
1196 	return 0;
1197 }
1198 
1199 static int rvu_hw_npa_ras_dump(struct devlink_health_reporter *reporter,
1200 			       struct devlink_fmsg *fmsg, void *ctx,
1201 			       struct netlink_ext_ack *netlink_extack)
1202 {
1203 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1204 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1205 	struct rvu_npa_event_ctx *npa_ctx;
1206 
1207 	npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1208 
1209 	return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_RAS) :
1210 		     rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_RAS);
1211 }
1212 
1213 static int rvu_hw_npa_ras_recover(struct devlink_health_reporter *reporter,
1214 				  void *ctx, struct netlink_ext_ack *netlink_extack)
1215 {
1216 	struct rvu *rvu = devlink_health_reporter_priv(reporter);
1217 	struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1218 	int blkaddr;
1219 
1220 	blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1221 	if (blkaddr < 0)
1222 		return blkaddr;
1223 
1224 	if (npa_event_ctx->npa_af_rvu_ras)
1225 		rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1S, ~0ULL);
1226 
1227 	return 0;
1228 }
1229 
1230 RVU_REPORTERS(hw_npa_intr);
1231 RVU_REPORTERS(hw_npa_gen);
1232 RVU_REPORTERS(hw_npa_err);
1233 RVU_REPORTERS(hw_npa_ras);
1234 
1235 static void rvu_npa_health_reporters_destroy(struct rvu_devlink *rvu_dl);
1236 
1237 static int rvu_npa_register_reporters(struct rvu_devlink *rvu_dl)
1238 {
1239 	struct rvu_npa_health_reporters *rvu_reporters;
1240 	struct rvu_npa_event_ctx *npa_event_context;
1241 	struct rvu *rvu = rvu_dl->rvu;
1242 
1243 	rvu_reporters = kzalloc(sizeof(*rvu_reporters), GFP_KERNEL);
1244 	if (!rvu_reporters)
1245 		return -ENOMEM;
1246 
1247 	rvu_dl->rvu_npa_health_reporter = rvu_reporters;
1248 	npa_event_context = kzalloc(sizeof(*npa_event_context), GFP_KERNEL);
1249 	if (!npa_event_context)
1250 		return -ENOMEM;
1251 
1252 	rvu_reporters->npa_event_ctx = npa_event_context;
1253 	rvu_reporters->rvu_hw_npa_intr_reporter =
1254 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_intr_reporter_ops, 0, rvu);
1255 	if (IS_ERR(rvu_reporters->rvu_hw_npa_intr_reporter)) {
1256 		dev_warn(rvu->dev, "Failed to create hw_npa_intr reporter, err=%ld\n",
1257 			 PTR_ERR(rvu_reporters->rvu_hw_npa_intr_reporter));
1258 		return PTR_ERR(rvu_reporters->rvu_hw_npa_intr_reporter);
1259 	}
1260 
1261 	rvu_reporters->rvu_hw_npa_gen_reporter =
1262 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_gen_reporter_ops, 0, rvu);
1263 	if (IS_ERR(rvu_reporters->rvu_hw_npa_gen_reporter)) {
1264 		dev_warn(rvu->dev, "Failed to create hw_npa_gen reporter, err=%ld\n",
1265 			 PTR_ERR(rvu_reporters->rvu_hw_npa_gen_reporter));
1266 		return PTR_ERR(rvu_reporters->rvu_hw_npa_gen_reporter);
1267 	}
1268 
1269 	rvu_reporters->rvu_hw_npa_err_reporter =
1270 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_err_reporter_ops, 0, rvu);
1271 	if (IS_ERR(rvu_reporters->rvu_hw_npa_err_reporter)) {
1272 		dev_warn(rvu->dev, "Failed to create hw_npa_err reporter, err=%ld\n",
1273 			 PTR_ERR(rvu_reporters->rvu_hw_npa_err_reporter));
1274 		return PTR_ERR(rvu_reporters->rvu_hw_npa_err_reporter);
1275 	}
1276 
1277 	rvu_reporters->rvu_hw_npa_ras_reporter =
1278 		devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_ras_reporter_ops, 0, rvu);
1279 	if (IS_ERR(rvu_reporters->rvu_hw_npa_ras_reporter)) {
1280 		dev_warn(rvu->dev, "Failed to create hw_npa_ras reporter, err=%ld\n",
1281 			 PTR_ERR(rvu_reporters->rvu_hw_npa_ras_reporter));
1282 		return PTR_ERR(rvu_reporters->rvu_hw_npa_ras_reporter);
1283 	}
1284 
1285 	rvu_dl->devlink_wq = create_workqueue("rvu_devlink_wq");
1286 	if (!rvu_dl->devlink_wq)
1287 		goto err;
1288 
1289 	INIT_WORK(&rvu_reporters->intr_work, rvu_npa_intr_work);
1290 	INIT_WORK(&rvu_reporters->err_work, rvu_npa_err_work);
1291 	INIT_WORK(&rvu_reporters->gen_work, rvu_npa_gen_work);
1292 	INIT_WORK(&rvu_reporters->ras_work, rvu_npa_ras_work);
1293 
1294 	return 0;
1295 err:
1296 	rvu_npa_health_reporters_destroy(rvu_dl);
1297 	return -ENOMEM;
1298 }
1299 
1300 static int rvu_npa_health_reporters_create(struct rvu_devlink *rvu_dl)
1301 {
1302 	struct rvu *rvu = rvu_dl->rvu;
1303 	int err;
1304 
1305 	err = rvu_npa_register_reporters(rvu_dl);
1306 	if (err) {
1307 		dev_warn(rvu->dev, "Failed to create npa reporter, err =%d\n",
1308 			 err);
1309 		return err;
1310 	}
1311 	rvu_npa_register_interrupts(rvu);
1312 
1313 	return 0;
1314 }
1315 
1316 static void rvu_npa_health_reporters_destroy(struct rvu_devlink *rvu_dl)
1317 {
1318 	struct rvu_npa_health_reporters *npa_reporters;
1319 	struct rvu *rvu = rvu_dl->rvu;
1320 
1321 	npa_reporters = rvu_dl->rvu_npa_health_reporter;
1322 
1323 	if (!npa_reporters->rvu_hw_npa_ras_reporter)
1324 		return;
1325 	if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_intr_reporter))
1326 		devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_intr_reporter);
1327 
1328 	if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_gen_reporter))
1329 		devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_gen_reporter);
1330 
1331 	if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_err_reporter))
1332 		devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_err_reporter);
1333 
1334 	if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_ras_reporter))
1335 		devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_ras_reporter);
1336 
1337 	rvu_npa_unregister_interrupts(rvu);
1338 	kfree(rvu_dl->rvu_npa_health_reporter->npa_event_ctx);
1339 	kfree(rvu_dl->rvu_npa_health_reporter);
1340 }
1341 
1342 static int rvu_health_reporters_create(struct rvu *rvu)
1343 {
1344 	struct rvu_devlink *rvu_dl;
1345 	int err;
1346 
1347 	rvu_dl = rvu->rvu_dl;
1348 	err = rvu_npa_health_reporters_create(rvu_dl);
1349 	if (err)
1350 		return err;
1351 
1352 	return rvu_nix_health_reporters_create(rvu_dl);
1353 }
1354 
1355 static void rvu_health_reporters_destroy(struct rvu *rvu)
1356 {
1357 	struct rvu_devlink *rvu_dl;
1358 
1359 	if (!rvu->rvu_dl)
1360 		return;
1361 
1362 	rvu_dl = rvu->rvu_dl;
1363 	rvu_npa_health_reporters_destroy(rvu_dl);
1364 	rvu_nix_health_reporters_destroy(rvu_dl);
1365 }
1366 
1367 static int rvu_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
1368 				struct netlink_ext_ack *extack)
1369 {
1370 	return devlink_info_driver_name_put(req, DRV_NAME);
1371 }
1372 
1373 static const struct devlink_ops rvu_devlink_ops = {
1374 	.info_get = rvu_devlink_info_get,
1375 };
1376 
1377 int rvu_register_dl(struct rvu *rvu)
1378 {
1379 	struct rvu_devlink *rvu_dl;
1380 	struct devlink *dl;
1381 	int err;
1382 
1383 	rvu_dl = kzalloc(sizeof(*rvu_dl), GFP_KERNEL);
1384 	if (!rvu_dl)
1385 		return -ENOMEM;
1386 
1387 	dl = devlink_alloc(&rvu_devlink_ops, sizeof(struct rvu_devlink));
1388 	if (!dl) {
1389 		dev_warn(rvu->dev, "devlink_alloc failed\n");
1390 		kfree(rvu_dl);
1391 		return -ENOMEM;
1392 	}
1393 
1394 	err = devlink_register(dl, rvu->dev);
1395 	if (err) {
1396 		dev_err(rvu->dev, "devlink register failed with error %d\n", err);
1397 		devlink_free(dl);
1398 		kfree(rvu_dl);
1399 		return err;
1400 	}
1401 
1402 	rvu_dl->dl = dl;
1403 	rvu_dl->rvu = rvu;
1404 	rvu->rvu_dl = rvu_dl;
1405 
1406 	return rvu_health_reporters_create(rvu);
1407 }
1408 
1409 void rvu_unregister_dl(struct rvu *rvu)
1410 {
1411 	struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1412 	struct devlink *dl = rvu_dl->dl;
1413 
1414 	if (!dl)
1415 		return;
1416 
1417 	rvu_health_reporters_destroy(rvu);
1418 	devlink_unregister(dl);
1419 	devlink_free(dl);
1420 	kfree(rvu_dl);
1421 }
1422