isr_testutils.c

// Copyright lowRISC contributors (OpenTitan project).
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
 
// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND:
// util/autogen_testutils.py
 
#include "sw/device/lib/testing/autogen/isr_testutils.h"
#include "sw/device/lib/dif/dif_base.h"
 
#include "sw/device/lib/dif/dif_rv_plic.h"
#include "sw/device/lib/testing/test_framework/check.h"
 
void isr_testutils_ac_range_check_isr(
    plic_isr_ctx_t plic_ctx, ac_range_check_isr_ctx_t ac_range_check_ctx,
    bool mute_status_irq, top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_ac_range_check_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_ac_range_check_irq_t irq =
      (dif_ac_range_check_irq_t)(plic_irq_id -
                                 ac_range_check_ctx
                                     .plic_ac_range_check_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (ac_range_check_ctx.is_only_irq) {
    dif_ac_range_check_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_ac_range_check_irq_get_state(
        ac_range_check_ctx.ac_range_check, &snapshot));
    CHECK(snapshot == (dif_ac_range_check_irq_state_snapshot_t)(1 << irq),
          "Only ac_range_check IRQ %d expected to fire. Actual IRQ state = %x",
          irq, snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_ac_range_check_irq_get_type(
      ac_range_check_ctx.ac_range_check, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_ac_range_check_irq_acknowledge(
        ac_range_check_ctx.ac_range_check, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_ac_range_check_irq_set_enabled(
        ac_range_check_ctx.ac_range_check, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_acc_isr(plic_isr_ctx_t plic_ctx, acc_isr_ctx_t acc_ctx,
                           top_dragonfly_plic_peripheral_t *peripheral_serviced,
                           dif_acc_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_acc_irq_t irq =
      (dif_acc_irq_t)(plic_irq_id - acc_ctx.plic_acc_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (acc_ctx.is_only_irq) {
    dif_acc_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_acc_irq_get_state(acc_ctx.acc, &snapshot));
    CHECK(snapshot == (dif_acc_irq_state_snapshot_t)(1 << irq),
          "Only acc IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_acc_irq_get_type(acc_ctx.acc, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_acc_irq_acknowledge(acc_ctx.acc, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_alert_handler_isr(
    plic_isr_ctx_t plic_ctx, alert_handler_isr_ctx_t alert_handler_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_alert_handler_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_alert_handler_irq_t irq =
      (dif_alert_handler_irq_t)(plic_irq_id -
                                alert_handler_ctx
                                    .plic_alert_handler_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (alert_handler_ctx.is_only_irq) {
    dif_alert_handler_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_alert_handler_irq_get_state(
        alert_handler_ctx.alert_handler, &snapshot));
    CHECK(snapshot == (dif_alert_handler_irq_state_snapshot_t)(1 << irq),
          "Only alert_handler IRQ %d expected to fire. Actual IRQ state = %x",
          irq, snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_alert_handler_irq_get_type(alert_handler_ctx.alert_handler,
                                              irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_alert_handler_irq_acknowledge(
        alert_handler_ctx.alert_handler, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_aon_timer_isr(
    plic_isr_ctx_t plic_ctx, aon_timer_isr_ctx_t aon_timer_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_aon_timer_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_aon_timer_irq_t irq =
      (dif_aon_timer_irq_t)(plic_irq_id -
                            aon_timer_ctx.plic_aon_timer_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (aon_timer_ctx.is_only_irq) {
    dif_aon_timer_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(
        dif_aon_timer_irq_get_state(aon_timer_ctx.aon_timer, &snapshot));
    CHECK(snapshot == (dif_aon_timer_irq_state_snapshot_t)(1 << irq),
          "Only aon_timer IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_aon_timer_irq_get_type(aon_timer_ctx.aon_timer, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_aon_timer_irq_acknowledge(aon_timer_ctx.aon_timer, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_csrng_isr(
    plic_isr_ctx_t plic_ctx, csrng_isr_ctx_t csrng_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_csrng_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_csrng_irq_t irq =
      (dif_csrng_irq_t)(plic_irq_id - csrng_ctx.plic_csrng_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (csrng_ctx.is_only_irq) {
    dif_csrng_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_csrng_irq_get_state(csrng_ctx.csrng, &snapshot));
    CHECK(snapshot == (dif_csrng_irq_state_snapshot_t)(1 << irq),
          "Only csrng IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_csrng_irq_get_type(csrng_ctx.csrng, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_csrng_irq_acknowledge(csrng_ctx.csrng, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_dma_isr(plic_isr_ctx_t plic_ctx, dma_isr_ctx_t dma_ctx,
                           bool mute_status_irq,
                           top_dragonfly_plic_peripheral_t *peripheral_serviced,
                           dif_dma_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_dma_irq_t irq =
      (dif_dma_irq_t)(plic_irq_id - dma_ctx.plic_dma_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (dma_ctx.is_only_irq) {
    dif_dma_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_dma_irq_get_state(dma_ctx.dma, &snapshot));
    CHECK(snapshot == (dif_dma_irq_state_snapshot_t)(1 << irq),
          "Only dma IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_dma_irq_get_type(dma_ctx.dma, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_dma_irq_acknowledge(dma_ctx.dma, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_dma_irq_set_enabled(dma_ctx.dma, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_edn_isr(plic_isr_ctx_t plic_ctx, edn_isr_ctx_t edn_ctx,
                           top_dragonfly_plic_peripheral_t *peripheral_serviced,
                           dif_edn_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_edn_irq_t irq =
      (dif_edn_irq_t)(plic_irq_id - edn_ctx.plic_edn_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (edn_ctx.is_only_irq) {
    dif_edn_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_edn_irq_get_state(edn_ctx.edn, &snapshot));
    CHECK(snapshot == (dif_edn_irq_state_snapshot_t)(1 << irq),
          "Only edn IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_edn_irq_get_type(edn_ctx.edn, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_edn_irq_acknowledge(edn_ctx.edn, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_entropy_src_isr(
    plic_isr_ctx_t plic_ctx, entropy_src_isr_ctx_t entropy_src_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_entropy_src_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_entropy_src_irq_t irq =
      (dif_entropy_src_irq_t)(plic_irq_id -
                              entropy_src_ctx.plic_entropy_src_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (entropy_src_ctx.is_only_irq) {
    dif_entropy_src_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(
        dif_entropy_src_irq_get_state(entropy_src_ctx.entropy_src, &snapshot));
    CHECK(snapshot == (dif_entropy_src_irq_state_snapshot_t)(1 << irq),
          "Only entropy_src IRQ %d expected to fire. Actual IRQ state = %x",
          irq, snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(
      dif_entropy_src_irq_get_type(entropy_src_ctx.entropy_src, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(
        dif_entropy_src_irq_acknowledge(entropy_src_ctx.entropy_src, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_gpio_isr(
    plic_isr_ctx_t plic_ctx, gpio_isr_ctx_t gpio_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_gpio_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_gpio_irq_t irq =
      (dif_gpio_irq_t)(plic_irq_id - gpio_ctx.plic_gpio_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (gpio_ctx.is_only_irq) {
    dif_gpio_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_gpio_irq_get_state(gpio_ctx.gpio, &snapshot));
    CHECK(snapshot == (dif_gpio_irq_state_snapshot_t)(1 << irq),
          "Only gpio IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_gpio_irq_get_type(gpio_ctx.gpio, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_gpio_irq_acknowledge(gpio_ctx.gpio, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_hmac_isr(
    plic_isr_ctx_t plic_ctx, hmac_isr_ctx_t hmac_ctx, bool mute_status_irq,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_hmac_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_hmac_irq_t irq =
      (dif_hmac_irq_t)(plic_irq_id - hmac_ctx.plic_hmac_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (hmac_ctx.is_only_irq) {
    dif_hmac_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_hmac_irq_get_state(hmac_ctx.hmac, &snapshot));
    CHECK(snapshot == (dif_hmac_irq_state_snapshot_t)(1 << irq),
          "Only hmac IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_hmac_irq_get_type(hmac_ctx.hmac, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_hmac_irq_acknowledge(hmac_ctx.hmac, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(
        dif_hmac_irq_set_enabled(hmac_ctx.hmac, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_i2c_isr(plic_isr_ctx_t plic_ctx, i2c_isr_ctx_t i2c_ctx,
                           bool mute_status_irq,
                           top_dragonfly_plic_peripheral_t *peripheral_serviced,
                           dif_i2c_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_i2c_irq_t irq =
      (dif_i2c_irq_t)(plic_irq_id - i2c_ctx.plic_i2c_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (i2c_ctx.is_only_irq) {
    dif_i2c_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_i2c_irq_get_state(i2c_ctx.i2c, &snapshot));
    CHECK(snapshot == (dif_i2c_irq_state_snapshot_t)(1 << irq),
          "Only i2c IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_i2c_irq_get_type(i2c_ctx.i2c, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_i2c_irq_acknowledge(i2c_ctx.i2c, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_i2c_irq_set_enabled(i2c_ctx.i2c, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_keymgr_dpe_isr(
    plic_isr_ctx_t plic_ctx, keymgr_dpe_isr_ctx_t keymgr_dpe_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_keymgr_dpe_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_keymgr_dpe_irq_t irq =
      (dif_keymgr_dpe_irq_t)(plic_irq_id -
                             keymgr_dpe_ctx.plic_keymgr_dpe_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (keymgr_dpe_ctx.is_only_irq) {
    dif_keymgr_dpe_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(
        dif_keymgr_dpe_irq_get_state(keymgr_dpe_ctx.keymgr_dpe, &snapshot));
    CHECK(snapshot == (dif_keymgr_dpe_irq_state_snapshot_t)(1 << irq),
          "Only keymgr_dpe IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(
      dif_keymgr_dpe_irq_get_type(keymgr_dpe_ctx.keymgr_dpe, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(
        dif_keymgr_dpe_irq_acknowledge(keymgr_dpe_ctx.keymgr_dpe, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_kmac_isr(
    plic_isr_ctx_t plic_ctx, kmac_isr_ctx_t kmac_ctx, bool mute_status_irq,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_kmac_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_kmac_irq_t irq =
      (dif_kmac_irq_t)(plic_irq_id - kmac_ctx.plic_kmac_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (kmac_ctx.is_only_irq) {
    dif_kmac_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_kmac_irq_get_state(kmac_ctx.kmac, &snapshot));
    CHECK(snapshot == (dif_kmac_irq_state_snapshot_t)(1 << irq),
          "Only kmac IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_kmac_irq_get_type(kmac_ctx.kmac, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_kmac_irq_acknowledge(kmac_ctx.kmac, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(
        dif_kmac_irq_set_enabled(kmac_ctx.kmac, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_mbx_isr(plic_isr_ctx_t plic_ctx, mbx_isr_ctx_t mbx_ctx,
                           top_dragonfly_plic_peripheral_t *peripheral_serviced,
                           dif_mbx_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_mbx_irq_t irq =
      (dif_mbx_irq_t)(plic_irq_id - mbx_ctx.plic_mbx_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (mbx_ctx.is_only_irq) {
    dif_mbx_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_mbx_irq_get_state(mbx_ctx.mbx, &snapshot));
    CHECK(snapshot == (dif_mbx_irq_state_snapshot_t)(1 << irq),
          "Only mbx IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_mbx_irq_get_type(mbx_ctx.mbx, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_mbx_irq_acknowledge(mbx_ctx.mbx, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_otp_ctrl_isr(
    plic_isr_ctx_t plic_ctx, otp_ctrl_isr_ctx_t otp_ctrl_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_otp_ctrl_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_otp_ctrl_irq_t irq =
      (dif_otp_ctrl_irq_t)(plic_irq_id -
                           otp_ctrl_ctx.plic_otp_ctrl_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (otp_ctrl_ctx.is_only_irq) {
    dif_otp_ctrl_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_otp_ctrl_irq_get_state(otp_ctrl_ctx.otp_ctrl, &snapshot));
    CHECK(snapshot == (dif_otp_ctrl_irq_state_snapshot_t)(1 << irq),
          "Only otp_ctrl IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_otp_ctrl_irq_get_type(otp_ctrl_ctx.otp_ctrl, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_otp_ctrl_irq_acknowledge(otp_ctrl_ctx.otp_ctrl, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_pwrmgr_isr(
    plic_isr_ctx_t plic_ctx, pwrmgr_isr_ctx_t pwrmgr_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_pwrmgr_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_pwrmgr_irq_t irq =
      (dif_pwrmgr_irq_t)(plic_irq_id - pwrmgr_ctx.plic_pwrmgr_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (pwrmgr_ctx.is_only_irq) {
    dif_pwrmgr_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_pwrmgr_irq_get_state(pwrmgr_ctx.pwrmgr, &snapshot));
    CHECK(snapshot == (dif_pwrmgr_irq_state_snapshot_t)(1 << irq),
          "Only pwrmgr IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_pwrmgr_irq_get_type(pwrmgr_ctx.pwrmgr, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_pwrmgr_irq_acknowledge(pwrmgr_ctx.pwrmgr, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_racl_ctrl_isr(
    plic_isr_ctx_t plic_ctx, racl_ctrl_isr_ctx_t racl_ctrl_ctx,
    bool mute_status_irq, top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_racl_ctrl_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_racl_ctrl_irq_t irq =
      (dif_racl_ctrl_irq_t)(plic_irq_id -
                            racl_ctrl_ctx.plic_racl_ctrl_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (racl_ctrl_ctx.is_only_irq) {
    dif_racl_ctrl_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(
        dif_racl_ctrl_irq_get_state(racl_ctrl_ctx.racl_ctrl, &snapshot));
    CHECK(snapshot == (dif_racl_ctrl_irq_state_snapshot_t)(1 << irq),
          "Only racl_ctrl IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_racl_ctrl_irq_get_type(racl_ctrl_ctx.racl_ctrl, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_racl_ctrl_irq_acknowledge(racl_ctrl_ctx.racl_ctrl, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_racl_ctrl_irq_set_enabled(racl_ctrl_ctx.racl_ctrl, irq,
                                               kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_rv_timer_isr(
    plic_isr_ctx_t plic_ctx, rv_timer_isr_ctx_t rv_timer_ctx,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_rv_timer_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_rv_timer_irq_t irq =
      (dif_rv_timer_irq_t)(plic_irq_id -
                           rv_timer_ctx.plic_rv_timer_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (rv_timer_ctx.is_only_irq) {
    dif_rv_timer_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_rv_timer_irq_get_state(rv_timer_ctx.rv_timer,
                                            plic_ctx.hart_id, &snapshot));
    CHECK(snapshot == (dif_rv_timer_irq_state_snapshot_t)(1 << irq),
          "Only rv_timer IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_rv_timer_irq_get_type(rv_timer_ctx.rv_timer, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_rv_timer_irq_acknowledge(rv_timer_ctx.rv_timer, irq));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_spi_device_isr(
    plic_isr_ctx_t plic_ctx, spi_device_isr_ctx_t spi_device_ctx,
    bool mute_status_irq, top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_spi_device_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_spi_device_irq_t irq =
      (dif_spi_device_irq_t)(plic_irq_id -
                             spi_device_ctx.plic_spi_device_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (spi_device_ctx.is_only_irq) {
    dif_spi_device_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(
        dif_spi_device_irq_get_state(spi_device_ctx.spi_device, &snapshot));
    CHECK(snapshot == (dif_spi_device_irq_state_snapshot_t)(1 << irq),
          "Only spi_device IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(
      dif_spi_device_irq_get_type(spi_device_ctx.spi_device, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(
        dif_spi_device_irq_acknowledge(spi_device_ctx.spi_device, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_spi_device_irq_set_enabled(spi_device_ctx.spi_device, irq,
                                                kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_spi_host_isr(
    plic_isr_ctx_t plic_ctx, spi_host_isr_ctx_t spi_host_ctx,
    bool mute_status_irq, top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_spi_host_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_spi_host_irq_t irq =
      (dif_spi_host_irq_t)(plic_irq_id -
                           spi_host_ctx.plic_spi_host_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (spi_host_ctx.is_only_irq) {
    dif_spi_host_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_spi_host_irq_get_state(spi_host_ctx.spi_host, &snapshot));
    CHECK(snapshot == (dif_spi_host_irq_state_snapshot_t)(1 << irq),
          "Only spi_host IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_spi_host_irq_get_type(spi_host_ctx.spi_host, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_spi_host_irq_acknowledge(spi_host_ctx.spi_host, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(dif_spi_host_irq_set_enabled(spi_host_ctx.spi_host, irq,
                                              kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}
 
void isr_testutils_uart_isr(
    plic_isr_ctx_t plic_ctx, uart_isr_ctx_t uart_ctx, bool mute_status_irq,
    top_dragonfly_plic_peripheral_t *peripheral_serviced,
    dif_uart_irq_t *irq_serviced) {
 
  // Claim the IRQ at the PLIC.
  dif_rv_plic_irq_id_t plic_irq_id;
  CHECK_DIF_OK(
      dif_rv_plic_irq_claim(plic_ctx.rv_plic, plic_ctx.hart_id, &plic_irq_id));
 
  // Get the peripheral the IRQ belongs to.
  *peripheral_serviced = (top_dragonfly_plic_peripheral_t)
      top_dragonfly_plic_interrupt_for_peripheral[plic_irq_id];
 
  // Get the IRQ that was fired from the PLIC IRQ ID.
  dif_uart_irq_t irq =
      (dif_uart_irq_t)(plic_irq_id - uart_ctx.plic_uart_start_irq_id);
  *irq_serviced = irq;
 
  // Check if it is supposed to be the only IRQ fired.
  if (uart_ctx.is_only_irq) {
    dif_uart_irq_state_snapshot_t snapshot;
    CHECK_DIF_OK(dif_uart_irq_get_state(uart_ctx.uart, &snapshot));
    CHECK(snapshot == (dif_uart_irq_state_snapshot_t)(1 << irq),
          "Only uart IRQ %d expected to fire. Actual IRQ state = %x", irq,
          snapshot);
  }
 
  // Acknowledge the IRQ at the peripheral if IRQ is of the event type.
  dif_irq_type_t type;
  CHECK_DIF_OK(dif_uart_irq_get_type(uart_ctx.uart, irq, &type));
  if (type == kDifIrqTypeEvent) {
    CHECK_DIF_OK(dif_uart_irq_acknowledge(uart_ctx.uart, irq));
  } else if (mute_status_irq) {
    CHECK_DIF_OK(
        dif_uart_irq_set_enabled(uart_ctx.uart, irq, kDifToggleDisabled));
  }
 
  // Complete the IRQ at the PLIC.
  CHECK_DIF_OK(dif_rv_plic_irq_complete(plic_ctx.rv_plic, plic_ctx.hart_id,
                                        plic_irq_id));
}