[dif] Add DIFs to acknowledge a snapshot of IRQs
In issue #17349, alees24 identified a deficiency in the available
functions for acknowledging IRQs: The choices were a single IRQ or all
of them.
Add a set of DIFs for acknowledging the precise set of IRQs that were
retrieved at the time of calling dif_<IP>_irq_get_state() so multiple
IRQs may be acknowledged at once, but IRQs that were not observed do not
get inadvertently cleared.
Signed-off-by: Alexander Williams <awill@opentitan.org>
diff --git a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c
index 0680470..f265a8c 100644
--- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c
@@ -95,6 +95,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_adc_ctrl_irq_acknowledge_state(
+ const dif_adc_ctrl_t *adc_ctrl,
+ dif_adc_ctrl_irq_state_snapshot_t snapshot) {
+ if (adc_ctrl == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(adc_ctrl->base_addr, ADC_CTRL_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_adc_ctrl_irq_is_pending(const dif_adc_ctrl_t *adc_ctrl,
dif_adc_ctrl_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h
index 5bb7446..7af546f 100644
--- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h
@@ -86,7 +86,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_adc_ctrl_irq_get_state()`
- * function.
+ * and `dif_adc_ctrl_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_adc_ctrl_irq_state_snapshot_t;
@@ -129,6 +129,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param adc_ctrl A adc_ctrl handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_adc_ctrl_irq_acknowledge_state(
+ const dif_adc_ctrl_t *adc_ctrl, dif_adc_ctrl_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen_unittest.cc
index 94d25ae..a52b81d 100644
--- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen_unittest.cc
@@ -150,6 +150,35 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public AdcCtrlTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_adc_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_adc_ctrl_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_adc_ctrl_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(ADC_CTRL_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_adc_ctrl_irq_acknowledge_state(&adc_ctrl_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_adc_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(ADC_CTRL_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_adc_ctrl_irq_get_state(&adc_ctrl_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public AdcCtrlTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c
index 98aa6a3..37fa6b9 100644
--- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c
@@ -86,6 +86,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_alert_handler_irq_acknowledge_state(
+ const dif_alert_handler_t *alert_handler,
+ dif_alert_handler_irq_state_snapshot_t snapshot) {
+ if (alert_handler == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(alert_handler->base_addr,
+ ALERT_HANDLER_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_alert_handler_irq_is_pending(
const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h
index 8cece9a..d3540a0 100644
--- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h
@@ -80,7 +80,8 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the
- * `dif_alert_handler_irq_get_state()` function.
+ * `dif_alert_handler_irq_get_state()` and
+ * `dif_alert_handler_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_alert_handler_irq_state_snapshot_t;
@@ -123,6 +124,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param alert_handler A alert_handler handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_alert_handler_irq_acknowledge_state(
+ const dif_alert_handler_t *alert_handler,
+ dif_alert_handler_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_alert_handler_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_alert_handler_autogen_unittest.cc
index 6995596..a1b1e6e 100644
--- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_alert_handler_autogen_unittest.cc
@@ -141,6 +141,38 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public AlertHandlerTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_alert_handler_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_alert_handler_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 4;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_alert_handler_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_alert_handler_irq_acknowledge_state(&alert_handler_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_alert_handler_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(
+ dif_alert_handler_irq_get_state(&alert_handler_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public AlertHandlerTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c
index f15a357..211f913 100644
--- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c
@@ -108,6 +108,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_aon_timer_irq_acknowledge_state(
+ const dif_aon_timer_t *aon_timer,
+ dif_aon_timer_irq_state_snapshot_t snapshot) {
+ if (aon_timer == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(aon_timer->base_addr, AON_TIMER_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_aon_timer_irq_is_pending(const dif_aon_timer_t *aon_timer,
dif_aon_timer_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h
index 65ef415..b5d5c0d 100644
--- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h
@@ -91,7 +91,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_aon_timer_irq_get_state()`
- * function.
+ * and `dif_aon_timer_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_aon_timer_irq_state_snapshot_t;
@@ -134,6 +134,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param aon_timer A aon_timer handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_aon_timer_irq_acknowledge_state(
+ const dif_aon_timer_t *aon_timer,
+ dif_aon_timer_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_aon_timer_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_aon_timer_autogen_unittest.cc
index 7b12ab4..519ec39 100644
--- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_aon_timer_autogen_unittest.cc
@@ -159,6 +159,36 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public AonTimerTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_aon_timer_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_aon_timer_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_aon_timer_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(AON_TIMER_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_aon_timer_irq_acknowledge_state(&aon_timer_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_aon_timer_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(AON_TIMER_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_aon_timer_irq_get_state(&aon_timer_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public AonTimerTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen.c b/sw/device/lib/dif/autogen/dif_csrng_autogen.c
index cee1b5b..05d5874 100644
--- a/sw/device/lib/dif/autogen/dif_csrng_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_csrng_autogen.c
@@ -106,6 +106,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_csrng_irq_acknowledge_state(
+ const dif_csrng_t *csrng, dif_csrng_irq_state_snapshot_t snapshot) {
+ if (csrng == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(csrng->base_addr, CSRNG_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_csrng_irq_is_pending(const dif_csrng_t *csrng,
dif_csrng_irq_t irq, bool *is_pending) {
if (csrng == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen.h b/sw/device/lib/dif/autogen/dif_csrng_autogen.h
index 7683b6d..1cbdb9a 100644
--- a/sw/device/lib/dif/autogen/dif_csrng_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_csrng_autogen.h
@@ -105,7 +105,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_csrng_irq_get_state()`
- * function.
+ * and `dif_csrng_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_csrng_irq_state_snapshot_t;
@@ -145,6 +145,18 @@
dif_csrng_irq_t irq, bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param csrng A csrng handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_csrng_irq_acknowledge_state(
+ const dif_csrng_t *csrng, dif_csrng_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc
index be67563..edb3bc3 100644
--- a/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc
@@ -161,6 +161,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public CsrngTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_csrng_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_csrng_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 4;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_csrng_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(CSRNG_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_csrng_irq_acknowledge_state(&csrng_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_csrng_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(CSRNG_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_csrng_irq_get_state(&csrng_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public CsrngTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen.c b/sw/device/lib/dif/autogen/dif_edn_autogen.c
index 1bff568..eed57b5 100644
--- a/sw/device/lib/dif/autogen/dif_edn_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_edn_autogen.c
@@ -97,6 +97,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_edn_irq_acknowledge_state(
+ const dif_edn_t *edn, dif_edn_irq_state_snapshot_t snapshot) {
+ if (edn == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(edn->base_addr, EDN_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_edn_irq_is_pending(const dif_edn_t *edn, dif_edn_irq_t irq,
bool *is_pending) {
if (edn == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen.h b/sw/device/lib/dif/autogen/dif_edn_autogen.h
index 024a5e7..e8cea11 100644
--- a/sw/device/lib/dif/autogen/dif_edn_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_edn_autogen.h
@@ -93,7 +93,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_edn_irq_get_state()`
- * function.
+ * and `dif_edn_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_edn_irq_state_snapshot_t;
@@ -133,6 +133,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param edn A edn handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_edn_irq_acknowledge_state(
+ const dif_edn_t *edn, dif_edn_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc
index 80a628a..b3264f4 100644
--- a/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc
@@ -159,6 +159,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public EdnTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_edn_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_edn_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_edn_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(EDN_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_edn_irq_acknowledge_state(&edn_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_edn_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(EDN_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_edn_irq_get_state(&edn_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public EdnTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c
index 1931113..d9fc7d8 100644
--- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c
@@ -111,6 +111,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_entropy_src_irq_acknowledge_state(
+ const dif_entropy_src_t *entropy_src,
+ dif_entropy_src_irq_state_snapshot_t snapshot) {
+ if (entropy_src == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(entropy_src->base_addr, ENTROPY_SRC_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_entropy_src_irq_is_pending(
const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h
index a69a1b1..880234a 100644
--- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h
@@ -106,7 +106,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_entropy_src_irq_get_state()`
- * function.
+ * and `dif_entropy_src_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_entropy_src_irq_state_snapshot_t;
@@ -149,6 +149,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param entropy_src A entropy_src handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_entropy_src_irq_acknowledge_state(
+ const dif_entropy_src_t *entropy_src,
+ dif_entropy_src_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_entropy_src_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_entropy_src_autogen_unittest.cc
index 333c8f6..509687d 100644
--- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_entropy_src_autogen_unittest.cc
@@ -165,6 +165,37 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public EntropySrcTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_entropy_src_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_entropy_src_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 4;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_entropy_src_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_entropy_src_irq_acknowledge_state(&entropy_src_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_entropy_src_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_entropy_src_irq_get_state(&entropy_src_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public EntropySrcTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c
index 2a76903..818dcb8 100644
--- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c
@@ -124,6 +124,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_flash_ctrl_irq_acknowledge_state(
+ const dif_flash_ctrl_t *flash_ctrl,
+ dif_flash_ctrl_irq_state_snapshot_t snapshot) {
+ if (flash_ctrl == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(flash_ctrl->base_addr, FLASH_CTRL_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_flash_ctrl_irq_is_pending(const dif_flash_ctrl_t *flash_ctrl,
dif_flash_ctrl_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h
index 91f064c..b6acb47 100644
--- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h
@@ -123,7 +123,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_flash_ctrl_irq_get_state()`
- * function.
+ * and `dif_flash_ctrl_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_flash_ctrl_irq_state_snapshot_t;
@@ -166,6 +166,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param flash_ctrl A flash_ctrl handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_flash_ctrl_irq_acknowledge_state(
+ const dif_flash_ctrl_t *flash_ctrl,
+ dif_flash_ctrl_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen_unittest.cc
index ae43795..47b01d4 100644
--- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen_unittest.cc
@@ -164,6 +164,37 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public FlashCtrlTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_flash_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_flash_ctrl_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 6;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_flash_ctrl_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(FLASH_CTRL_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_flash_ctrl_irq_acknowledge_state(&flash_ctrl_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_flash_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(FLASH_CTRL_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_flash_ctrl_irq_get_state(&flash_ctrl_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public FlashCtrlTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen.c b/sw/device/lib/dif/autogen/dif_gpio_autogen.c
index 14e8ed6..5f95a75 100644
--- a/sw/device/lib/dif/autogen/dif_gpio_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_gpio_autogen.c
@@ -191,6 +191,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_gpio_irq_acknowledge_state(
+ const dif_gpio_t *gpio, dif_gpio_irq_state_snapshot_t snapshot) {
+ if (gpio == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(gpio->base_addr, GPIO_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_gpio_irq_is_pending(const dif_gpio_t *gpio, dif_gpio_irq_t irq,
bool *is_pending) {
if (gpio == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen.h b/sw/device/lib/dif/autogen/dif_gpio_autogen.h
index e73cfeb..4ac7163 100644
--- a/sw/device/lib/dif/autogen/dif_gpio_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_gpio_autogen.h
@@ -116,7 +116,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_gpio_irq_get_state()`
- * function.
+ * and `dif_gpio_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_gpio_irq_state_snapshot_t;
@@ -156,6 +156,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param gpio A gpio handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_gpio_irq_acknowledge_state(
+ const dif_gpio_t *gpio, dif_gpio_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc
index b349ad5..9e2644b 100644
--- a/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc
@@ -146,6 +146,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public GpioTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_gpio_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_gpio_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 32;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_gpio_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(GPIO_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_gpio_irq_acknowledge_state(&gpio_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_gpio_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(GPIO_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_gpio_irq_get_state(&gpio_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public GpioTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen.c b/sw/device/lib/dif/autogen/dif_hmac_autogen.c
index 11ec824..f5718eb 100644
--- a/sw/device/lib/dif/autogen/dif_hmac_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_hmac_autogen.c
@@ -99,6 +99,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_hmac_irq_acknowledge_state(
+ const dif_hmac_t *hmac, dif_hmac_irq_state_snapshot_t snapshot) {
+ if (hmac == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(hmac->base_addr, HMAC_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_hmac_irq_is_pending(const dif_hmac_t *hmac, dif_hmac_irq_t irq,
bool *is_pending) {
if (hmac == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen.h b/sw/device/lib/dif/autogen/dif_hmac_autogen.h
index c88b1c7..aea7add 100644
--- a/sw/device/lib/dif/autogen/dif_hmac_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_hmac_autogen.h
@@ -93,7 +93,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_hmac_irq_get_state()`
- * function.
+ * and `dif_hmac_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_hmac_irq_state_snapshot_t;
@@ -133,6 +133,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param hmac A hmac handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_hmac_irq_acknowledge_state(
+ const dif_hmac_t *hmac, dif_hmac_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc
index 5334a38..5fbf475 100644
--- a/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc
@@ -153,6 +153,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public HmacTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_hmac_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_hmac_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 3;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_hmac_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(HMAC_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_hmac_irq_acknowledge_state(&hmac_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_hmac_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(HMAC_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_hmac_irq_get_state(&hmac_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public HmacTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen.c b/sw/device/lib/dif/autogen/dif_i2c_autogen.c
index 910d4ad..8c337ff 100644
--- a/sw/device/lib/dif/autogen/dif_i2c_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_i2c_autogen.c
@@ -135,6 +135,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_i2c_irq_acknowledge_state(
+ const dif_i2c_t *i2c, dif_i2c_irq_state_snapshot_t snapshot) {
+ if (i2c == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(i2c->base_addr, I2C_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_i2c_irq_is_pending(const dif_i2c_t *i2c, dif_i2c_irq_t irq,
bool *is_pending) {
if (i2c == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen.h b/sw/device/lib/dif/autogen/dif_i2c_autogen.h
index fb8b9b9..e977a22 100644
--- a/sw/device/lib/dif/autogen/dif_i2c_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_i2c_autogen.h
@@ -153,7 +153,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_i2c_irq_get_state()`
- * function.
+ * and `dif_i2c_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_i2c_irq_state_snapshot_t;
@@ -193,6 +193,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param i2c A i2c handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_i2c_irq_acknowledge_state(
+ const dif_i2c_t *i2c, dif_i2c_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc
index 3d21c3a..9ec9adb 100644
--- a/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc
@@ -154,6 +154,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public I2cTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_i2c_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_i2c_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 15;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_i2c_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(I2C_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_i2c_irq_acknowledge_state(&i2c_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_i2c_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(I2C_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_i2c_irq_get_state(&i2c_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public I2cTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen.c b/sw/device/lib/dif/autogen/dif_keymgr_autogen.c
index ac6f1e8..a1ab67a 100644
--- a/sw/device/lib/dif/autogen/dif_keymgr_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_keymgr_autogen.c
@@ -96,6 +96,19 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_keymgr_irq_acknowledge_state(
+ const dif_keymgr_t *keymgr, dif_keymgr_irq_state_snapshot_t snapshot) {
+ if (keymgr == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(keymgr->base_addr, KEYMGR_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_keymgr_irq_is_pending(const dif_keymgr_t *keymgr,
dif_keymgr_irq_t irq, bool *is_pending) {
if (keymgr == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen.h b/sw/device/lib/dif/autogen/dif_keymgr_autogen.h
index 179c6e4..05a14a2 100644
--- a/sw/device/lib/dif/autogen/dif_keymgr_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_keymgr_autogen.h
@@ -89,7 +89,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_keymgr_irq_get_state()`
- * function.
+ * and `dif_keymgr_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_keymgr_irq_state_snapshot_t;
@@ -130,6 +130,18 @@
dif_keymgr_irq_t irq, bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param keymgr A keymgr handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_keymgr_irq_acknowledge_state(
+ const dif_keymgr_t *keymgr, dif_keymgr_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc
index fea67c7..ecca5e1 100644
--- a/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc
@@ -153,6 +153,35 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public KeymgrTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_keymgr_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_keymgr_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_keymgr_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(KEYMGR_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_keymgr_irq_acknowledge_state(&keymgr_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_keymgr_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(KEYMGR_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_keymgr_irq_get_state(&keymgr_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public KeymgrTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen.c b/sw/device/lib/dif/autogen/dif_kmac_autogen.c
index 9167899..cc0e34c 100644
--- a/sw/device/lib/dif/autogen/dif_kmac_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_kmac_autogen.c
@@ -102,6 +102,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_kmac_irq_acknowledge_state(
+ const dif_kmac_t *kmac, dif_kmac_irq_state_snapshot_t snapshot) {
+ if (kmac == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(kmac->base_addr, KMAC_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_kmac_irq_is_pending(const dif_kmac_t *kmac, dif_kmac_irq_t irq,
bool *is_pending) {
if (kmac == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen.h b/sw/device/lib/dif/autogen/dif_kmac_autogen.h
index acee223..5550025 100644
--- a/sw/device/lib/dif/autogen/dif_kmac_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_kmac_autogen.h
@@ -102,7 +102,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_kmac_irq_get_state()`
- * function.
+ * and `dif_kmac_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_kmac_irq_state_snapshot_t;
@@ -142,6 +142,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param kmac A kmac handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_kmac_irq_acknowledge_state(
+ const dif_kmac_t *kmac, dif_kmac_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc
index 4507e78..13f7045 100644
--- a/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc
@@ -159,6 +159,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public KmacTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_kmac_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_kmac_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 3;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_kmac_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(KMAC_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_kmac_irq_acknowledge_state(&kmac_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_kmac_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(KMAC_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_kmac_irq_get_state(&kmac_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public KmacTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen.c b/sw/device/lib/dif/autogen/dif_otbn_autogen.c
index 5b7b45f..010be29 100644
--- a/sw/device/lib/dif/autogen/dif_otbn_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_otbn_autogen.c
@@ -94,6 +94,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_otbn_irq_acknowledge_state(
+ const dif_otbn_t *otbn, dif_otbn_irq_state_snapshot_t snapshot) {
+ if (otbn == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(otbn->base_addr, OTBN_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_otbn_irq_is_pending(const dif_otbn_t *otbn, dif_otbn_irq_t irq,
bool *is_pending) {
if (otbn == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen.h b/sw/device/lib/dif/autogen/dif_otbn_autogen.h
index 3756262..45defe6 100644
--- a/sw/device/lib/dif/autogen/dif_otbn_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_otbn_autogen.h
@@ -89,7 +89,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_otbn_irq_get_state()`
- * function.
+ * and `dif_otbn_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_otbn_irq_state_snapshot_t;
@@ -129,6 +129,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param otbn A otbn handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_otbn_irq_acknowledge_state(
+ const dif_otbn_t *otbn, dif_otbn_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc
index 4f73b13..1c603a2 100644
--- a/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc
@@ -144,6 +144,35 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public OtbnTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_otbn_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_otbn_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_otbn_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(OTBN_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_otbn_irq_acknowledge_state(&otbn_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_otbn_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(OTBN_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_otbn_irq_get_state(&otbn_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public OtbnTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c
index b6eca4b..720e1b8 100644
--- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c
@@ -111,6 +111,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_otp_ctrl_irq_acknowledge_state(
+ const dif_otp_ctrl_t *otp_ctrl,
+ dif_otp_ctrl_irq_state_snapshot_t snapshot) {
+ if (otp_ctrl == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(otp_ctrl->base_addr, OTP_CTRL_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_otp_ctrl_irq_is_pending(const dif_otp_ctrl_t *otp_ctrl,
dif_otp_ctrl_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h
index af72f23..cdac8f9 100644
--- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h
@@ -110,7 +110,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_otp_ctrl_irq_get_state()`
- * function.
+ * and `dif_otp_ctrl_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_otp_ctrl_irq_state_snapshot_t;
@@ -153,6 +153,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param otp_ctrl A otp_ctrl handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_otp_ctrl_irq_acknowledge_state(
+ const dif_otp_ctrl_t *otp_ctrl, dif_otp_ctrl_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen_unittest.cc
index ad03425..ddedbf3 100644
--- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen_unittest.cc
@@ -164,6 +164,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public OtpCtrlTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_otp_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_otp_ctrl_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_otp_ctrl_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(OTP_CTRL_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_otp_ctrl_irq_acknowledge_state(&otp_ctrl_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_otp_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(OTP_CTRL_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_otp_ctrl_irq_get_state(&otp_ctrl_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public OtpCtrlTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen.c b/sw/device/lib/dif/autogen/dif_pattgen_autogen.c
index d76a9d3..b1b93c5 100644
--- a/sw/device/lib/dif/autogen/dif_pattgen_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_pattgen_autogen.c
@@ -97,6 +97,19 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_pattgen_irq_acknowledge_state(
+ const dif_pattgen_t *pattgen, dif_pattgen_irq_state_snapshot_t snapshot) {
+ if (pattgen == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(pattgen->base_addr, PATTGEN_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_pattgen_irq_is_pending(const dif_pattgen_t *pattgen,
dif_pattgen_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen.h b/sw/device/lib/dif/autogen/dif_pattgen_autogen.h
index cab64b4..d169813 100644
--- a/sw/device/lib/dif/autogen/dif_pattgen_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_pattgen_autogen.h
@@ -89,7 +89,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_pattgen_irq_get_state()`
- * function.
+ * and `dif_pattgen_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_pattgen_irq_state_snapshot_t;
@@ -131,6 +131,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param pattgen A pattgen handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_pattgen_irq_acknowledge_state(
+ const dif_pattgen_t *pattgen, dif_pattgen_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc
index 55aa08a..83cd631 100644
--- a/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc
@@ -157,6 +157,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public PattgenTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_pattgen_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_pattgen_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_pattgen_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(PATTGEN_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_pattgen_irq_acknowledge_state(&pattgen_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_pattgen_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(PATTGEN_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_pattgen_irq_get_state(&pattgen_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public PattgenTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c
index 311a5fa..aad1b97 100644
--- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c
@@ -93,6 +93,19 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_pwrmgr_irq_acknowledge_state(
+ const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_state_snapshot_t snapshot) {
+ if (pwrmgr == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(pwrmgr->base_addr, PWRMGR_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_pwrmgr_irq_is_pending(const dif_pwrmgr_t *pwrmgr,
dif_pwrmgr_irq_t irq, bool *is_pending) {
if (pwrmgr == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h
index 7cdca36..af78fff 100644
--- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h
@@ -85,7 +85,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_pwrmgr_irq_get_state()`
- * function.
+ * and `dif_pwrmgr_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_pwrmgr_irq_state_snapshot_t;
@@ -126,6 +126,18 @@
dif_pwrmgr_irq_t irq, bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param pwrmgr A pwrmgr handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_pwrmgr_irq_acknowledge_state(
+ const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc
index bed7de1..c75e794 100644
--- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc
@@ -146,6 +146,35 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public PwrmgrTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_pwrmgr_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_pwrmgr_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_pwrmgr_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(PWRMGR_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_pwrmgr_irq_acknowledge_state(&pwrmgr_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_pwrmgr_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(PWRMGR_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_pwrmgr_irq_get_state(&pwrmgr_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public PwrmgrTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c
index f7ce78a..f52a477 100644
--- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c
@@ -153,6 +153,27 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_rv_timer_irq_acknowledge_state(
+ const dif_rv_timer_t *rv_timer, uint32_t hart_id,
+ dif_rv_timer_irq_state_snapshot_t snapshot) {
+ if (rv_timer == NULL) {
+ return kDifBadArg;
+ }
+
+ switch (hart_id) {
+ case 0:
+ mmio_region_write32(rv_timer->base_addr, RV_TIMER_INTR_STATE0_REG_OFFSET,
+ snapshot);
+
+ break;
+ default:
+ return kDifBadArg;
+ }
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_rv_timer_irq_is_pending(const dif_rv_timer_t *rv_timer,
dif_rv_timer_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h
index 4c0575f..c2ffc47 100644
--- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h
@@ -86,7 +86,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_rv_timer_irq_get_state()`
- * function.
+ * and `dif_rv_timer_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_rv_timer_irq_state_snapshot_t;
@@ -130,6 +130,20 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param rv_timer A rv_timer handle.
+ * @param hart_id The hart to manipulate.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_rv_timer_irq_acknowledge_state(
+ const dif_rv_timer_t *rv_timer, uint32_t hart_id,
+ dif_rv_timer_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_rv_timer_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rv_timer_autogen_unittest.cc
index 71241c6..e1822af 100644
--- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_rv_timer_autogen_unittest.cc
@@ -151,6 +151,37 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public RvTimerTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_rv_timer_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_rv_timer_irq_acknowledge_state(nullptr, 0, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_rv_timer_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(RV_TIMER_INTR_STATE0_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_rv_timer_irq_acknowledge_state(&rv_timer_, 0, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_rv_timer_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(RV_TIMER_INTR_STATE0_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_rv_timer_irq_get_state(&rv_timer_, 0, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public RvTimerTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c
index 74046a4..34c81b0 100644
--- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c
@@ -103,6 +103,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_sensor_ctrl_irq_acknowledge_state(
+ const dif_sensor_ctrl_t *sensor_ctrl,
+ dif_sensor_ctrl_irq_state_snapshot_t snapshot) {
+ if (sensor_ctrl == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(sensor_ctrl->base_addr, SENSOR_CTRL_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_irq_is_pending(
const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h
index 532a3ca..ebd6410 100644
--- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h
@@ -94,7 +94,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_sensor_ctrl_irq_get_state()`
- * function.
+ * and `dif_sensor_ctrl_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_sensor_ctrl_irq_state_snapshot_t;
@@ -137,6 +137,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param sensor_ctrl A sensor_ctrl handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_sensor_ctrl_irq_acknowledge_state(
+ const dif_sensor_ctrl_t *sensor_ctrl,
+ dif_sensor_ctrl_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen_unittest.cc
index 04c92a6..545ef9c 100644
--- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen_unittest.cc
@@ -165,6 +165,37 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public SensorCtrlTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_sensor_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_sensor_ctrl_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_sensor_ctrl_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_sensor_ctrl_irq_acknowledge_state(&sensor_ctrl_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_sensor_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_sensor_ctrl_irq_get_state(&sensor_ctrl_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public SensorCtrlTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_spi_device_autogen.c b/sw/device/lib/dif/autogen/dif_spi_device_autogen.c
index d9530b2..ca01fc4 100644
--- a/sw/device/lib/dif/autogen/dif_spi_device_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_spi_device_autogen.c
@@ -131,6 +131,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_spi_device_irq_acknowledge_state(
+ const dif_spi_device_t *spi_device,
+ dif_spi_device_irq_state_snapshot_t snapshot) {
+ if (spi_device == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(spi_device->base_addr, SPI_DEVICE_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_spi_device_irq_is_pending(const dif_spi_device_t *spi_device,
dif_spi_device_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_spi_device_autogen.h b/sw/device/lib/dif/autogen/dif_spi_device_autogen.h
index 47b8990..b00c88f 100644
--- a/sw/device/lib/dif/autogen/dif_spi_device_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_spi_device_autogen.h
@@ -136,7 +136,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_spi_device_irq_get_state()`
- * function.
+ * and `dif_spi_device_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_spi_device_irq_state_snapshot_t;
@@ -179,6 +179,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param spi_device A spi_device handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_spi_device_irq_acknowledge_state(
+ const dif_spi_device_t *spi_device,
+ dif_spi_device_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_spi_device_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_spi_device_autogen_unittest.cc
index 79f6f54..14048a4 100644
--- a/sw/device/lib/dif/autogen/dif_spi_device_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_spi_device_autogen_unittest.cc
@@ -159,6 +159,37 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public SpiDeviceTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_spi_device_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_spi_device_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 12;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_spi_device_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(SPI_DEVICE_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_spi_device_irq_acknowledge_state(&spi_device_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_spi_device_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(SPI_DEVICE_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_spi_device_irq_get_state(&spi_device_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public SpiDeviceTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_spi_host_autogen.c b/sw/device/lib/dif/autogen/dif_spi_host_autogen.c
index b0bd395..95efb9b 100644
--- a/sw/device/lib/dif/autogen/dif_spi_host_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_spi_host_autogen.c
@@ -99,6 +99,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_spi_host_irq_acknowledge_state(
+ const dif_spi_host_t *spi_host,
+ dif_spi_host_irq_state_snapshot_t snapshot) {
+ if (spi_host == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(spi_host->base_addr, SPI_HOST_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_spi_host_irq_is_pending(const dif_spi_host_t *spi_host,
dif_spi_host_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_spi_host_autogen.h b/sw/device/lib/dif/autogen/dif_spi_host_autogen.h
index 002248e..52773b2 100644
--- a/sw/device/lib/dif/autogen/dif_spi_host_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_spi_host_autogen.h
@@ -90,7 +90,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_spi_host_irq_get_state()`
- * function.
+ * and `dif_spi_host_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_spi_host_irq_state_snapshot_t;
@@ -133,6 +133,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param spi_host A spi_host handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_spi_host_irq_acknowledge_state(
+ const dif_spi_host_t *spi_host, dif_spi_host_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_spi_host_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_spi_host_autogen_unittest.cc
index e35bccb..65d1cca 100644
--- a/sw/device/lib/dif/autogen/dif_spi_host_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_spi_host_autogen_unittest.cc
@@ -158,6 +158,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public SpiHostTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_spi_host_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_spi_host_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 2;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_spi_host_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(SPI_HOST_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_spi_host_irq_acknowledge_state(&spi_host_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_spi_host_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(SPI_HOST_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_spi_host_irq_get_state(&spi_host_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public SpiHostTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c
index bfadde8..6f5c2f5 100644
--- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c
@@ -96,6 +96,20 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_sysrst_ctrl_irq_acknowledge_state(
+ const dif_sysrst_ctrl_t *sysrst_ctrl,
+ dif_sysrst_ctrl_irq_state_snapshot_t snapshot) {
+ if (sysrst_ctrl == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(sysrst_ctrl->base_addr, SYSRST_CTRL_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_sysrst_ctrl_irq_is_pending(
const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq,
bool *is_pending) {
diff --git a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h
index 050aa2c..5e253c5 100644
--- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h
@@ -87,7 +87,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_sysrst_ctrl_irq_get_state()`
- * function.
+ * and `dif_sysrst_ctrl_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_sysrst_ctrl_irq_state_snapshot_t;
@@ -130,6 +130,19 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param sysrst_ctrl A sysrst_ctrl handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_sysrst_ctrl_irq_acknowledge_state(
+ const dif_sysrst_ctrl_t *sysrst_ctrl,
+ dif_sysrst_ctrl_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen_unittest.cc
index 026a27f..6d53283 100644
--- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen_unittest.cc
@@ -151,6 +151,37 @@
EXPECT_TRUE(irq_state);
}
+class AcknowledgeStateTest : public SysrstCtrlTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_sysrst_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(
+ dif_sysrst_ctrl_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 1;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_sysrst_ctrl_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(
+ dif_sysrst_ctrl_irq_acknowledge_state(&sysrst_ctrl_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_sysrst_ctrl_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_sysrst_ctrl_irq_get_state(&sysrst_ctrl_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public SysrstCtrlTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen.c b/sw/device/lib/dif/autogen/dif_uart_autogen.c
index fd393d9..d68d85b 100644
--- a/sw/device/lib/dif/autogen/dif_uart_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_uart_autogen.c
@@ -113,6 +113,18 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_uart_irq_acknowledge_state(
+ const dif_uart_t *uart, dif_uart_irq_state_snapshot_t snapshot) {
+ if (uart == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(uart->base_addr, UART_INTR_STATE_REG_OFFSET, snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_uart_irq_is_pending(const dif_uart_t *uart, dif_uart_irq_t irq,
bool *is_pending) {
if (uart == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen.h b/sw/device/lib/dif/autogen/dif_uart_autogen.h
index 1366d9c..68d75f8 100644
--- a/sw/device/lib/dif/autogen/dif_uart_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_uart_autogen.h
@@ -114,7 +114,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_uart_irq_get_state()`
- * function.
+ * and `dif_uart_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_uart_irq_state_snapshot_t;
@@ -154,6 +154,18 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param uart A uart handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_uart_irq_acknowledge_state(
+ const dif_uart_t *uart, dif_uart_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc
index 99b152b..9775485 100644
--- a/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc
@@ -154,6 +154,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public UartTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_uart_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_uart_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 8;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_uart_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(UART_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_uart_irq_acknowledge_state(&uart_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_uart_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(UART_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_uart_irq_get_state(&uart_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public UartTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen.c b/sw/device/lib/dif/autogen/dif_usbdev_autogen.c
index 1582aa7..47b8e0a 100644
--- a/sw/device/lib/dif/autogen/dif_usbdev_autogen.c
+++ b/sw/device/lib/dif/autogen/dif_usbdev_autogen.c
@@ -145,6 +145,19 @@
}
OT_WARN_UNUSED_RESULT
+dif_result_t dif_usbdev_irq_acknowledge_state(
+ const dif_usbdev_t *usbdev, dif_usbdev_irq_state_snapshot_t snapshot) {
+ if (usbdev == NULL) {
+ return kDifBadArg;
+ }
+
+ mmio_region_write32(usbdev->base_addr, USBDEV_INTR_STATE_REG_OFFSET,
+ snapshot);
+
+ return kDifOk;
+}
+
+OT_WARN_UNUSED_RESULT
dif_result_t dif_usbdev_irq_is_pending(const dif_usbdev_t *usbdev,
dif_usbdev_irq_t irq, bool *is_pending) {
if (usbdev == NULL || is_pending == NULL) {
diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen.h b/sw/device/lib/dif/autogen/dif_usbdev_autogen.h
index 2897282..293587c 100644
--- a/sw/device/lib/dif/autogen/dif_usbdev_autogen.h
+++ b/sw/device/lib/dif/autogen/dif_usbdev_autogen.h
@@ -170,7 +170,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_usbdev_irq_get_state()`
- * function.
+ * and `dif_usbdev_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_usbdev_irq_state_snapshot_t;
@@ -211,6 +211,18 @@
dif_usbdev_irq_t irq, bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param usbdev A usbdev handle.
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+OT_WARN_UNUSED_RESULT
+dif_result_t dif_usbdev_irq_acknowledge_state(
+ const dif_usbdev_t *usbdev, dif_usbdev_irq_state_snapshot_t snapshot);
+
+/**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc
index 0e549ab..ad3e952 100644
--- a/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc
+++ b/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc
@@ -156,6 +156,35 @@
EXPECT_FALSE(irq_state);
}
+class AcknowledgeStateTest : public UsbdevTest {};
+
+TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_usbdev_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_usbdev_irq_acknowledge_state(nullptr, irq_snapshot));
+}
+
+TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ const uint32_t num_irqs = 17;
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_usbdev_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ EXPECT_WRITE32(USBDEV_INTR_STATE_REG_OFFSET, irq_snapshot);
+ EXPECT_DIF_OK(dif_usbdev_irq_acknowledge_state(&usbdev_, irq_snapshot));
+ }
+}
+
+TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_usbdev_irq_state_snapshot_t irq_snapshot = 0;
+
+ EXPECT_READ32(USBDEV_INTR_STATE_REG_OFFSET, 0);
+ EXPECT_DIF_OK(dif_usbdev_irq_get_state(&usbdev_, &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+}
+
class AcknowledgeAllTest : public UsbdevTest {};
TEST_F(AcknowledgeAllTest, NullArgs) {
diff --git a/util/make_new_dif/templates/dif_autogen.c.tpl b/util/make_new_dif/templates/dif_autogen.c.tpl
index 94a2ad5..cd859d5 100644
--- a/util/make_new_dif/templates/dif_autogen.c.tpl
+++ b/util/make_new_dif/templates/dif_autogen.c.tpl
@@ -248,6 +248,34 @@
}
OT_WARN_UNUSED_RESULT
+ dif_result_t dif_${ip.name_snake}_irq_acknowledge_state(
+ const dif_${ip.name_snake}_t *${ip.name_snake},
+ % if ip.name_snake == "rv_timer":
+ uint32_t hart_id,
+ % endif
+ dif_${ip.name_snake}_irq_state_snapshot_t snapshot) {
+ if (${ip.name_snake} == NULL) {
+ return kDifBadArg;
+ }
+
+ % if ip.name_snake == "rv_timer":
+ switch (hart_id) {
+ % for hart_id in range(int(ip.parameters["N_HARTS"].default)):
+ case ${hart_id}:
+ ${mmio_region_write32("RV_TIMER_INTR_STATE%d_REG_OFFSET" % hart_id, "snapshot")}
+ break;
+ % endfor
+ default:
+ return kDifBadArg;
+ }
+ % else:
+ ${mmio_region_write32(ip.name_upper + "_INTR_STATE_REG_OFFSET", "snapshot")}
+ % endif
+
+ return kDifOk;
+ }
+
+ OT_WARN_UNUSED_RESULT
dif_result_t dif_${ip.name_snake}_irq_is_pending(
const dif_${ip.name_snake}_t *${ip.name_snake},
dif_${ip.name_snake}_irq_t irq,
diff --git a/util/make_new_dif/templates/dif_autogen.h.tpl b/util/make_new_dif/templates/dif_autogen.h.tpl
index 28696a9..4451ed6 100644
--- a/util/make_new_dif/templates/dif_autogen.h.tpl
+++ b/util/make_new_dif/templates/dif_autogen.h.tpl
@@ -120,7 +120,7 @@
* A snapshot of the state of the interrupts for this IP.
*
* This is an opaque type, to be used with the `dif_${ip.name_snake}_irq_get_state()`
- * function.
+ * and `dif_${ip.name_snake}_irq_acknowledge_state()` functions.
*/
typedef uint32_t dif_${ip.name_snake}_irq_state_snapshot_t;
@@ -171,6 +171,25 @@
bool *is_pending);
/**
+ * Acknowledges all interrupts that were pending at the time of the state
+ * snapshot.
+ *
+ * @param ${ip.name_snake} A ${ip.name_snake} handle.
+ % if ip.name_snake == "rv_timer":
+ * @param hart_id The hart to manipulate.
+ % endif
+ * @param snapshot Interrupt state snapshot.
+ * @return The result of the operation.
+ */
+ OT_WARN_UNUSED_RESULT
+ dif_result_t dif_${ip.name_snake}_irq_acknowledge_state(
+ const dif_${ip.name_snake}_t *${ip.name_snake},
+ % if ip.name_snake == "rv_timer":
+ uint32_t hart_id,
+ % endif
+ dif_${ip.name_snake}_irq_state_snapshot_t snapshot);
+
+ /**
* Acknowledges all interrupts, indicating to the hardware that all
* interrupts have been successfully serviced.
*
diff --git a/util/make_new_dif/templates/dif_autogen_unittest.cc.tpl b/util/make_new_dif/templates/dif_autogen_unittest.cc.tpl
index 8549865..70596be 100644
--- a/util/make_new_dif/templates/dif_autogen_unittest.cc.tpl
+++ b/util/make_new_dif/templates/dif_autogen_unittest.cc.tpl
@@ -306,6 +306,65 @@
% endif
}
+ class AcknowledgeStateTest : public ${ip.name_camel}Test {};
+
+ TEST_F(AcknowledgeStateTest, NullArgs) {
+ dif_${ip.name_snake}_irq_state_snapshot_t irq_snapshot = 0;
+ EXPECT_DIF_BADARG(dif_${ip.name_snake}_irq_acknowledge_state(
+ nullptr,
+ % if ip.name_snake == "rv_timer":
+ 0,
+ % endif
+ irq_snapshot
+ ));
+ }
+
+ TEST_F(AcknowledgeStateTest, AckSnapshot) {
+ <%
+ num_irqs = 0
+ for irq in ip.irqs:
+ num_irqs += irq.width
+ %>
+ const uint32_t num_irqs = ${num_irqs};
+ const uint32_t irq_mask = (1u << num_irqs) - 1;
+ dif_${ip.name_snake}_irq_state_snapshot_t irq_snapshot = 1;
+
+ // Test a few snapshots.
+ for (size_t i = 0; i < num_irqs; ++i) {
+ irq_snapshot = ~irq_snapshot & irq_mask;
+ irq_snapshot |= (1u << i);
+ % if ip.name_snake == "rv_timer":
+ EXPECT_WRITE32(${ip.name_upper}_INTR_STATE0_REG_OFFSET,
+ % else:
+ EXPECT_WRITE32(${ip.name_upper}_INTR_STATE_REG_OFFSET,
+ % endif
+ irq_snapshot);
+ EXPECT_DIF_OK(dif_${ip.name_snake}_irq_acknowledge_state(
+ &${ip.name_snake}_,
+ % if ip.name_snake == "rv_timer":
+ 0,
+ % endif
+ irq_snapshot));
+ }
+ }
+
+ TEST_F(AcknowledgeStateTest, SuccessNoneRaised) {
+ dif_${ip.name_snake}_irq_state_snapshot_t irq_snapshot = 0;
+
+ % if ip.name_snake == "rv_timer":
+ EXPECT_READ32(${ip.name_upper}_INTR_STATE0_REG_OFFSET, 0);
+ % else:
+ EXPECT_READ32(${ip.name_upper}_INTR_STATE_REG_OFFSET, 0);
+ % endif
+ EXPECT_DIF_OK(dif_${ip.name_snake}_irq_get_state(
+ &${ip.name_snake}_,
+ % if ip.name_snake == "rv_timer":
+ 0,
+ % endif
+ &irq_snapshot));
+ EXPECT_EQ(irq_snapshot, 0);
+ }
+
class AcknowledgeAllTest : public ${ip.name_camel}Test {};
TEST_F(AcknowledgeAllTest, NullArgs) {
