1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell RVU Admin Function Devlink
4 * Copyright (C) 2020 Marvell.
8 #include<linux/bitfield.h>
12 #include "rvu_struct.h"
13 #include "rvu_npc_hash.h"
15 #define DRV_NAME "octeontx2-af"
17 static int rvu_report_pair_start(struct devlink_fmsg *fmsg, const char *name)
21 err = devlink_fmsg_pair_nest_start(fmsg, name);
25 return devlink_fmsg_obj_nest_start(fmsg);
28 static int rvu_report_pair_end(struct devlink_fmsg *fmsg)
32 err = devlink_fmsg_obj_nest_end(fmsg);
36 return devlink_fmsg_pair_nest_end(fmsg);
39 static bool rvu_common_request_irq(struct rvu *rvu, int offset,
40 const char *name, irq_handler_t fn)
42 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
45 sprintf(&rvu->irq_name[offset * NAME_SIZE], "%s", name);
46 rc = request_irq(pci_irq_vector(rvu->pdev, offset), fn, 0,
47 &rvu->irq_name[offset * NAME_SIZE], rvu_dl);
49 dev_warn(rvu->dev, "Failed to register %s irq\n", name);
51 rvu->irq_allocated[offset] = true;
53 return rvu->irq_allocated[offset];
56 static void rvu_nix_intr_work(struct work_struct *work)
58 struct rvu_nix_health_reporters *rvu_nix_health_reporter;
60 rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, intr_work);
61 devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_intr_reporter,
63 rvu_nix_health_reporter->nix_event_ctx);
66 static irqreturn_t rvu_nix_af_rvu_intr_handler(int irq, void *rvu_irq)
68 struct rvu_nix_event_ctx *nix_event_context;
69 struct rvu_devlink *rvu_dl = rvu_irq;
75 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
79 nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
80 intr = rvu_read64(rvu, blkaddr, NIX_AF_RVU_INT);
81 nix_event_context->nix_af_rvu_int = intr;
83 /* Clear interrupts */
84 rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT, intr);
85 rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1C, ~0ULL);
86 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->intr_work);
91 static void rvu_nix_gen_work(struct work_struct *work)
93 struct rvu_nix_health_reporters *rvu_nix_health_reporter;
95 rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, gen_work);
96 devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_gen_reporter,
98 rvu_nix_health_reporter->nix_event_ctx);
101 static irqreturn_t rvu_nix_af_rvu_gen_handler(int irq, void *rvu_irq)
103 struct rvu_nix_event_ctx *nix_event_context;
104 struct rvu_devlink *rvu_dl = rvu_irq;
110 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
114 nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
115 intr = rvu_read64(rvu, blkaddr, NIX_AF_GEN_INT);
116 nix_event_context->nix_af_rvu_gen = intr;
118 /* Clear interrupts */
119 rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT, intr);
120 rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1C, ~0ULL);
121 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->gen_work);
126 static void rvu_nix_err_work(struct work_struct *work)
128 struct rvu_nix_health_reporters *rvu_nix_health_reporter;
130 rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, err_work);
131 devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_err_reporter,
133 rvu_nix_health_reporter->nix_event_ctx);
136 static irqreturn_t rvu_nix_af_rvu_err_handler(int irq, void *rvu_irq)
138 struct rvu_nix_event_ctx *nix_event_context;
139 struct rvu_devlink *rvu_dl = rvu_irq;
145 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
149 nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
150 intr = rvu_read64(rvu, blkaddr, NIX_AF_ERR_INT);
151 nix_event_context->nix_af_rvu_err = intr;
153 /* Clear interrupts */
154 rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT, intr);
155 rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1C, ~0ULL);
156 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->err_work);
161 static void rvu_nix_ras_work(struct work_struct *work)
163 struct rvu_nix_health_reporters *rvu_nix_health_reporter;
165 rvu_nix_health_reporter = container_of(work, struct rvu_nix_health_reporters, ras_work);
166 devlink_health_report(rvu_nix_health_reporter->rvu_hw_nix_ras_reporter,
168 rvu_nix_health_reporter->nix_event_ctx);
171 static irqreturn_t rvu_nix_af_rvu_ras_handler(int irq, void *rvu_irq)
173 struct rvu_nix_event_ctx *nix_event_context;
174 struct rvu_devlink *rvu_dl = rvu_irq;
180 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
184 nix_event_context = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
185 intr = rvu_read64(rvu, blkaddr, NIX_AF_ERR_INT);
186 nix_event_context->nix_af_rvu_ras = intr;
188 /* Clear interrupts */
189 rvu_write64(rvu, blkaddr, NIX_AF_RAS, intr);
190 rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1C, ~0ULL);
191 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_nix_health_reporter->ras_work);
196 static void rvu_nix_unregister_interrupts(struct rvu *rvu)
198 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
199 int offs, i, blkaddr;
201 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
205 offs = rvu_read64(rvu, blkaddr, NIX_PRIV_AF_INT_CFG) & 0x3ff;
209 rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1C, ~0ULL);
210 rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1C, ~0ULL);
211 rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1C, ~0ULL);
212 rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1C, ~0ULL);
214 if (rvu->irq_allocated[offs + NIX_AF_INT_VEC_RVU]) {
215 free_irq(pci_irq_vector(rvu->pdev, offs + NIX_AF_INT_VEC_RVU),
217 rvu->irq_allocated[offs + NIX_AF_INT_VEC_RVU] = false;
220 for (i = NIX_AF_INT_VEC_AF_ERR; i < NIX_AF_INT_VEC_CNT; i++)
221 if (rvu->irq_allocated[offs + i]) {
222 free_irq(pci_irq_vector(rvu->pdev, offs + i), rvu_dl);
223 rvu->irq_allocated[offs + i] = false;
227 static int rvu_nix_register_interrupts(struct rvu *rvu)
232 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
236 /* Get NIX AF MSIX vectors offset. */
237 base = rvu_read64(rvu, blkaddr, NIX_PRIV_AF_INT_CFG) & 0x3ff;
240 "Failed to get NIX%d NIX_AF_INT vector offsets\n",
241 blkaddr - BLKADDR_NIX0);
244 /* Register and enable NIX_AF_RVU_INT interrupt */
245 rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_RVU,
247 rvu_nix_af_rvu_intr_handler);
250 rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1S, ~0ULL);
252 /* Register and enable NIX_AF_GEN_INT interrupt */
253 rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_GEN,
255 rvu_nix_af_rvu_gen_handler);
258 rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1S, ~0ULL);
260 /* Register and enable NIX_AF_ERR_INT interrupt */
261 rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_AF_ERR,
263 rvu_nix_af_rvu_err_handler);
266 rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1S, ~0ULL);
268 /* Register and enable NIX_AF_RAS interrupt */
269 rc = rvu_common_request_irq(rvu, base + NIX_AF_INT_VEC_POISON,
271 rvu_nix_af_rvu_ras_handler);
274 rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1S, ~0ULL);
278 rvu_nix_unregister_interrupts(rvu);
282 static int rvu_nix_report_show(struct devlink_fmsg *fmsg, void *ctx,
283 enum nix_af_rvu_health health_reporter)
285 struct rvu_nix_event_ctx *nix_event_context;
289 nix_event_context = ctx;
290 switch (health_reporter) {
291 case NIX_AF_RVU_INTR:
292 intr_val = nix_event_context->nix_af_rvu_int;
293 err = rvu_report_pair_start(fmsg, "NIX_AF_RVU");
296 err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RVU Interrupt Reg ",
297 nix_event_context->nix_af_rvu_int);
300 if (intr_val & BIT_ULL(0)) {
301 err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
305 err = rvu_report_pair_end(fmsg);
310 intr_val = nix_event_context->nix_af_rvu_gen;
311 err = rvu_report_pair_start(fmsg, "NIX_AF_GENERAL");
314 err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX General Interrupt Reg ",
315 nix_event_context->nix_af_rvu_gen);
318 if (intr_val & BIT_ULL(0)) {
319 err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast pkt drop");
323 if (intr_val & BIT_ULL(1)) {
324 err = devlink_fmsg_string_put(fmsg, "\n\tRx mirror pkt drop");
328 if (intr_val & BIT_ULL(4)) {
329 err = devlink_fmsg_string_put(fmsg, "\n\tSMQ flush done");
333 err = rvu_report_pair_end(fmsg);
338 intr_val = nix_event_context->nix_af_rvu_err;
339 err = rvu_report_pair_start(fmsg, "NIX_AF_ERR");
342 err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX Error Interrupt Reg ",
343 nix_event_context->nix_af_rvu_err);
346 if (intr_val & BIT_ULL(14)) {
347 err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_INST_S read");
351 if (intr_val & BIT_ULL(13)) {
352 err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_RES_S write");
356 if (intr_val & BIT_ULL(12)) {
357 err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
361 if (intr_val & BIT_ULL(6)) {
362 err = devlink_fmsg_string_put(fmsg, "\n\tRx on unmapped PF_FUNC");
366 if (intr_val & BIT_ULL(5)) {
367 err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast replication error");
371 if (intr_val & BIT_ULL(4)) {
372 err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_RX_MCE_S read");
376 if (intr_val & BIT_ULL(3)) {
377 err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast WQE read");
381 if (intr_val & BIT_ULL(2)) {
382 err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror WQE read");
386 if (intr_val & BIT_ULL(1)) {
387 err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror pkt write");
391 if (intr_val & BIT_ULL(0)) {
392 err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast pkt write");
396 err = rvu_report_pair_end(fmsg);
401 intr_val = nix_event_context->nix_af_rvu_err;
402 err = rvu_report_pair_start(fmsg, "NIX_AF_RAS");
405 err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RAS Interrupt Reg ",
406 nix_event_context->nix_af_rvu_err);
409 err = devlink_fmsg_string_put(fmsg, "\n\tPoison Data on:");
412 if (intr_val & BIT_ULL(34)) {
413 err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_INST_S");
417 if (intr_val & BIT_ULL(33)) {
418 err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_RES_S");
422 if (intr_val & BIT_ULL(32)) {
423 err = devlink_fmsg_string_put(fmsg, "\n\tHW ctx");
427 if (intr_val & BIT_ULL(4)) {
428 err = devlink_fmsg_string_put(fmsg, "\n\tPacket from mirror buffer");
432 if (intr_val & BIT_ULL(3)) {
433 err = devlink_fmsg_string_put(fmsg, "\n\tPacket from multicast buffer");
438 if (intr_val & BIT_ULL(2)) {
439 err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from mirror buffer");
443 if (intr_val & BIT_ULL(1)) {
444 err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from multicast buffer");
448 if (intr_val & BIT_ULL(0)) {
449 err = devlink_fmsg_string_put(fmsg, "\n\tNIX_RX_MCE_S read");
453 err = rvu_report_pair_end(fmsg);
464 static int rvu_hw_nix_intr_dump(struct devlink_health_reporter *reporter,
465 struct devlink_fmsg *fmsg, void *ctx,
466 struct netlink_ext_ack *netlink_extack)
468 struct rvu *rvu = devlink_health_reporter_priv(reporter);
469 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
470 struct rvu_nix_event_ctx *nix_ctx;
472 nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
474 return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_INTR) :
475 rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_INTR);
478 static int rvu_hw_nix_intr_recover(struct devlink_health_reporter *reporter,
479 void *ctx, struct netlink_ext_ack *netlink_extack)
481 struct rvu *rvu = devlink_health_reporter_priv(reporter);
482 struct rvu_nix_event_ctx *nix_event_ctx = ctx;
485 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
489 if (nix_event_ctx->nix_af_rvu_int)
490 rvu_write64(rvu, blkaddr, NIX_AF_RVU_INT_ENA_W1S, ~0ULL);
495 static int rvu_hw_nix_gen_dump(struct devlink_health_reporter *reporter,
496 struct devlink_fmsg *fmsg, void *ctx,
497 struct netlink_ext_ack *netlink_extack)
499 struct rvu *rvu = devlink_health_reporter_priv(reporter);
500 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
501 struct rvu_nix_event_ctx *nix_ctx;
503 nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
505 return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_GEN) :
506 rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_GEN);
509 static int rvu_hw_nix_gen_recover(struct devlink_health_reporter *reporter,
510 void *ctx, struct netlink_ext_ack *netlink_extack)
512 struct rvu *rvu = devlink_health_reporter_priv(reporter);
513 struct rvu_nix_event_ctx *nix_event_ctx = ctx;
516 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
520 if (nix_event_ctx->nix_af_rvu_gen)
521 rvu_write64(rvu, blkaddr, NIX_AF_GEN_INT_ENA_W1S, ~0ULL);
526 static int rvu_hw_nix_err_dump(struct devlink_health_reporter *reporter,
527 struct devlink_fmsg *fmsg, void *ctx,
528 struct netlink_ext_ack *netlink_extack)
530 struct rvu *rvu = devlink_health_reporter_priv(reporter);
531 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
532 struct rvu_nix_event_ctx *nix_ctx;
534 nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
536 return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_ERR) :
537 rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_ERR);
540 static int rvu_hw_nix_err_recover(struct devlink_health_reporter *reporter,
541 void *ctx, struct netlink_ext_ack *netlink_extack)
543 struct rvu *rvu = devlink_health_reporter_priv(reporter);
544 struct rvu_nix_event_ctx *nix_event_ctx = ctx;
547 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
551 if (nix_event_ctx->nix_af_rvu_err)
552 rvu_write64(rvu, blkaddr, NIX_AF_ERR_INT_ENA_W1S, ~0ULL);
557 static int rvu_hw_nix_ras_dump(struct devlink_health_reporter *reporter,
558 struct devlink_fmsg *fmsg, void *ctx,
559 struct netlink_ext_ack *netlink_extack)
561 struct rvu *rvu = devlink_health_reporter_priv(reporter);
562 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
563 struct rvu_nix_event_ctx *nix_ctx;
565 nix_ctx = rvu_dl->rvu_nix_health_reporter->nix_event_ctx;
567 return ctx ? rvu_nix_report_show(fmsg, ctx, NIX_AF_RVU_RAS) :
568 rvu_nix_report_show(fmsg, nix_ctx, NIX_AF_RVU_RAS);
571 static int rvu_hw_nix_ras_recover(struct devlink_health_reporter *reporter,
572 void *ctx, struct netlink_ext_ack *netlink_extack)
574 struct rvu *rvu = devlink_health_reporter_priv(reporter);
575 struct rvu_nix_event_ctx *nix_event_ctx = ctx;
578 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
582 if (nix_event_ctx->nix_af_rvu_int)
583 rvu_write64(rvu, blkaddr, NIX_AF_RAS_ENA_W1S, ~0ULL);
588 RVU_REPORTERS(hw_nix_intr);
589 RVU_REPORTERS(hw_nix_gen);
590 RVU_REPORTERS(hw_nix_err);
591 RVU_REPORTERS(hw_nix_ras);
593 static void rvu_nix_health_reporters_destroy(struct rvu_devlink *rvu_dl);
595 static int rvu_nix_register_reporters(struct rvu_devlink *rvu_dl)
597 struct rvu_nix_health_reporters *rvu_reporters;
598 struct rvu_nix_event_ctx *nix_event_context;
599 struct rvu *rvu = rvu_dl->rvu;
601 rvu_reporters = kzalloc(sizeof(*rvu_reporters), GFP_KERNEL);
605 rvu_dl->rvu_nix_health_reporter = rvu_reporters;
606 nix_event_context = kzalloc(sizeof(*nix_event_context), GFP_KERNEL);
607 if (!nix_event_context)
610 rvu_reporters->nix_event_ctx = nix_event_context;
611 rvu_reporters->rvu_hw_nix_intr_reporter =
612 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_intr_reporter_ops, 0, rvu);
613 if (IS_ERR(rvu_reporters->rvu_hw_nix_intr_reporter)) {
614 dev_warn(rvu->dev, "Failed to create hw_nix_intr reporter, err=%ld\n",
615 PTR_ERR(rvu_reporters->rvu_hw_nix_intr_reporter));
616 return PTR_ERR(rvu_reporters->rvu_hw_nix_intr_reporter);
619 rvu_reporters->rvu_hw_nix_gen_reporter =
620 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_gen_reporter_ops, 0, rvu);
621 if (IS_ERR(rvu_reporters->rvu_hw_nix_gen_reporter)) {
622 dev_warn(rvu->dev, "Failed to create hw_nix_gen reporter, err=%ld\n",
623 PTR_ERR(rvu_reporters->rvu_hw_nix_gen_reporter));
624 return PTR_ERR(rvu_reporters->rvu_hw_nix_gen_reporter);
627 rvu_reporters->rvu_hw_nix_err_reporter =
628 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_err_reporter_ops, 0, rvu);
629 if (IS_ERR(rvu_reporters->rvu_hw_nix_err_reporter)) {
630 dev_warn(rvu->dev, "Failed to create hw_nix_err reporter, err=%ld\n",
631 PTR_ERR(rvu_reporters->rvu_hw_nix_err_reporter));
632 return PTR_ERR(rvu_reporters->rvu_hw_nix_err_reporter);
635 rvu_reporters->rvu_hw_nix_ras_reporter =
636 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_nix_ras_reporter_ops, 0, rvu);
637 if (IS_ERR(rvu_reporters->rvu_hw_nix_ras_reporter)) {
638 dev_warn(rvu->dev, "Failed to create hw_nix_ras reporter, err=%ld\n",
639 PTR_ERR(rvu_reporters->rvu_hw_nix_ras_reporter));
640 return PTR_ERR(rvu_reporters->rvu_hw_nix_ras_reporter);
643 rvu_dl->devlink_wq = create_workqueue("rvu_devlink_wq");
644 if (!rvu_dl->devlink_wq)
647 INIT_WORK(&rvu_reporters->intr_work, rvu_nix_intr_work);
648 INIT_WORK(&rvu_reporters->gen_work, rvu_nix_gen_work);
649 INIT_WORK(&rvu_reporters->err_work, rvu_nix_err_work);
650 INIT_WORK(&rvu_reporters->ras_work, rvu_nix_ras_work);
654 rvu_nix_health_reporters_destroy(rvu_dl);
658 static int rvu_nix_health_reporters_create(struct rvu_devlink *rvu_dl)
660 struct rvu *rvu = rvu_dl->rvu;
663 err = rvu_nix_register_reporters(rvu_dl);
665 dev_warn(rvu->dev, "Failed to create nix reporter, err =%d\n",
669 rvu_nix_register_interrupts(rvu);
674 static void rvu_nix_health_reporters_destroy(struct rvu_devlink *rvu_dl)
676 struct rvu_nix_health_reporters *nix_reporters;
677 struct rvu *rvu = rvu_dl->rvu;
679 nix_reporters = rvu_dl->rvu_nix_health_reporter;
681 if (!nix_reporters->rvu_hw_nix_ras_reporter)
683 if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_intr_reporter))
684 devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_intr_reporter);
686 if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_gen_reporter))
687 devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_gen_reporter);
689 if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_err_reporter))
690 devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_err_reporter);
692 if (!IS_ERR_OR_NULL(nix_reporters->rvu_hw_nix_ras_reporter))
693 devlink_health_reporter_destroy(nix_reporters->rvu_hw_nix_ras_reporter);
695 rvu_nix_unregister_interrupts(rvu);
696 kfree(rvu_dl->rvu_nix_health_reporter->nix_event_ctx);
697 kfree(rvu_dl->rvu_nix_health_reporter);
700 static void rvu_npa_intr_work(struct work_struct *work)
702 struct rvu_npa_health_reporters *rvu_npa_health_reporter;
704 rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, intr_work);
705 devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_intr_reporter,
707 rvu_npa_health_reporter->npa_event_ctx);
710 static irqreturn_t rvu_npa_af_rvu_intr_handler(int irq, void *rvu_irq)
712 struct rvu_npa_event_ctx *npa_event_context;
713 struct rvu_devlink *rvu_dl = rvu_irq;
719 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
723 npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
724 intr = rvu_read64(rvu, blkaddr, NPA_AF_RVU_INT);
725 npa_event_context->npa_af_rvu_int = intr;
727 /* Clear interrupts */
728 rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT, intr);
729 rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1C, ~0ULL);
730 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->intr_work);
735 static void rvu_npa_gen_work(struct work_struct *work)
737 struct rvu_npa_health_reporters *rvu_npa_health_reporter;
739 rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, gen_work);
740 devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_gen_reporter,
742 rvu_npa_health_reporter->npa_event_ctx);
745 static irqreturn_t rvu_npa_af_gen_intr_handler(int irq, void *rvu_irq)
747 struct rvu_npa_event_ctx *npa_event_context;
748 struct rvu_devlink *rvu_dl = rvu_irq;
754 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
758 npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
759 intr = rvu_read64(rvu, blkaddr, NPA_AF_GEN_INT);
760 npa_event_context->npa_af_rvu_gen = intr;
762 /* Clear interrupts */
763 rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT, intr);
764 rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1C, ~0ULL);
765 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->gen_work);
770 static void rvu_npa_err_work(struct work_struct *work)
772 struct rvu_npa_health_reporters *rvu_npa_health_reporter;
774 rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, err_work);
775 devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_err_reporter,
777 rvu_npa_health_reporter->npa_event_ctx);
780 static irqreturn_t rvu_npa_af_err_intr_handler(int irq, void *rvu_irq)
782 struct rvu_npa_event_ctx *npa_event_context;
783 struct rvu_devlink *rvu_dl = rvu_irq;
789 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
792 npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
793 intr = rvu_read64(rvu, blkaddr, NPA_AF_ERR_INT);
794 npa_event_context->npa_af_rvu_err = intr;
796 /* Clear interrupts */
797 rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT, intr);
798 rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1C, ~0ULL);
799 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->err_work);
804 static void rvu_npa_ras_work(struct work_struct *work)
806 struct rvu_npa_health_reporters *rvu_npa_health_reporter;
808 rvu_npa_health_reporter = container_of(work, struct rvu_npa_health_reporters, ras_work);
809 devlink_health_report(rvu_npa_health_reporter->rvu_hw_npa_ras_reporter,
810 "HW NPA_AF_RAS Error reported",
811 rvu_npa_health_reporter->npa_event_ctx);
814 static irqreturn_t rvu_npa_af_ras_intr_handler(int irq, void *rvu_irq)
816 struct rvu_npa_event_ctx *npa_event_context;
817 struct rvu_devlink *rvu_dl = rvu_irq;
823 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
827 npa_event_context = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
828 intr = rvu_read64(rvu, blkaddr, NPA_AF_RAS);
829 npa_event_context->npa_af_rvu_ras = intr;
831 /* Clear interrupts */
832 rvu_write64(rvu, blkaddr, NPA_AF_RAS, intr);
833 rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1C, ~0ULL);
834 queue_work(rvu_dl->devlink_wq, &rvu_dl->rvu_npa_health_reporter->ras_work);
839 static void rvu_npa_unregister_interrupts(struct rvu *rvu)
841 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
842 int i, offs, blkaddr;
845 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
849 reg = rvu_read64(rvu, blkaddr, NPA_PRIV_AF_INT_CFG);
852 rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1C, ~0ULL);
853 rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1C, ~0ULL);
854 rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1C, ~0ULL);
855 rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1C, ~0ULL);
857 for (i = 0; i < NPA_AF_INT_VEC_CNT; i++)
858 if (rvu->irq_allocated[offs + i]) {
859 free_irq(pci_irq_vector(rvu->pdev, offs + i), rvu_dl);
860 rvu->irq_allocated[offs + i] = false;
864 static int rvu_npa_register_interrupts(struct rvu *rvu)
869 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
873 /* Get NPA AF MSIX vectors offset. */
874 base = rvu_read64(rvu, blkaddr, NPA_PRIV_AF_INT_CFG) & 0x3ff;
877 "Failed to get NPA_AF_INT vector offsets\n");
881 /* Register and enable NPA_AF_RVU_INT interrupt */
882 rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_RVU,
884 rvu_npa_af_rvu_intr_handler);
887 rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1S, ~0ULL);
889 /* Register and enable NPA_AF_GEN_INT interrupt */
890 rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_GEN,
892 rvu_npa_af_gen_intr_handler);
895 rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1S, ~0ULL);
897 /* Register and enable NPA_AF_ERR_INT interrupt */
898 rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_AF_ERR,
900 rvu_npa_af_err_intr_handler);
903 rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1S, ~0ULL);
905 /* Register and enable NPA_AF_RAS interrupt */
906 rc = rvu_common_request_irq(rvu, base + NPA_AF_INT_VEC_POISON,
908 rvu_npa_af_ras_intr_handler);
911 rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1S, ~0ULL);
915 rvu_npa_unregister_interrupts(rvu);
919 static int rvu_npa_report_show(struct devlink_fmsg *fmsg, void *ctx,
920 enum npa_af_rvu_health health_reporter)
922 struct rvu_npa_event_ctx *npa_event_context;
923 unsigned int alloc_dis, free_dis;
927 npa_event_context = ctx;
928 switch (health_reporter) {
930 intr_val = npa_event_context->npa_af_rvu_gen;
931 err = rvu_report_pair_start(fmsg, "NPA_AF_GENERAL");
934 err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA General Interrupt Reg ",
935 npa_event_context->npa_af_rvu_gen);
938 if (intr_val & BIT_ULL(32)) {
939 err = devlink_fmsg_string_put(fmsg, "\n\tUnmap PF Error");
944 free_dis = FIELD_GET(GENMASK(15, 0), intr_val);
945 if (free_dis & BIT(NPA_INPQ_NIX0_RX)) {
946 err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: free disabled RX");
950 if (free_dis & BIT(NPA_INPQ_NIX0_TX)) {
951 err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:free disabled TX");
955 if (free_dis & BIT(NPA_INPQ_NIX1_RX)) {
956 err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: free disabled RX");
960 if (free_dis & BIT(NPA_INPQ_NIX1_TX)) {
961 err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:free disabled TX");
965 if (free_dis & BIT(NPA_INPQ_SSO)) {
966 err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for SSO");
970 if (free_dis & BIT(NPA_INPQ_TIM)) {
971 err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for TIM");
975 if (free_dis & BIT(NPA_INPQ_DPI)) {
976 err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for DPI");
980 if (free_dis & BIT(NPA_INPQ_AURA_OP)) {
981 err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for AURA");
986 alloc_dis = FIELD_GET(GENMASK(31, 16), intr_val);
987 if (alloc_dis & BIT(NPA_INPQ_NIX0_RX)) {
988 err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: alloc disabled RX");
992 if (alloc_dis & BIT(NPA_INPQ_NIX0_TX)) {
993 err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:alloc disabled TX");
997 if (alloc_dis & BIT(NPA_INPQ_NIX1_RX)) {
998 err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: alloc disabled RX");
1002 if (alloc_dis & BIT(NPA_INPQ_NIX1_TX)) {
1003 err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:alloc disabled TX");
1007 if (alloc_dis & BIT(NPA_INPQ_SSO)) {
1008 err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for SSO");
1012 if (alloc_dis & BIT(NPA_INPQ_TIM)) {
1013 err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for TIM");
1017 if (alloc_dis & BIT(NPA_INPQ_DPI)) {
1018 err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for DPI");
1022 if (alloc_dis & BIT(NPA_INPQ_AURA_OP)) {
1023 err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for AURA");
1027 err = rvu_report_pair_end(fmsg);
1031 case NPA_AF_RVU_ERR:
1032 err = rvu_report_pair_start(fmsg, "NPA_AF_ERR");
1035 err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA Error Interrupt Reg ",
1036 npa_event_context->npa_af_rvu_err);
1040 if (npa_event_context->npa_af_rvu_err & BIT_ULL(14)) {
1041 err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_INST_S read");
1045 if (npa_event_context->npa_af_rvu_err & BIT_ULL(13)) {
1046 err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_RES_S write");
1050 if (npa_event_context->npa_af_rvu_err & BIT_ULL(12)) {
1051 err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
1055 err = rvu_report_pair_end(fmsg);
1059 case NPA_AF_RVU_RAS:
1060 err = rvu_report_pair_start(fmsg, "NPA_AF_RVU_RAS");
1063 err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RAS Interrupt Reg ",
1064 npa_event_context->npa_af_rvu_ras);
1067 if (npa_event_context->npa_af_rvu_ras & BIT_ULL(34)) {
1068 err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_INST_S");
1072 if (npa_event_context->npa_af_rvu_ras & BIT_ULL(33)) {
1073 err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_RES_S");
1077 if (npa_event_context->npa_af_rvu_ras & BIT_ULL(32)) {
1078 err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on HW context");
1082 err = rvu_report_pair_end(fmsg);
1086 case NPA_AF_RVU_INTR:
1087 err = rvu_report_pair_start(fmsg, "NPA_AF_RVU");
1090 err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RVU Interrupt Reg ",
1091 npa_event_context->npa_af_rvu_int);
1094 if (npa_event_context->npa_af_rvu_int & BIT_ULL(0)) {
1095 err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
1099 return rvu_report_pair_end(fmsg);
1107 static int rvu_hw_npa_intr_dump(struct devlink_health_reporter *reporter,
1108 struct devlink_fmsg *fmsg, void *ctx,
1109 struct netlink_ext_ack *netlink_extack)
1111 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1112 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1113 struct rvu_npa_event_ctx *npa_ctx;
1115 npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1117 return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_INTR) :
1118 rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_INTR);
1121 static int rvu_hw_npa_intr_recover(struct devlink_health_reporter *reporter,
1122 void *ctx, struct netlink_ext_ack *netlink_extack)
1124 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1125 struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1128 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1132 if (npa_event_ctx->npa_af_rvu_int)
1133 rvu_write64(rvu, blkaddr, NPA_AF_RVU_INT_ENA_W1S, ~0ULL);
1138 static int rvu_hw_npa_gen_dump(struct devlink_health_reporter *reporter,
1139 struct devlink_fmsg *fmsg, void *ctx,
1140 struct netlink_ext_ack *netlink_extack)
1142 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1143 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1144 struct rvu_npa_event_ctx *npa_ctx;
1146 npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1148 return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_GEN) :
1149 rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_GEN);
1152 static int rvu_hw_npa_gen_recover(struct devlink_health_reporter *reporter,
1153 void *ctx, struct netlink_ext_ack *netlink_extack)
1155 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1156 struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1159 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1163 if (npa_event_ctx->npa_af_rvu_gen)
1164 rvu_write64(rvu, blkaddr, NPA_AF_GEN_INT_ENA_W1S, ~0ULL);
1169 static int rvu_hw_npa_err_dump(struct devlink_health_reporter *reporter,
1170 struct devlink_fmsg *fmsg, void *ctx,
1171 struct netlink_ext_ack *netlink_extack)
1173 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1174 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1175 struct rvu_npa_event_ctx *npa_ctx;
1177 npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1179 return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_ERR) :
1180 rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_ERR);
1183 static int rvu_hw_npa_err_recover(struct devlink_health_reporter *reporter,
1184 void *ctx, struct netlink_ext_ack *netlink_extack)
1186 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1187 struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1190 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1194 if (npa_event_ctx->npa_af_rvu_err)
1195 rvu_write64(rvu, blkaddr, NPA_AF_ERR_INT_ENA_W1S, ~0ULL);
1200 static int rvu_hw_npa_ras_dump(struct devlink_health_reporter *reporter,
1201 struct devlink_fmsg *fmsg, void *ctx,
1202 struct netlink_ext_ack *netlink_extack)
1204 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1205 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1206 struct rvu_npa_event_ctx *npa_ctx;
1208 npa_ctx = rvu_dl->rvu_npa_health_reporter->npa_event_ctx;
1210 return ctx ? rvu_npa_report_show(fmsg, ctx, NPA_AF_RVU_RAS) :
1211 rvu_npa_report_show(fmsg, npa_ctx, NPA_AF_RVU_RAS);
1214 static int rvu_hw_npa_ras_recover(struct devlink_health_reporter *reporter,
1215 void *ctx, struct netlink_ext_ack *netlink_extack)
1217 struct rvu *rvu = devlink_health_reporter_priv(reporter);
1218 struct rvu_npa_event_ctx *npa_event_ctx = ctx;
1221 blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPA, 0);
1225 if (npa_event_ctx->npa_af_rvu_ras)
1226 rvu_write64(rvu, blkaddr, NPA_AF_RAS_ENA_W1S, ~0ULL);
1231 RVU_REPORTERS(hw_npa_intr);
1232 RVU_REPORTERS(hw_npa_gen);
1233 RVU_REPORTERS(hw_npa_err);
1234 RVU_REPORTERS(hw_npa_ras);
1236 static void rvu_npa_health_reporters_destroy(struct rvu_devlink *rvu_dl);
1238 static int rvu_npa_register_reporters(struct rvu_devlink *rvu_dl)
1240 struct rvu_npa_health_reporters *rvu_reporters;
1241 struct rvu_npa_event_ctx *npa_event_context;
1242 struct rvu *rvu = rvu_dl->rvu;
1244 rvu_reporters = kzalloc(sizeof(*rvu_reporters), GFP_KERNEL);
1248 rvu_dl->rvu_npa_health_reporter = rvu_reporters;
1249 npa_event_context = kzalloc(sizeof(*npa_event_context), GFP_KERNEL);
1250 if (!npa_event_context)
1253 rvu_reporters->npa_event_ctx = npa_event_context;
1254 rvu_reporters->rvu_hw_npa_intr_reporter =
1255 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_intr_reporter_ops, 0, rvu);
1256 if (IS_ERR(rvu_reporters->rvu_hw_npa_intr_reporter)) {
1257 dev_warn(rvu->dev, "Failed to create hw_npa_intr reporter, err=%ld\n",
1258 PTR_ERR(rvu_reporters->rvu_hw_npa_intr_reporter));
1259 return PTR_ERR(rvu_reporters->rvu_hw_npa_intr_reporter);
1262 rvu_reporters->rvu_hw_npa_gen_reporter =
1263 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_gen_reporter_ops, 0, rvu);
1264 if (IS_ERR(rvu_reporters->rvu_hw_npa_gen_reporter)) {
1265 dev_warn(rvu->dev, "Failed to create hw_npa_gen reporter, err=%ld\n",
1266 PTR_ERR(rvu_reporters->rvu_hw_npa_gen_reporter));
1267 return PTR_ERR(rvu_reporters->rvu_hw_npa_gen_reporter);
1270 rvu_reporters->rvu_hw_npa_err_reporter =
1271 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_err_reporter_ops, 0, rvu);
1272 if (IS_ERR(rvu_reporters->rvu_hw_npa_err_reporter)) {
1273 dev_warn(rvu->dev, "Failed to create hw_npa_err reporter, err=%ld\n",
1274 PTR_ERR(rvu_reporters->rvu_hw_npa_err_reporter));
1275 return PTR_ERR(rvu_reporters->rvu_hw_npa_err_reporter);
1278 rvu_reporters->rvu_hw_npa_ras_reporter =
1279 devlink_health_reporter_create(rvu_dl->dl, &rvu_hw_npa_ras_reporter_ops, 0, rvu);
1280 if (IS_ERR(rvu_reporters->rvu_hw_npa_ras_reporter)) {
1281 dev_warn(rvu->dev, "Failed to create hw_npa_ras reporter, err=%ld\n",
1282 PTR_ERR(rvu_reporters->rvu_hw_npa_ras_reporter));
1283 return PTR_ERR(rvu_reporters->rvu_hw_npa_ras_reporter);
1286 rvu_dl->devlink_wq = create_workqueue("rvu_devlink_wq");
1287 if (!rvu_dl->devlink_wq)
1290 INIT_WORK(&rvu_reporters->intr_work, rvu_npa_intr_work);
1291 INIT_WORK(&rvu_reporters->err_work, rvu_npa_err_work);
1292 INIT_WORK(&rvu_reporters->gen_work, rvu_npa_gen_work);
1293 INIT_WORK(&rvu_reporters->ras_work, rvu_npa_ras_work);
1297 rvu_npa_health_reporters_destroy(rvu_dl);
1301 static int rvu_npa_health_reporters_create(struct rvu_devlink *rvu_dl)
1303 struct rvu *rvu = rvu_dl->rvu;
1306 err = rvu_npa_register_reporters(rvu_dl);
1308 dev_warn(rvu->dev, "Failed to create npa reporter, err =%d\n",
1312 rvu_npa_register_interrupts(rvu);
1317 static void rvu_npa_health_reporters_destroy(struct rvu_devlink *rvu_dl)
1319 struct rvu_npa_health_reporters *npa_reporters;
1320 struct rvu *rvu = rvu_dl->rvu;
1322 npa_reporters = rvu_dl->rvu_npa_health_reporter;
1324 if (!npa_reporters->rvu_hw_npa_ras_reporter)
1326 if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_intr_reporter))
1327 devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_intr_reporter);
1329 if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_gen_reporter))
1330 devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_gen_reporter);
1332 if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_err_reporter))
1333 devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_err_reporter);
1335 if (!IS_ERR_OR_NULL(npa_reporters->rvu_hw_npa_ras_reporter))
1336 devlink_health_reporter_destroy(npa_reporters->rvu_hw_npa_ras_reporter);
1338 rvu_npa_unregister_interrupts(rvu);
1339 kfree(rvu_dl->rvu_npa_health_reporter->npa_event_ctx);
1340 kfree(rvu_dl->rvu_npa_health_reporter);
1343 static int rvu_health_reporters_create(struct rvu *rvu)
1345 struct rvu_devlink *rvu_dl;
1348 rvu_dl = rvu->rvu_dl;
1349 err = rvu_npa_health_reporters_create(rvu_dl);
1353 return rvu_nix_health_reporters_create(rvu_dl);
1356 static void rvu_health_reporters_destroy(struct rvu *rvu)
1358 struct rvu_devlink *rvu_dl;
1363 rvu_dl = rvu->rvu_dl;
1364 rvu_npa_health_reporters_destroy(rvu_dl);
1365 rvu_nix_health_reporters_destroy(rvu_dl);
1368 /* Devlink Params APIs */
1369 static int rvu_af_dl_dwrr_mtu_validate(struct devlink *devlink, u32 id,
1370 union devlink_param_value val,
1371 struct netlink_ext_ack *extack)
1373 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1374 struct rvu *rvu = rvu_dl->rvu;
1375 int dwrr_mtu = val.vu32;
1376 struct nix_txsch *txsch;
1377 struct nix_hw *nix_hw;
1379 if (!rvu->hw->cap.nix_common_dwrr_mtu) {
1380 NL_SET_ERR_MSG_MOD(extack,
1381 "Setting DWRR_MTU is not supported on this silicon");
1385 if ((dwrr_mtu > 65536 || !is_power_of_2(dwrr_mtu)) &&
1386 (dwrr_mtu != 9728 && dwrr_mtu != 10240)) {
1387 NL_SET_ERR_MSG_MOD(extack,
1388 "Invalid, supported MTUs are 0,2,4,8.16,32,64....4K,8K,32K,64K and 9728, 10240");
1392 nix_hw = get_nix_hw(rvu->hw, BLKADDR_NIX0);
1396 txsch = &nix_hw->txsch[NIX_TXSCH_LVL_SMQ];
1397 if (rvu_rsrc_free_count(&txsch->schq) != txsch->schq.max) {
1398 NL_SET_ERR_MSG_MOD(extack,
1399 "Changing DWRR MTU is not supported when there are active NIXLFs");
1400 NL_SET_ERR_MSG_MOD(extack,
1401 "Make sure none of the PF/VF interfaces are initialized and retry");
1408 static int rvu_af_dl_dwrr_mtu_set(struct devlink *devlink, u32 id,
1409 struct devlink_param_gset_ctx *ctx)
1411 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1412 struct rvu *rvu = rvu_dl->rvu;
1415 dwrr_mtu = convert_bytes_to_dwrr_mtu(ctx->val.vu32);
1416 rvu_write64(rvu, BLKADDR_NIX0, NIX_AF_DWRR_RPM_MTU, dwrr_mtu);
1421 static int rvu_af_dl_dwrr_mtu_get(struct devlink *devlink, u32 id,
1422 struct devlink_param_gset_ctx *ctx)
1424 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1425 struct rvu *rvu = rvu_dl->rvu;
1428 if (!rvu->hw->cap.nix_common_dwrr_mtu)
1431 dwrr_mtu = rvu_read64(rvu, BLKADDR_NIX0, NIX_AF_DWRR_RPM_MTU);
1432 ctx->val.vu32 = convert_dwrr_mtu_to_bytes(dwrr_mtu);
1437 enum rvu_af_dl_param_id {
1438 RVU_AF_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
1439 RVU_AF_DEVLINK_PARAM_ID_DWRR_MTU,
1440 RVU_AF_DEVLINK_PARAM_ID_NPC_EXACT_FEATURE_DISABLE,
1443 static int rvu_af_npc_exact_feature_get(struct devlink *devlink, u32 id,
1444 struct devlink_param_gset_ctx *ctx)
1446 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1447 struct rvu *rvu = rvu_dl->rvu;
1450 enabled = rvu_npc_exact_has_match_table(rvu);
1452 snprintf(ctx->val.vstr, sizeof(ctx->val.vstr), "%s",
1453 enabled ? "enabled" : "disabled");
1458 static int rvu_af_npc_exact_feature_disable(struct devlink *devlink, u32 id,
1459 struct devlink_param_gset_ctx *ctx)
1461 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1462 struct rvu *rvu = rvu_dl->rvu;
1464 rvu_npc_exact_disable_feature(rvu);
1469 static int rvu_af_npc_exact_feature_validate(struct devlink *devlink, u32 id,
1470 union devlink_param_value val,
1471 struct netlink_ext_ack *extack)
1473 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1474 struct rvu *rvu = rvu_dl->rvu;
1477 if (kstrtoull(val.vstr, 10, &enable)) {
1478 NL_SET_ERR_MSG_MOD(extack,
1479 "Only 1 value is supported");
1484 NL_SET_ERR_MSG_MOD(extack,
1485 "Only disabling exact match feature is supported");
1489 if (rvu_npc_exact_can_disable_feature(rvu))
1492 NL_SET_ERR_MSG_MOD(extack,
1493 "Can't disable exact match feature; Please try before any configuration");
1497 static const struct devlink_param rvu_af_dl_params[] = {
1498 DEVLINK_PARAM_DRIVER(RVU_AF_DEVLINK_PARAM_ID_DWRR_MTU,
1499 "dwrr_mtu", DEVLINK_PARAM_TYPE_U32,
1500 BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1501 rvu_af_dl_dwrr_mtu_get, rvu_af_dl_dwrr_mtu_set,
1502 rvu_af_dl_dwrr_mtu_validate),
1503 DEVLINK_PARAM_DRIVER(RVU_AF_DEVLINK_PARAM_ID_NPC_EXACT_FEATURE_DISABLE,
1504 "npc_exact_feature_disable", DEVLINK_PARAM_TYPE_STRING,
1505 BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1506 rvu_af_npc_exact_feature_get,
1507 rvu_af_npc_exact_feature_disable,
1508 rvu_af_npc_exact_feature_validate),
1511 /* Devlink switch mode */
1512 static int rvu_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
1514 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1515 struct rvu *rvu = rvu_dl->rvu;
1516 struct rvu_switch *rswitch;
1518 rswitch = &rvu->rswitch;
1519 *mode = rswitch->mode;
1524 static int rvu_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode,
1525 struct netlink_ext_ack *extack)
1527 struct rvu_devlink *rvu_dl = devlink_priv(devlink);
1528 struct rvu *rvu = rvu_dl->rvu;
1529 struct rvu_switch *rswitch;
1531 rswitch = &rvu->rswitch;
1533 case DEVLINK_ESWITCH_MODE_LEGACY:
1534 case DEVLINK_ESWITCH_MODE_SWITCHDEV:
1535 if (rswitch->mode == mode)
1537 rswitch->mode = mode;
1538 if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
1539 rvu_switch_enable(rvu);
1541 rvu_switch_disable(rvu);
1550 static const struct devlink_ops rvu_devlink_ops = {
1551 .eswitch_mode_get = rvu_devlink_eswitch_mode_get,
1552 .eswitch_mode_set = rvu_devlink_eswitch_mode_set,
1555 int rvu_register_dl(struct rvu *rvu)
1557 struct rvu_devlink *rvu_dl;
1562 dl = devlink_alloc(&rvu_devlink_ops, sizeof(struct rvu_devlink),
1565 dev_warn(rvu->dev, "devlink_alloc failed\n");
1569 rvu_dl = devlink_priv(dl);
1572 rvu->rvu_dl = rvu_dl;
1574 err = rvu_health_reporters_create(rvu);
1577 "devlink health reporter creation failed with error %d\n", err);
1581 /* Register exact match devlink only for CN10K-B */
1582 size = ARRAY_SIZE(rvu_af_dl_params);
1583 if (!rvu_npc_exact_has_match_table(rvu))
1586 err = devlink_params_register(dl, rvu_af_dl_params, size);
1589 "devlink params register failed with error %d", err);
1593 devlink_register(dl);
1597 rvu_health_reporters_destroy(rvu);
1602 void rvu_unregister_dl(struct rvu *rvu)
1604 struct rvu_devlink *rvu_dl = rvu->rvu_dl;
1605 struct devlink *dl = rvu_dl->dl;
1607 devlink_unregister(dl);
1608 devlink_params_unregister(dl, rvu_af_dl_params,
1609 ARRAY_SIZE(rvu_af_dl_params));
1610 rvu_health_reporters_destroy(rvu);